base: Support setting thread priorities generically.

base/synchronization/lock_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/synchronization/lock.h"
 
 #include <stdlib.h>
 
 #include "base/compiler_specific.h"
 #include "base/threading/platform_thread.h"
@@ skipping 33 matching lines @@
  private:
   Lock* lock_;
   int acquired_;
 
   DISALLOW_COPY_AND_ASSIGN(BasicLockTestThread);
 };
 
 TEST(LockTest, Basic) {
   Lock lock;
   BasicLockTestThread thread(&lock);
-  PlatformThreadHandle handle = kNullThreadHandle;
+  PlatformThreadHandle handle;
 
   ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle));
 
   int acquired = 0;
   for (int i = 0; i < 5; i++) {
     lock.Acquire();
     acquired++;
     lock.Release();
   }
   for (int i = 0; i < 10; i++) {
@@ skipping 45 matching lines @@
 
 TEST(LockTest, TryLock) {
   Lock lock;
 
   ASSERT_TRUE(lock.Try());
   // We now have the lock....
 
   // This thread will not be able to get the lock.
   {
     TryLockTestThread thread(&lock);
-    PlatformThreadHandle handle = kNullThreadHandle;
+    PlatformThreadHandle handle;
 
     ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle));
 
     PlatformThread::Join(handle);
 
     ASSERT_FALSE(thread.got_lock());
   }
 
   lock.Release();
 
   // This thread will....
   {
     TryLockTestThread thread(&lock);
-    PlatformThreadHandle handle = kNullThreadHandle;
+    PlatformThreadHandle handle;
 
     ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle));
 
     PlatformThread::Join(handle);
 
     ASSERT_TRUE(thread.got_lock());
     // But it released it....
     ASSERT_TRUE(lock.Try());
   }
 
@@ skipping 26 matching lines @@
   int* value_;
 
   DISALLOW_COPY_AND_ASSIGN(MutexLockTestThread);
 };
 
 TEST(LockTest, MutexTwoThreads) {
   Lock lock;
   int value = 0;
 
   MutexLockTestThread thread(&lock, &value);
-  PlatformThreadHandle handle = kNullThreadHandle;
+  PlatformThreadHandle handle;
 
   ASSERT_TRUE(PlatformThread::Create(0, &thread, &handle));
 
   MutexLockTestThread::DoStuff(&lock, &value);
 
   PlatformThread::Join(handle);
 
   EXPECT_EQ(2 * 40, value);
 }
 
 TEST(LockTest, MutexFourThreads) {
   Lock lock;
   int value = 0;
 
   MutexLockTestThread thread1(&lock, &value);
   MutexLockTestThread thread2(&lock, &value);
   MutexLockTestThread thread3(&lock, &value);
-  PlatformThreadHandle handle1 = kNullThreadHandle;
-  PlatformThreadHandle handle2 = kNullThreadHandle;
-  PlatformThreadHandle handle3 = kNullThreadHandle;
+  PlatformThreadHandle handle1;
+  PlatformThreadHandle handle2;
+  PlatformThreadHandle handle3;
 
   ASSERT_TRUE(PlatformThread::Create(0, &thread1, &handle1));
   ASSERT_TRUE(PlatformThread::Create(0, &thread2, &handle2));
   ASSERT_TRUE(PlatformThread::Create(0, &thread3, &handle3));
 
   MutexLockTestThread::DoStuff(&lock, &value);
 
   PlatformThread::Join(handle1);
   PlatformThread::Join(handle2);
   PlatformThread::Join(handle3);
 
   EXPECT_EQ(4 * 40, value);
 }
 
 }  // namespace base