kernel/thread: Include thread-related enums within the kernel namespace

Previously, these were sitting outside of the Kernel namespace, which
doesn't really make sense, given they're related to the Thread class
which is within the Kernel namespace.

src/citra_qt/debugger/wait_tree.cpp

@@ -145,32 +145,32 @@ QString WaitTreeThread::GetText() const {
     const auto& thread = static_cast<const Kernel::Thread&>(object);
     QString status;
     switch (thread.status) {
-    case ThreadStatus::Running:
+    case Kernel::ThreadStatus::Running:
         status = tr("running");
         break;
-    case ThreadStatus::Ready:
+    case Kernel::ThreadStatus::Ready:
         status = tr("ready");
         break;
-    case ThreadStatus::WaitArb:
+    case Kernel::ThreadStatus::WaitArb:
         status = tr("waiting for address 0x%1").arg(thread.wait_address, 8, 16, QLatin1Char('0'));
         break;
-    case ThreadStatus::WaitSleep:
+    case Kernel::ThreadStatus::WaitSleep:
         status = tr("sleeping");
         break;
-    case ThreadStatus::WaitIPC:
+    case Kernel::ThreadStatus::WaitIPC:
         status = tr("waiting for IPC response");
         break;
-    case ThreadStatus::WaitSynchAll:
+    case Kernel::ThreadStatus::WaitSynchAll:
-    case ThreadStatus::WaitSynchAny:
+    case Kernel::ThreadStatus::WaitSynchAny:
         status = tr("waiting for objects");
         break;
-    case ThreadStatus::WaitHleEvent:
+    case Kernel::ThreadStatus::WaitHleEvent:
         status = tr("waiting for HLE return");
         break;
-    case ThreadStatus::Dormant:
+    case Kernel::ThreadStatus::Dormant:
         status = tr("dormant");
         break;
-    case ThreadStatus::Dead:
+    case Kernel::ThreadStatus::Dead:
         status = tr("dead");
         break;
     }
@@ -183,23 +183,23 @@ QString WaitTreeThread::GetText() const {
 QColor WaitTreeThread::GetColor() const {
     const auto& thread = static_cast<const Kernel::Thread&>(object);
     switch (thread.status) {
-    case ThreadStatus::Running:
+    case Kernel::ThreadStatus::Running:
         return QColor(Qt::GlobalColor::darkGreen);
-    case ThreadStatus::Ready:
+    case Kernel::ThreadStatus::Ready:
         return QColor(Qt::GlobalColor::darkBlue);
-    case ThreadStatus::WaitArb:
+    case Kernel::ThreadStatus::WaitArb:
         return QColor(Qt::GlobalColor::darkRed);
-    case ThreadStatus::WaitSleep:
+    case Kernel::ThreadStatus::WaitSleep:
         return QColor(Qt::GlobalColor::darkYellow);
-    case ThreadStatus::WaitIPC:
+    case Kernel::ThreadStatus::WaitIPC:
         return QColor(Qt::GlobalColor::darkCyan);
-    case ThreadStatus::WaitSynchAll:
+    case Kernel::ThreadStatus::WaitSynchAll:
-    case ThreadStatus::WaitSynchAny:
+    case Kernel::ThreadStatus::WaitSynchAny:
-    case ThreadStatus::WaitHleEvent:
+    case Kernel::ThreadStatus::WaitHleEvent:
         return QColor(Qt::GlobalColor::red);
-    case ThreadStatus::Dormant:
+    case Kernel::ThreadStatus::Dormant:
         return QColor(Qt::GlobalColor::darkCyan);
-    case ThreadStatus::Dead:
+    case Kernel::ThreadStatus::Dead:
         return QColor(Qt::GlobalColor::gray);
     default:
         return WaitTreeItem::GetColor();
@@ -213,16 +213,16 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeThread::GetChildren() const {
 
     QString processor;
     switch (thread.processor_id) {
-    case ThreadProcessorId::THREADPROCESSORID_DEFAULT:
+    case Kernel::ThreadProcessorId::THREADPROCESSORID_DEFAULT:
         processor = tr("default");
         break;
-    case ThreadProcessorId::THREADPROCESSORID_ALL:
+    case Kernel::ThreadProcessorId::THREADPROCESSORID_ALL:
         processor = tr("all");
         break;
-    case ThreadProcessorId::THREADPROCESSORID_0:
+    case Kernel::ThreadProcessorId::THREADPROCESSORID_0:
         processor = tr("AppCore");
         break;
-    case ThreadProcessorId::THREADPROCESSORID_1:
+    case Kernel::ThreadProcessorId::THREADPROCESSORID_1:
         processor = tr("SysCore");
         break;
     default:
@@ -243,9 +243,9 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeThread::GetChildren() const {
     } else {
         list.push_back(std::make_unique<WaitTreeMutexList>(thread.held_mutexes));
     }
-    if (thread.status == ThreadStatus::WaitSynchAny ||
+    if (thread.status == Kernel::ThreadStatus::WaitSynchAny ||
-        thread.status == ThreadStatus::WaitSynchAll ||
+        thread.status == Kernel::ThreadStatus::WaitSynchAll ||
-        thread.status == ThreadStatus::WaitHleEvent) {
+        thread.status == Kernel::ThreadStatus::WaitHleEvent) {
         list.push_back(std::make_unique<WaitTreeObjectList>(thread.wait_objects,
                                                             thread.IsSleepingOnWaitAll()));
     }

src/core/hle/kernel/thread.h

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

src/core/hle/service/fs/archive.cpp

@@ -108,7 +108,7 @@ void File::Read(Kernel::HLERequestContext& ctx) {
     std::chrono::nanoseconds read_timeout_ns{backend->GetReadDelayNs(length)};
     ctx.SleepClientThread(Kernel::GetCurrentThread(), "file::read", read_timeout_ns,
                           [](Kernel::SharedPtr<Kernel::Thread> thread,
-                             Kernel::HLERequestContext& ctx, ThreadWakeupReason reason) {
+                             Kernel::HLERequestContext& ctx, Kernel::ThreadWakeupReason reason) {
                               // Nothing to do here
                           });
 }

src/core/hle/service/nwm/nwm_uds.cpp

@@ -1162,7 +1162,7 @@ void NWM_UDS::ConnectToNetwork(Kernel::HLERequestContext& ctx) {
     connection_event = ctx.SleepClientThread(
         Kernel::GetCurrentThread(), "uds::ConnectToNetwork", UDSConnectionTimeout,
         [](Kernel::SharedPtr<Kernel::Thread> thread, Kernel::HLERequestContext& ctx,
-           ThreadWakeupReason reason) {
+           Kernel::ThreadWakeupReason reason) {
             // TODO(B3N30): Add error handling for host full and timeout
             IPC::RequestBuilder rb(ctx, 0x1E, 1, 0);
             rb.Push(RESULT_SUCCESS);

src/core/hle/service/service.cpp

@@ -198,11 +198,12 @@ void ServiceFrameworkBase::HandleSyncRequest(SharedPtr<ServerSession> server_ses
     handler_invoker(this, info->handler_callback, context);
 
     auto thread = Kernel::GetCurrentThread();
-    ASSERT(thread->status == ThreadStatus::Running || thread->status == ThreadStatus::WaitHleEvent);
+    ASSERT(thread->status == Kernel::ThreadStatus::Running ||
+           thread->status == Kernel::ThreadStatus::WaitHleEvent);
     // Only write the response immediately if the thread is still running. If the HLE handler put
     // the thread to sleep then the writing of the command buffer will be deferred to the wakeup
     // callback.
-    if (thread->status == ThreadStatus::Running) {
+    if (thread->status == Kernel::ThreadStatus::Running) {
         context.WriteToOutgoingCommandBuffer(cmd_buf, *Kernel::g_current_process,
                                              Kernel::g_handle_table);
     }

src/core/hle/service/sm/srv.cpp

@@ -101,7 +101,8 @@ void SRV::GetServiceHandle(Kernel::HLERequestContext& ctx) {
     // TODO(yuriks): Permission checks go here
 
     auto get_handle = [name, this](Kernel::SharedPtr<Kernel::Thread> thread,
-                                   Kernel::HLERequestContext& ctx, ThreadWakeupReason reason) {
+                                   Kernel::HLERequestContext& ctx,
+                                   Kernel::ThreadWakeupReason reason) {
         LOG_ERROR(Service_SRV, "called service={} wakeup", name);
         auto client_port = service_manager->GetServicePort(name);