base/threading: restrict to set only current thread priority

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"
 
-#if defined(OS_WIN)
+#if defined(OS_POSIX)
+#include <sys/types.h>
+#include <unistd.h>
+#elif defined(OS_WIN)
 #include <windows.h>
 #endif
 
 namespace base {
 
 // Trivial tests that thread runs and doesn't crash on create and join ---------
 
+namespace {
+
 class TrivialThread : public PlatformThread::Delegate {
  public:
   TrivialThread() : did_run_(false) {}
 
   void ThreadMain() override { did_run_ = true; }
 
   bool did_run() const { return did_run_; }
 
  private:
   bool did_run_;
 
   DISALLOW_COPY_AND_ASSIGN(TrivialThread);
 };
 
+}  // namespace
+
 TEST(PlatformThreadTest, Trivial) {
   TrivialThread thread;
   PlatformThreadHandle handle;
 
   ASSERT_FALSE(thread.did_run());
   ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle));
   PlatformThread::Join(handle);
   ASSERT_TRUE(thread.did_run());
 }
 
 TEST(PlatformThreadTest, TrivialTimesTen) {
   TrivialThread thread[10];
   PlatformThreadHandle handle[arraysize(thread)];
 
   for (size_t n = 0; n < arraysize(thread); n++)
     ASSERT_FALSE(thread[n].did_run());
   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 ---------------------------------------------
 
+namespace {
+
 class FunctionTestThread : public PlatformThread::Delegate {
  public:
   FunctionTestThread()
       : thread_id_(kInvalidThreadId),
-        thread_started_(true, false),
+        termination_ready_(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.
+  // Grabs |thread_id_|, runs an optional test on that thread, signals
+  // |termination_ready_|, and then waits for |terminate_thread_| to be
+  // signaled before exiting.
   void ThreadMain() override {
     thread_id_ = PlatformThread::CurrentId();
     EXPECT_NE(thread_id_, kInvalidThreadId);
 
     // Make sure that the thread ID is the same across calls.
     EXPECT_EQ(thread_id_, PlatformThread::CurrentId());
 
-    thread_started_.Signal();
+    // Run extra tests.
+    RunTest();
 
+    termination_ready_.Signal();
     terminate_thread_.Wait();
 
     done_ = true;
   }
 
   PlatformThreadId thread_id() const {
-    EXPECT_TRUE(thread_started_.IsSignaled()) << "Thread ID still unknown";
+    EXPECT_TRUE(termination_ready_.IsSignaled()) << "Thread ID still unknown";
     return thread_id_;
   }
 
   bool IsRunning() const {
-    return thread_started_.IsSignaled() && !done_;
+    return termination_ready_.IsSignaled() && !done_;
   }
 
-  // Blocks until this thread is started.
-  void WaitForThreadStart() { thread_started_.Wait(); }
+  // Blocks until this thread is started and ready to be terminated.
+  void WaitForTerminationReady() { termination_ready_.Wait(); }
 
-  // Mark this thread for termination (callers must then join this thread to be
+  // Marks this thread for termination (callers must then join this thread to be
   // guaranteed of termination).
   void MarkForTermination() { terminate_thread_.Signal(); }
 
  private:
+  // Runs an optional test on the newly created thread.
+  virtual void RunTest() {}
+
   PlatformThreadId thread_id_;
 
-  mutable WaitableEvent thread_started_;
+  mutable WaitableEvent termination_ready_;
   WaitableEvent terminate_thread_;
   bool done_;
 
   DISALLOW_COPY_AND_ASSIGN(FunctionTestThread);
 };
 
+}  // namespace
+
 TEST(PlatformThreadTest, Function) {
   PlatformThreadId main_thread_id = PlatformThread::CurrentId();
 
   FunctionTestThread thread;
   PlatformThreadHandle handle;
 
   ASSERT_FALSE(thread.IsRunning());
   ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle));
-  thread.WaitForThreadStart();
+  thread.WaitForTerminationReady();
   ASSERT_TRUE(thread.IsRunning());
   EXPECT_NE(thread.thread_id(), main_thread_id);
 
   thread.MarkForTermination();
   PlatformThread::Join(handle);
   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].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++)
-    thread[n].WaitForThreadStart();
+    thread[n].WaitForTerminationReady();
 
   for (size_t n = 0; n < arraysize(thread); n++) {
     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)
+// The order should be higher to lower to cover as much cases as possible on
+// Linux trybots running without CAP_SYS_NICE permission.
+#if !defined(OS_ANDROID)
+    // PlatformThread::GetCurrentThreadPriority() on Android does not support
+    // REALTIME_AUDIO case. See http://crbug.com/505474.
+    ThreadPriority::REALTIME_AUDIO,
+#endif
     ThreadPriority::DISPLAY,
-    ThreadPriority::REALTIME_AUDIO,
-    // Keep BACKGROUND second to last to test backgrounding from other
-    // priorities.
+    // This redundant BACKGROUND priority is to test backgrounding from other
+    // priorities, and unbackgrounding.
     ThreadPriority::BACKGROUND,
-#endif  // !defined(OS_POSIX)
-    // Keep NORMAL last to test unbackgrounding.
-    ThreadPriority::NORMAL
+    ThreadPriority::NORMAL,
+    ThreadPriority::BACKGROUND};
+
+bool IsBumpingPriorityAllowed() {
+#if defined(OS_POSIX)
+  // Only root can raise thread priority on POSIX environment. On Linux, users
+  // who have CAP_SYS_NICE permission also can raise the thread priority, but
+  // libcap.so would be needed to check the capability.
+  return geteuid() == 0;
+#else
+  return true;
+#endif
+}
+
+class ThreadPriorityTestThread : public FunctionTestThread {
+ public:
+  ThreadPriorityTestThread() = default;
+  ~ThreadPriorityTestThread() override = default;
+
+ private:
+  void RunTest() override {
+    // Confirm that the current thread's priority is as expected.
+    EXPECT_EQ(ThreadPriority::NORMAL,
+              PlatformThread::GetCurrentThreadPriority());
+
+    // Toggle each supported priority on the current thread and confirm it
+    // affects it.
+    const bool bumping_priority_allowed = IsBumpingPriorityAllowed();
+    for (size_t i = 0; i < arraysize(kThreadPriorityTestValues); ++i) {
+      SCOPED_TRACE(i);
+      if (!bumping_priority_allowed &&
+          kThreadPriorityTestValues[i] >
+              PlatformThread::GetCurrentThreadPriority()) {
+        continue;
+      }
+
+      // Alter and verify the current thread's priority.
+      PlatformThread::SetCurrentThreadPriority(kThreadPriorityTestValues[i]);
+      EXPECT_EQ(kThreadPriorityTestValues[i],
+                PlatformThread::GetCurrentThreadPriority());
+    }
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(ThreadPriorityTestThread);
 };
 
 }  // 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());
+#if defined(OS_MACOSX)
+// PlatformThread::GetCurrentThreadPriority() is not implemented on OS X.
+#define MAYBE_ThreadPriorityCurrentThread DISABLED_ThreadPriorityCurrentThread
+#else
+#define MAYBE_ThreadPriorityCurrentThread ThreadPriorityCurrentThread
+#endif
 
-  // Confirm that the current thread's priority is as expected.
-  EXPECT_EQ(ThreadPriority::NORMAL,
-            PlatformThread::GetThreadPriority(current_handle));
+// Test changing a created thread's priority (which has different semantics on
+// some platforms).
+TEST(PlatformThreadTest, MAYBE_ThreadPriorityCurrentThread) {
+  ThreadPriorityTestThread thread;
+  PlatformThreadHandle handle;
 
-  // Create a test thread.
-  FunctionTestThread thread;
-  PlatformThreadHandle handle;
+  ASSERT_FALSE(thread.IsRunning());
   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(ThreadPriority::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(ThreadPriority::NORMAL,
-              PlatformThread::GetThreadPriority(current_handle));
-  }
+  thread.WaitForTerminationReady();
+  ASSERT_TRUE(thread.IsRunning());
 
   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(ThreadPriority::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(ThreadPriority::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(ThreadPriority::NORMAL,
-              PlatformThread::GetThreadPriority(handle));
-  }
-
-  // Restore current thread priority for follow-up tests.
-  PlatformThread::SetThreadPriority(current_handle, ThreadPriority::NORMAL);
-
-  thread.MarkForTermination();
-  PlatformThread::Join(handle);
+  ASSERT_FALSE(thread.IsRunning());
 }
 
 }  // namespace base