From d9500ecf9b1728bc9c5d87b79c1040fbcf6ba9b7 Mon Sep 17 00:00:00 2001
From: wwylele <wwylele@gmail.com>
Date: Thu, 22 Feb 2018 17:31:58 +0200
Subject: [PATCH] Revert "Kernel/Threads: Add a new thread status that will
 allow using a Kernel::Event to put a guest thread to sleep inside an HLE
 handler until said event is signaled"

---
 src/core/hle/service/service.cpp | 44 +-------------------------------
 src/core/hle/service/service.h   | 44 ++------------------------------
 2 files changed, 3 insertions(+), 85 deletions(-)

diff --git a/src/core/hle/service/service.cpp b/src/core/hle/service/service.cpp
index b754e13e90..b6aca39000 100644
--- a/src/core/hle/service/service.cpp
+++ b/src/core/hle/service/service.cpp
@@ -9,7 +9,6 @@
 #include "common/string_util.h"
 #include "core/hle/ipc.h"
 #include "core/hle/kernel/client_port.h"
-#include "core/hle/kernel/event.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/server_port.h"
 #include "core/hle/kernel/server_session.h"
@@ -220,47 +219,6 @@ void AddService(Interface* interface_) {
     server_port->SetHleHandler(std::shared_ptr<Interface>(interface_));
 }
 
-bool ThreadContinuationToken::IsValid() {
-    return thread != nullptr && event != nullptr;
-}
-
-ThreadContinuationToken SleepClientThread(const std::string& reason,
-                                          ThreadContinuationToken::Callback callback) {
-    auto thread = Kernel::GetCurrentThread();
-
-    ASSERT(thread->status == THREADSTATUS_RUNNING);
-
-    ThreadContinuationToken token;
-
-    token.event = Kernel::Event::Create(Kernel::ResetType::OneShot, "HLE Pause Event: " + reason);
-    token.thread = thread;
-    token.callback = std::move(callback);
-    token.pause_reason = std::move(reason);
-
-    // Make the thread wait on our newly created event, it will be signaled when
-    // ContinueClientThread is called.
-    thread->status = THREADSTATUS_WAIT_HLE_EVENT;
-    thread->wait_objects = {token.event};
-    token.event->AddWaitingThread(thread);
-
-    return token;
-}
-
-void ContinueClientThread(ThreadContinuationToken& token) {
-    ASSERT_MSG(token.IsValid(), "Invalid continuation token");
-    ASSERT(token.thread->status == THREADSTATUS_WAIT_HLE_EVENT);
-
-    // Signal the event to wake up the thread
-    token.event->Signal();
-    ASSERT(token.thread->status == THREADSTATUS_READY);
-
-    token.callback(token.thread);
-
-    token.event = nullptr;
-    token.thread = nullptr;
-    token.callback = nullptr;
-}
-
 /// Initialize ServiceManager
 void Init() {
     SM::g_service_manager = std::make_shared<SM::ServiceManager>();
@@ -327,4 +285,4 @@ void Shutdown() {
     g_kernel_named_ports.clear();
     LOG_DEBUG(Service, "shutdown OK");
 }
-} // namespace Service
+}
diff --git a/src/core/hle/service/service.h b/src/core/hle/service/service.h
index 26894ce253..3b8a192370 100644
--- a/src/core/hle/service/service.h
+++ b/src/core/hle/service/service.h
@@ -20,8 +20,7 @@ namespace Kernel {
 class ClientPort;
 class ServerPort;
 class ServerSession;
-class Event;
-} // namespace Kernel
+}
 
 namespace Service {
 
@@ -262,45 +261,6 @@ private:
     }
 };
 
-/*
- * Token representing a pause request for a guest thread from an HLE service function.
- * Using this token a function can put a guest thread to sleep to defer returning a result from
- * SendSyncRequest until an async operation completes on the host. To use it, call SleepClientThread
- * to create a specific continuation token for the current thread, perform your async operation, and
- * then call ContinueClientThread passing in the returned token as a parameter.
- */
-class ThreadContinuationToken {
-public:
-    using Callback = std::function<void(Kernel::SharedPtr<Kernel::Thread> thread)>;
-    friend ThreadContinuationToken SleepClientThread(const std::string& reason, Callback callback);
-    friend void ContinueClientThread(ThreadContinuationToken& token);
-
-    bool IsValid();
-
-private:
-    Kernel::SharedPtr<Kernel::Event> event;
-    Kernel::SharedPtr<Kernel::Thread> thread;
-    Callback callback;
-    std::string pause_reason;
-};
-
-/*
- * Puts the current guest thread to sleep and returns a ThreadContinuationToken to be used with
- * ContinueClientThread.
- * @param reason Reason for pausing the thread, to be used for debugging purposes.
- * @param callback Callback to be invoked when the thread is resumed by ContinueClientThread.
- * @returns ThreadContinuationToken representing the pause request.
- */
-ThreadContinuationToken SleepClientThread(const std::string& reason,
-                                          ThreadContinuationToken::Callback callback);
-
-/*
- * Completes a continuation request and resumes the associated guest thread.
- * This function invalidates the token.
- * @param token The continuation token associated with the continuation request.
- */
-void ContinueClientThread(ThreadContinuationToken& token);
-
 /// Initialize ServiceManager
 void Init();
 
@@ -315,4 +275,4 @@ void AddNamedPort(std::string name, Kernel::SharedPtr<Kernel::ClientPort> port);
 /// Adds a service to the services table
 void AddService(Interface* interface_);
 
-} // namespace Service
+} // namespace