Add full SetThreadPriority support to Windows.

base/threading/platform_thread_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/compiler_specific.h"
+#include "base/macros.h"
+#include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
+#include "testing/gtest/include/gtest/gtest.h"
 
-#include "testing/gtest/include/gtest/gtest.h"
+#if defined(OS_WIN)
+#include <windows.h>
+#endif
 
 namespace base {
 
 // Trivial tests that thread runs and doesn't crash on create and join ---------
 
 class TrivialThread : public PlatformThread::Delegate {
  public:
   TrivialThread() : did_run_(false) {}
 
   void ThreadMain() override { did_run_ = true; }
@@ skipping 25 matching lines @@
   for (size_t n = 0; n < arraysize(thread); n++)
     ASSERT_TRUE(PlatformThread::Create(0, &thread[n], &handle[n]));
   for (size_t n = 0; n < arraysize(thread); n++)
     PlatformThread::Join(handle[n]);
   for (size_t n = 0; n < arraysize(thread); n++)
     ASSERT_TRUE(thread[n].did_run());
 }
 
 // Tests of basic thread functions ---------------------------------------------
 
-class FunctionTestThread : public TrivialThread {
+class FunctionTestThread : public PlatformThread::Delegate {
  public:
-  FunctionTestThread() : thread_id_(0) {}
+  FunctionTestThread()
+      : thread_id_(kInvalidThreadId),
+        thread_started_(true, false),
+        terminate_thread_(true, false),
+        done_(false) {}
+  ~FunctionTestThread() override {
+    EXPECT_TRUE(terminate_thread_.IsSignaled())
+        << "Need to mark thread for termination and join the underlying thread "
+        << "before destroying a FunctionTestThread as it owns the "
+        << "WaitableEvent blocking the underlying thread's main.";
+  }
 
+  // Grabs |thread_id_|, signals |thread_started_|, and then waits for
+  // |terminate_thread_| to be signaled before exiting.
   void ThreadMain() override {
     thread_id_ = PlatformThread::CurrentId();
-    PlatformThread::YieldCurrentThread();
-    PlatformThread::Sleep(TimeDelta::FromMilliseconds(50));
+    EXPECT_NE(thread_id_, kInvalidThreadId);
 
     // Make sure that the thread ID is the same across calls.
     EXPECT_EQ(thread_id_, PlatformThread::CurrentId());
 
-    TrivialThread::ThreadMain();
+    thread_started_.Signal();
+
+    terminate_thread_.Wait();
+
+    done_ = true;
   }
 
-  PlatformThreadId thread_id() const { return thread_id_; }
+  PlatformThreadId thread_id() const {
+    EXPECT_TRUE(thread_started_.IsSignaled()) << "Thread ID still unknown";
+    return thread_id_;
+  }
+
+  bool IsRunning() const {
+    return thread_started_.IsSignaled() && !done_;
+  }
+
+  // Blocks until this thread is started.
+  void WaitForThreadStart() { thread_started_.Wait(); }
+
+  // Mark this thread for termination (callers must then join this thread to be
+  // guaranteed of termination).
+  void MarkForTermination() { terminate_thread_.Signal(); }
 
  private:
   PlatformThreadId thread_id_;
 
+  mutable WaitableEvent thread_started_;
+  WaitableEvent terminate_thread_;
+  bool done_;
+
   DISALLOW_COPY_AND_ASSIGN(FunctionTestThread);
 };
 
 TEST(PlatformThreadTest, Function) {
   PlatformThreadId main_thread_id = PlatformThread::CurrentId();
 
   FunctionTestThread thread;
   PlatformThreadHandle handle;
 
-  ASSERT_FALSE(thread.did_run());
+  ASSERT_FALSE(thread.IsRunning());
   ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle));
+  thread.WaitForThreadStart();
+  ASSERT_TRUE(thread.IsRunning());
+  EXPECT_NE(thread.thread_id(), main_thread_id);
+
+  thread.MarkForTermination();
   PlatformThread::Join(handle);
-  ASSERT_TRUE(thread.did_run());
-  EXPECT_NE(thread.thread_id(), main_thread_id);
+  ASSERT_FALSE(thread.IsRunning());
 
   // Make sure that the thread ID is the same across calls.
   EXPECT_EQ(main_thread_id, PlatformThread::CurrentId());
 }
 
 TEST(PlatformThreadTest, FunctionTimesTen) {
   PlatformThreadId main_thread_id = PlatformThread::CurrentId();
 
   FunctionTestThread thread[10];
   PlatformThreadHandle handle[arraysize(thread)];
 
   for (size_t n = 0; n < arraysize(thread); n++)
-    ASSERT_FALSE(thread[n].did_run());
+    ASSERT_FALSE(thread[n].IsRunning());
+
   for (size_t n = 0; n < arraysize(thread); n++)
     ASSERT_TRUE(PlatformThread::Create(0, &thread[n], &handle[n]));
   for (size_t n = 0; n < arraysize(thread); n++)
-    PlatformThread::Join(handle[n]);
+    thread[n].WaitForThreadStart();
+
   for (size_t n = 0; n < arraysize(thread); n++) {
-    ASSERT_TRUE(thread[n].did_run());
+    ASSERT_TRUE(thread[n].IsRunning());
     EXPECT_NE(thread[n].thread_id(), main_thread_id);
 
     // Make sure no two threads get the same ID.
     for (size_t i = 0; i < n; ++i) {
       EXPECT_NE(thread[i].thread_id(), thread[n].thread_id());
     }
   }
 
+  for (size_t n = 0; n < arraysize(thread); n++)
+    thread[n].MarkForTermination();
+  for (size_t n = 0; n < arraysize(thread); n++)
+    PlatformThread::Join(handle[n]);
+  for (size_t n = 0; n < arraysize(thread); n++)
+    ASSERT_FALSE(thread[n].IsRunning());
+
   // Make sure that the thread ID is the same across calls.
   EXPECT_EQ(main_thread_id, PlatformThread::CurrentId());
 }
 
+namespace {
+
+const ThreadPriority kThreadPriorityTestValues[] = {
+// Disable non-normal priority toggling on POSIX as it appears to be broken
+// (http://crbug.com/468793). This is prefered to disabling the tests altogether
+// on POSIX as it at least provides coverage for running this code under
+// "normal" priority.
+#if !defined(OS_POSIX)
+    kThreadPriority_RealtimeAudio,
+    kThreadPriority_Display,
+    kThreadPriority_Background,
+#endif  // !defined(OS_POSIX)
+    // Keep normal last to test unbackgrounding.
+    kThreadPriority_Normal
+};
+
+}  // namespace
+
+// Test changing another thread's priority.
+// NOTE: This test is partially disabled on POSIX, see note above and
+// http://crbug.com/468793.
+TEST(PlatformThreadTest, ThreadPriorityOtherThread) {
+  PlatformThreadHandle current_handle(PlatformThread::CurrentHandle());
+
+  // Confirm that the current thread's priority is as expected.
+  EXPECT_EQ(kThreadPriority_Normal,
+            PlatformThread::GetThreadPriority(current_handle));
+
+  // Create a test thread.
+  FunctionTestThread thread;
+  PlatformThreadHandle handle;
+  ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle));
+  thread.WaitForThreadStart();
+  EXPECT_NE(thread.thread_id(), kInvalidThreadId);
+  EXPECT_NE(thread.thread_id(), PlatformThread::CurrentId());
+
+  // New threads should get normal priority by default.
+  EXPECT_EQ(kThreadPriority_Normal, PlatformThread::GetThreadPriority(handle));
+
+  // Toggle each supported priority on the test thread and confirm it only
+  // affects it (and not the current thread).
+  for (size_t i = 0; i < arraysize(kThreadPriorityTestValues); ++i) {
+    SCOPED_TRACE(i);
+
+    // Alter and verify the test thread's priority.
+    PlatformThread::SetThreadPriority(handle, kThreadPriorityTestValues[i]);
+    EXPECT_EQ(kThreadPriorityTestValues[i],
+              PlatformThread::GetThreadPriority(handle));
+
+    // Make sure the current thread was otherwise unaffected.
+    EXPECT_EQ(kThreadPriority_Normal,
+              PlatformThread::GetThreadPriority(current_handle));
+  }
+
+  thread.MarkForTermination();
+  PlatformThread::Join(handle);
+}
+
+// Test changing the current thread's priority (which has different semantics on
+// some platforms).
+// NOTE: This test is partially disabled on POSIX, see note above and
+// http://crbug.com/468793.
+TEST(PlatformThreadTest, ThreadPriorityCurrentThread) {
+  PlatformThreadHandle current_handle(PlatformThread::CurrentHandle());
+
+  // Confirm that the current thread's priority is as expected.
+  EXPECT_EQ(kThreadPriority_Normal,
+            PlatformThread::GetThreadPriority(current_handle));
+
+  // Create a test thread for verification purposes only.
+  FunctionTestThread thread;
+  PlatformThreadHandle handle;
+  ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle));
+  thread.WaitForThreadStart();
+  EXPECT_NE(thread.thread_id(), kInvalidThreadId);
+  EXPECT_NE(thread.thread_id(), PlatformThread::CurrentId());
+
+  // Confirm that the new thread's priority is as expected.
+  EXPECT_EQ(kThreadPriority_Normal, PlatformThread::GetThreadPriority(handle));
+
+  // Toggle each supported priority on the current thread and confirm it only
+  // affects it (and not the test thread).
+  for (size_t i = 0; i < arraysize(kThreadPriorityTestValues); ++i) {
+    SCOPED_TRACE(i);
+
+    // Alter and verify the current thread's priority.
+    PlatformThread::SetThreadPriority(current_handle,
+                                      kThreadPriorityTestValues[i]);
+    EXPECT_EQ(kThreadPriorityTestValues[i],
+              PlatformThread::GetThreadPriority(current_handle));
+
+    // Make sure the test thread was otherwise unaffected.
+    EXPECT_EQ(kThreadPriority_Normal,
+              PlatformThread::GetThreadPriority(handle));
+  }
+
+  // Restore current thread priority for follow-up tests.
+  PlatformThread::SetThreadPriority(current_handle, kThreadPriority_Normal);
+
+  thread.MarkForTermination();
+  PlatformThread::Join(handle);
+}
+
 }  // namespace base