Merge pull request #1439 from lioncash/thread

kernel/thread: Make all instance variables private

1 files changed, 15 insertions, 16 deletions

diff --git a/src/core/hle/kernel/wait_object.cpp b/src/core/hle/kernel/wait_object.cpp
index b190ceb98..530ee6af7 100644
--- a/src/core/hle/kernel/wait_object.cpp
+++ b/src/core/hle/kernel/wait_object.cpp
@@ -35,13 +35,15 @@ SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() {
     u32 candidate_priority = THREADPRIO_LOWEST + 1;
 
     for (const auto& thread : waiting_threads) {
+        const ThreadStatus thread_status = thread->GetStatus();
+
         // The list of waiting threads must not contain threads that are not waiting to be awakened.
-        ASSERT_MSG(thread->status == ThreadStatus::WaitSynchAny ||
-                       thread->status == ThreadStatus::WaitSynchAll ||
-                       thread->status == ThreadStatus::WaitHLEEvent,
+        ASSERT_MSG(thread_status == ThreadStatus::WaitSynchAny ||
+                       thread_status == ThreadStatus::WaitSynchAll ||
+                       thread_status == ThreadStatus::WaitHLEEvent,
                    "Inconsistent thread statuses in waiting_threads");
 
-        if (thread->current_priority >= candidate_priority)
+        if (thread->GetPriority() >= candidate_priority)
             continue;
 
         if (ShouldWait(thread.get()))
@@ -50,16 +52,13 @@ SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() {
         // A thread is ready to run if it's either in ThreadStatus::WaitSynchAny or
         // in ThreadStatus::WaitSynchAll and the rest of the objects it is waiting on are ready.
         bool ready_to_run = true;
-        if (thread->status == ThreadStatus::WaitSynchAll) {
-            ready_to_run = std::none_of(thread->wait_objects.begin(), thread->wait_objects.end(),
-                                        [&thread](const SharedPtr<WaitObject>& object) {
-                                            return object->ShouldWait(thread.get());
-                                        });
+        if (thread_status == ThreadStatus::WaitSynchAll) {
+            ready_to_run = thread->AllWaitObjectsReady();
         }
 
         if (ready_to_run) {
             candidate = thread.get();
-            candidate_priority = thread->current_priority;
+            candidate_priority = thread->GetPriority();
         }
     }
 
@@ -75,24 +74,24 @@ void WaitObject::WakeupWaitingThread(SharedPtr<Thread> thread) {
     if (!thread->IsSleepingOnWaitAll()) {
         Acquire(thread.get());
     } else {
-        for (auto& object : thread->wait_objects) {
+        for (const auto& object : thread->GetWaitObjects()) {
             ASSERT(!object->ShouldWait(thread.get()));
             object->Acquire(thread.get());
         }
     }
 
-    std::size_t index = thread->GetWaitObjectIndex(this);
+    const std::size_t index = thread->GetWaitObjectIndex(this);
 
-    for (auto& object : thread->wait_objects)
+    for (const auto& object : thread->GetWaitObjects())
         object->RemoveWaitingThread(thread.get());
-    thread->wait_objects.clear();
+    thread->ClearWaitObjects();
 
     thread->CancelWakeupTimer();
 
     bool resume = true;
 
-    if (thread->wakeup_callback)
-        resume = thread->wakeup_callback(ThreadWakeupReason::Signal, thread, this, index);
+    if (thread->HasWakeupCallback())
+        resume = thread->InvokeWakeupCallback(ThreadWakeupReason::Signal, thread, this, index);
 
     if (resume)
         thread->ResumeFromWait();