Turn ThreadPriority enum into an enum class.

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"
 
@@ skipping 157 matching lines @@
 }
 
 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,
+    ThreadPriority::REALTIMEAUDIO,
+    ThreadPriority::DISPLAY,
+    ThreadPriority::BACKGROUND,
 #endif  // !defined(OS_POSIX)
     // Keep normal last to test unbackgrounding.
-    kThreadPriority_Normal
+    ThreadPriority::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,
+  EXPECT_EQ(ThreadPriority::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));
+  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(kThreadPriority_Normal,
+    EXPECT_EQ(ThreadPriority::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,
+  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(kThreadPriority_Normal, PlatformThread::GetThreadPriority(handle));
+  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(kThreadPriority_Normal,
+    EXPECT_EQ(ThreadPriority::NORMAL,
               PlatformThread::GetThreadPriority(handle));
   }
 
   // Restore current thread priority for follow-up tests.
-  PlatformThread::SetThreadPriority(current_handle, kThreadPriority_Normal);
+  PlatformThread::SetThreadPriority(current_handle, ThreadPriority::NORMAL);
 
   thread.MarkForTermination();
   PlatformThread::Join(handle);
 }
 
 }  // namespace base