From c0d3aef28c0a0c68c18de30228f29e30f0e52533 Mon Sep 17 00:00:00 2001
From: bunnei <bunneidev@gmail.com>
Date: Wed, 30 Dec 2020 23:01:08 -0800
Subject: core: hle: kernel: Rename Thread to KThread.

---
 src/core/hle/kernel/time_manager.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'src/core/hle/kernel/time_manager.cpp')

diff --git a/src/core/hle/kernel/time_manager.cpp b/src/core/hle/kernel/time_manager.cpp
index 832edd629..aaeef3033 100644
--- a/src/core/hle/kernel/time_manager.cpp
+++ b/src/core/hle/kernel/time_manager.cpp
@@ -8,8 +8,8 @@
 #include "core/core_timing_util.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/k_scheduler.h"
+#include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/thread.h"
 #include "core/hle/kernel/time_manager.h"
 
 namespace Kernel {
@@ -18,7 +18,7 @@ TimeManager::TimeManager(Core::System& system_) : system{system_} {
     time_manager_event_type = Core::Timing::CreateEvent(
         "Kernel::TimeManagerCallback",
         [this](std::uintptr_t thread_handle, std::chrono::nanoseconds) {
-            std::shared_ptr<Thread> thread;
+            std::shared_ptr<KThread> thread;
             {
                 std::lock_guard lock{mutex};
                 const auto proper_handle = static_cast<Handle>(thread_handle);
@@ -35,7 +35,7 @@ TimeManager::TimeManager(Core::System& system_) : system{system_} {
         });
 }
 
-void TimeManager::ScheduleTimeEvent(Handle& event_handle, Thread* timetask, s64 nanoseconds) {
+void TimeManager::ScheduleTimeEvent(Handle& event_handle, KThread* timetask, s64 nanoseconds) {
     std::lock_guard lock{mutex};
     event_handle = timetask->GetGlobalHandle();
     if (nanoseconds > 0) {
@@ -58,7 +58,7 @@ void TimeManager::UnscheduleTimeEvent(Handle event_handle) {
     cancelled_events[event_handle] = true;
 }
 
-void TimeManager::CancelTimeEvent(Thread* time_task) {
+void TimeManager::CancelTimeEvent(KThread* time_task) {
     std::lock_guard lock{mutex};
     const Handle event_handle = time_task->GetGlobalHandle();
     UnscheduleTimeEvent(event_handle);
-- 
cgit v1.2.3


From c0f5830323ca5d5bdc2e5e494fcaeaf27fffeb6b Mon Sep 17 00:00:00 2001
From: bunnei <bunneidev@gmail.com>
Date: Tue, 19 Jan 2021 21:05:24 -0800
Subject: hle: kernel: TimeManager: Simplify to not rely on previous
 EmuThreadHandle implementation.

---
 src/core/hle/kernel/time_manager.cpp | 40 +++++++++---------------------------
 1 file changed, 10 insertions(+), 30 deletions(-)

(limited to 'src/core/hle/kernel/time_manager.cpp')

diff --git a/src/core/hle/kernel/time_manager.cpp b/src/core/hle/kernel/time_manager.cpp
index aaeef3033..fd0630019 100644
--- a/src/core/hle/kernel/time_manager.cpp
+++ b/src/core/hle/kernel/time_manager.cpp
@@ -21,47 +21,27 @@ TimeManager::TimeManager(Core::System& system_) : system{system_} {
             std::shared_ptr<KThread> thread;
             {
                 std::lock_guard lock{mutex};
-                const auto proper_handle = static_cast<Handle>(thread_handle);
-                if (cancelled_events[proper_handle]) {
-                    return;
-                }
-                thread = system.Kernel().RetrieveThreadFromGlobalHandleTable(proper_handle);
-            }
-
-            if (thread) {
-                // Thread can be null if process has exited
-                thread->Wakeup();
+                thread = SharedFrom<KThread>(reinterpret_cast<KThread*>(thread_handle));
             }
+            thread->Wakeup();
         });
 }
 
-void TimeManager::ScheduleTimeEvent(Handle& event_handle, KThread* timetask, s64 nanoseconds) {
+void TimeManager::ScheduleTimeEvent(KThread* thread, s64 nanoseconds) {
     std::lock_guard lock{mutex};
-    event_handle = timetask->GetGlobalHandle();
     if (nanoseconds > 0) {
-        ASSERT(timetask);
-        ASSERT(timetask->GetState() != ThreadState::Runnable);
+        ASSERT(thread);
+        ASSERT(thread->GetState() != ThreadState::Runnable);
         system.CoreTiming().ScheduleEvent(std::chrono::nanoseconds{nanoseconds},
-                                          time_manager_event_type, event_handle);
-    } else {
-        event_handle = InvalidHandle;
-    }
-    cancelled_events[event_handle] = false;
-}
-
-void TimeManager::UnscheduleTimeEvent(Handle event_handle) {
-    std::lock_guard lock{mutex};
-    if (event_handle == InvalidHandle) {
-        return;
+                                          time_manager_event_type,
+                                          reinterpret_cast<uintptr_t>(thread));
     }
-    system.CoreTiming().UnscheduleEvent(time_manager_event_type, event_handle);
-    cancelled_events[event_handle] = true;
 }
 
-void TimeManager::CancelTimeEvent(KThread* time_task) {
+void TimeManager::UnscheduleTimeEvent(KThread* thread) {
     std::lock_guard lock{mutex};
-    const Handle event_handle = time_task->GetGlobalHandle();
-    UnscheduleTimeEvent(event_handle);
+    system.CoreTiming().UnscheduleEvent(time_manager_event_type,
+                                        reinterpret_cast<uintptr_t>(thread));
 }
 
 } // namespace Kernel
-- 
cgit v1.2.3