service: Use nested namespace specifiers where applicable

There were a few places where nested namespace specifiers weren't being
used where they could be within the service code. This amends that to
make the namespacing a tiny bit more compact.

src/core/hle/kernel/thread.h

@@ -15,12 +15,6 @@
 #include "core/hle/kernel/wait_object.h"
 #include "core/hle/result.h"
 
-namespace Kernel {
-
-class KernelCore;
-class Process;
-class Scheduler;
-
 enum ThreadPriority : u32 {
     THREADPRIO_HIGHEST = 0,       ///< Highest thread priority
     THREADPRIO_USERLAND_MAX = 24, ///< Highest thread priority for userland apps
@@ -60,6 +54,12 @@ enum class ThreadWakeupReason {
     Timeout // The thread was woken up due to a wait timeout.
 };
 
+namespace Kernel {
+
+class KernelCore;
+class Process;
+class Scheduler;
+
 class Thread final : public WaitObject {
 public:
     /**

src/core/hle/service/acc/acc_su.h

@@ -6,8 +6,7 @@
 
 #include "core/hle/service/acc/acc.h"
 
-namespace Service {
-namespace Account {
+namespace Service::Account {
 
 class ACC_SU final : public Module::Interface {
 public:
@@ -16,5 +15,4 @@ public:
     ~ACC_SU() override;
 };
 
-} // namespace Account
-} // namespace Service
+} // namespace Service::Account

src/core/hle/service/nvflinger/buffer_queue.cpp

@@ -9,8 +9,7 @@
 #include "core/core.h"
 #include "core/hle/service/nvflinger/buffer_queue.h"
 
-namespace Service {
-namespace NVFlinger {
+namespace Service::NVFlinger {
 
 BufferQueue::BufferQueue(u32 id, u64 layer_id) : id(id), layer_id(layer_id) {
     auto& kernel = Core::System::GetInstance().Kernel();
@@ -104,5 +103,4 @@ u32 BufferQueue::Query(QueryType type) {
     return 0;
 }
 
-} // namespace NVFlinger
-} // namespace Service
+} // namespace Service::NVFlinger

src/core/hle/service/nvflinger/buffer_queue.h

@@ -15,8 +15,7 @@ namespace CoreTiming {
 struct EventType;
 }
 
-namespace Service {
-namespace NVFlinger {
+namespace Service::NVFlinger {
 
 struct IGBPBuffer {
     u32_le magic;
@@ -98,5 +97,4 @@ private:
     Kernel::SharedPtr<Kernel::Event> buffer_wait_event;
 };
 
-} // namespace NVFlinger
-} // namespace Service
+} // namespace Service::NVFlinger

src/core/hle/service/vi/vi.cpp

@@ -514,7 +514,7 @@ private:
                 ctx.SleepClientThread(
                     Kernel::GetCurrentThread(), "IHOSBinderDriver::DequeueBuffer", -1,
                     [=](Kernel::SharedPtr<Kernel::Thread> thread, Kernel::HLERequestContext& ctx,
-                        Kernel::ThreadWakeupReason reason) {
+                        ThreadWakeupReason reason) {
                         // Repeat TransactParcel DequeueBuffer when a buffer is available
                         auto buffer_queue = nv_flinger->GetBufferQueue(id);
                         boost::optional<u32> slot = buffer_queue->DequeueBuffer(width, height);

src/core/loader/nro.cpp

@@ -191,7 +191,7 @@ ResultStatus AppLoader_NRO::Load(Kernel::SharedPtr<Kernel::Process>& process) {
     process->svc_access_mask.set();
     process->resource_limit =
         kernel.ResourceLimitForCategory(Kernel::ResourceLimitCategory::APPLICATION);
-    process->Run(base_addr, Kernel::THREADPRIO_DEFAULT, Memory::DEFAULT_STACK_SIZE);
+    process->Run(base_addr, THREADPRIO_DEFAULT, Memory::DEFAULT_STACK_SIZE);
 
     is_loaded = true;
     return ResultStatus::Success;

src/core/loader/nso.cpp

@@ -157,8 +157,7 @@ ResultStatus AppLoader_NSO::Load(Kernel::SharedPtr<Kernel::Process>& process) {
     process->svc_access_mask.set();
     process->resource_limit =
         kernel.ResourceLimitForCategory(Kernel::ResourceLimitCategory::APPLICATION);
-    process->Run(Memory::PROCESS_IMAGE_VADDR, Kernel::THREADPRIO_DEFAULT,
-                 Memory::DEFAULT_STACK_SIZE);
+    process->Run(Memory::PROCESS_IMAGE_VADDR, THREADPRIO_DEFAULT, Memory::DEFAULT_STACK_SIZE);
 
     is_loaded = true;
     return ResultStatus::Success;

src/yuzu/debugger/wait_tree.cpp

@@ -213,35 +213,35 @@ QString WaitTreeThread::GetText() const {
     const auto& thread = static_cast<const Kernel::Thread&>(object);
     QString status;
     switch (thread.status) {
-    case Kernel::ThreadStatus::Running:
+    case ThreadStatus::Running:
         status = tr("running");
         break;
-    case Kernel::ThreadStatus::Ready:
+    case ThreadStatus::Ready:
         status = tr("ready");
         break;
-    case Kernel::ThreadStatus::WaitHLEEvent:
+    case ThreadStatus::WaitHLEEvent:
         status = tr("waiting for HLE return");
         break;
-    case Kernel::ThreadStatus::WaitSleep:
+    case ThreadStatus::WaitSleep:
         status = tr("sleeping");
         break;
-    case Kernel::ThreadStatus::WaitIPC:
+    case ThreadStatus::WaitIPC:
         status = tr("waiting for IPC reply");
         break;
-    case Kernel::ThreadStatus::WaitSynchAll:
-    case Kernel::ThreadStatus::WaitSynchAny:
+    case ThreadStatus::WaitSynchAll:
+    case ThreadStatus::WaitSynchAny:
         status = tr("waiting for objects");
         break;
-    case Kernel::ThreadStatus::WaitMutex:
+    case ThreadStatus::WaitMutex:
         status = tr("waiting for mutex");
         break;
-    case Kernel::ThreadStatus::WaitArb:
+    case ThreadStatus::WaitArb:
         status = tr("waiting for address arbiter");
         break;
-    case Kernel::ThreadStatus::Dormant:
+    case ThreadStatus::Dormant:
         status = tr("dormant");
         break;
-    case Kernel::ThreadStatus::Dead:
+    case ThreadStatus::Dead:
         status = tr("dead");
         break;
     }
@@ -254,23 +254,23 @@ QString WaitTreeThread::GetText() const {
 QColor WaitTreeThread::GetColor() const {
     const auto& thread = static_cast<const Kernel::Thread&>(object);
     switch (thread.status) {
-    case Kernel::ThreadStatus::Running:
+    case ThreadStatus::Running:
         return QColor(Qt::GlobalColor::darkGreen);
-    case Kernel::ThreadStatus::Ready:
+    case ThreadStatus::Ready:
         return QColor(Qt::GlobalColor::darkBlue);
-    case Kernel::ThreadStatus::WaitHLEEvent:
-    case Kernel::ThreadStatus::WaitIPC:
+    case ThreadStatus::WaitHLEEvent:
+    case ThreadStatus::WaitIPC:
         return QColor(Qt::GlobalColor::darkRed);
-    case Kernel::ThreadStatus::WaitSleep:
+    case ThreadStatus::WaitSleep:
         return QColor(Qt::GlobalColor::darkYellow);
-    case Kernel::ThreadStatus::WaitSynchAll:
-    case Kernel::ThreadStatus::WaitSynchAny:
-    case Kernel::ThreadStatus::WaitMutex:
-    case Kernel::ThreadStatus::WaitArb:
+    case ThreadStatus::WaitSynchAll:
+    case ThreadStatus::WaitSynchAny:
+    case ThreadStatus::WaitMutex:
+    case ThreadStatus::WaitArb:
         return QColor(Qt::GlobalColor::red);
-    case Kernel::ThreadStatus::Dormant:
+    case ThreadStatus::Dormant:
         return QColor(Qt::GlobalColor::darkCyan);
-    case Kernel::ThreadStatus::Dead:
+    case ThreadStatus::Dead:
         return QColor(Qt::GlobalColor::gray);
     default:
         return WaitTreeItem::GetColor();
@@ -284,13 +284,13 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeThread::GetChildren() const {
 
     QString processor;
     switch (thread.processor_id) {
-    case Kernel::ThreadProcessorId::THREADPROCESSORID_DEFAULT:
+    case ThreadProcessorId::THREADPROCESSORID_DEFAULT:
         processor = tr("default");
         break;
-    case Kernel::ThreadProcessorId::THREADPROCESSORID_0:
-    case Kernel::ThreadProcessorId::THREADPROCESSORID_1:
-    case Kernel::ThreadProcessorId::THREADPROCESSORID_2:
-    case Kernel::ThreadProcessorId::THREADPROCESSORID_3:
+    case ThreadProcessorId::THREADPROCESSORID_0:
+    case ThreadProcessorId::THREADPROCESSORID_1:
+    case ThreadProcessorId::THREADPROCESSORID_2:
+    case ThreadProcessorId::THREADPROCESSORID_3:
         processor = tr("core %1").arg(thread.processor_id);
         break;
     default:
@@ -314,8 +314,8 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeThread::GetChildren() const {
     else
         list.push_back(std::make_unique<WaitTreeText>(tr("not waiting for mutex")));
 
-    if (thread.status == Kernel::ThreadStatus::WaitSynchAny ||
-        thread.status == Kernel::ThreadStatus::WaitSynchAll) {
+    if (thread.status == ThreadStatus::WaitSynchAny ||
+        thread.status == ThreadStatus::WaitSynchAll) {
         list.push_back(std::make_unique<WaitTreeObjectList>(thread.wait_objects,
                                                             thread.IsSleepingOnWaitAll()));
     }