Upating the app, ceee, chrome, ipc, media, and net directories to use the correct lock.h file.

base/synchronization/condition_variable_unittest.cc

 // Copyright (c) 2011 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.
 
 // Multi-threaded tests of ConditionVariable class.
 
 #include <time.h>
 #include <algorithm>
 #include <vector>
 
-#include "base/synchronization/condition_variable.h"
-#include "base/lock.h"
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "base/spin_wait.h"
+#include "base/synchronization/condition_variable.h"
+#include "base/synchronization/lock.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_collision_warner.h"
 #include "base/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 namespace base {
 
 namespace {
 //------------------------------------------------------------------------------
@@ skipping 165 matching lines @@
 // Test serial task servicing, as well as two parallel task servicing methods.
 TEST_F(ConditionVariableTest, MultiThreadConsumerTest) {
   const int kThreadCount = 10;
   WorkQueue queue(kThreadCount);  // Start the threads.
 
   const int kTaskCount = 10;  // Number of tasks in each mini-test here.
 
   Time start_time;  // Used to time task processing.
 
   {
-    AutoLock auto_lock(*queue.lock());
+    base::AutoLock auto_lock(*queue.lock());
     while (!queue.EveryIdWasAllocated())
       queue.all_threads_have_ids()->Wait();
   }
 
   // If threads aren't in a wait state, they may start to gobble up tasks in
   // parallel, short-circuiting (breaking) this test.
   queue.SpinUntilAllThreadsAreWaiting();
 
   {
     // Since we have no tasks yet, all threads should be waiting by now.
-    AutoLock auto_lock(*queue.lock());
+    base::AutoLock auto_lock(*queue.lock());
     EXPECT_EQ(0, queue.GetNumThreadsTakingAssignments());
     EXPECT_EQ(0, queue.GetNumThreadsCompletingTasks());
     EXPECT_EQ(0, queue.task_count());
     EXPECT_EQ(0, queue.GetMaxCompletionsByWorkerThread());
     EXPECT_EQ(0, queue.GetMinCompletionsByWorkerThread());
     EXPECT_EQ(0, queue.GetNumberOfCompletedTasks());
 
     // Set up to make one worker do 30ms tasks sequentially.
     queue.ResetHistory();
     queue.SetTaskCount(kTaskCount);
     queue.SetWorkTime(kThirtyMs);
     queue.SetAllowHelp(false);
 
     start_time = Time::Now();
   }
 
   queue.work_is_available()->Signal();  // Start up one thread.
   // Wait till we at least start to handle tasks (and we're not all waiting).
   queue.SpinUntilTaskCountLessThan(kTaskCount);
 
   {
     // Wait until all 10 work tasks have at least been assigned.
-    AutoLock auto_lock(*queue.lock());
+    base::AutoLock auto_lock(*queue.lock());
     while (queue.task_count())
       queue.no_more_tasks()->Wait();
     // The last of the tasks *might* still be running, but... all but one should
     // be done by now, since tasks are being done serially.
     EXPECT_LE(queue.GetWorkTime().InMilliseconds() * (kTaskCount - 1),
               (Time::Now() - start_time).InMilliseconds());
 
     EXPECT_EQ(1, queue.GetNumThreadsTakingAssignments());
     EXPECT_EQ(1, queue.GetNumThreadsCompletingTasks());
     EXPECT_LE(kTaskCount - 1, queue.GetMaxCompletionsByWorkerThread());
     EXPECT_EQ(0, queue.GetMinCompletionsByWorkerThread());
     EXPECT_LE(kTaskCount - 1, queue.GetNumberOfCompletedTasks());
   }
 
   // Wait to be sure all tasks are done.
   queue.SpinUntilAllThreadsAreWaiting();
 
   {
     // Check that all work was done by one thread id.
-    AutoLock auto_lock(*queue.lock());
+    base::AutoLock auto_lock(*queue.lock());
     EXPECT_EQ(1, queue.GetNumThreadsTakingAssignments());
     EXPECT_EQ(1, queue.GetNumThreadsCompletingTasks());
     EXPECT_EQ(0, queue.task_count());
     EXPECT_EQ(kTaskCount, queue.GetMaxCompletionsByWorkerThread());
     EXPECT_EQ(0, queue.GetMinCompletionsByWorkerThread());
     EXPECT_EQ(kTaskCount, queue.GetNumberOfCompletedTasks());
 
     // Set up to make each task include getting help from another worker, so
     // so that the work gets done in paralell.
     queue.ResetHistory();
     queue.SetTaskCount(kTaskCount);
     queue.SetWorkTime(kThirtyMs);
     queue.SetAllowHelp(true);
 
     start_time = Time::Now();
   }
 
   queue.work_is_available()->Signal();  // But each worker can signal another.
   // Wait till we at least start to handle tasks (and we're not all waiting).
   queue.SpinUntilTaskCountLessThan(kTaskCount);
   // Wait to allow the all workers to get done.
   queue.SpinUntilAllThreadsAreWaiting();
 
   {
     // Wait until all work tasks have at least been assigned.
-    AutoLock auto_lock(*queue.lock());
+    base::AutoLock auto_lock(*queue.lock());
     while (queue.task_count())
       queue.no_more_tasks()->Wait();
 
     // To avoid racy assumptions, we'll just assert that at least 2 threads
     // did work.  We know that the first worker should have gone to sleep, and
     // hence a second worker should have gotten an assignment.
     EXPECT_LE(2, queue.GetNumThreadsTakingAssignments());
     EXPECT_EQ(kTaskCount, queue.GetNumberOfCompletedTasks());
 
     // Try to ask all workers to help, and only a few will do the work.
     queue.ResetHistory();
     queue.SetTaskCount(3);
     queue.SetWorkTime(kThirtyMs);
     queue.SetAllowHelp(false);
   }
   queue.work_is_available()->Broadcast();  // Make them all try.
   // Wait till we at least start to handle tasks (and we're not all waiting).
   queue.SpinUntilTaskCountLessThan(3);
   // Wait to allow the 3 workers to get done.
   queue.SpinUntilAllThreadsAreWaiting();
 
   {
-    AutoLock auto_lock(*queue.lock());
+    base::AutoLock auto_lock(*queue.lock());
     EXPECT_EQ(3, queue.GetNumThreadsTakingAssignments());
     EXPECT_EQ(3, queue.GetNumThreadsCompletingTasks());
     EXPECT_EQ(0, queue.task_count());
     EXPECT_EQ(1, queue.GetMaxCompletionsByWorkerThread());
     EXPECT_EQ(0, queue.GetMinCompletionsByWorkerThread());
     EXPECT_EQ(3, queue.GetNumberOfCompletedTasks());
 
     // Set up to make each task get help from another worker.
     queue.ResetHistory();
     queue.SetTaskCount(3);
     queue.SetWorkTime(kThirtyMs);
     queue.SetAllowHelp(true);  // Allow (unnecessary) help requests.
   }
   queue.work_is_available()->Broadcast();  // Signal all threads.
   // Wait till we at least start to handle tasks (and we're not all waiting).
   queue.SpinUntilTaskCountLessThan(3);
   // Wait to allow the 3 workers to get done.
   queue.SpinUntilAllThreadsAreWaiting();
 
   {
-    AutoLock auto_lock(*queue.lock());
+    base::AutoLock auto_lock(*queue.lock());
     EXPECT_EQ(3, queue.GetNumThreadsTakingAssignments());
     EXPECT_EQ(3, queue.GetNumThreadsCompletingTasks());
     EXPECT_EQ(0, queue.task_count());
     EXPECT_EQ(1, queue.GetMaxCompletionsByWorkerThread());
     EXPECT_EQ(0, queue.GetMinCompletionsByWorkerThread());
     EXPECT_EQ(3, queue.GetNumberOfCompletedTasks());
 
     // Set up to make each task get help from another worker.
     queue.ResetHistory();
     queue.SetTaskCount(20);  // 2 tasks per thread.
     queue.SetWorkTime(kThirtyMs);
     queue.SetAllowHelp(true);
   }
   queue.work_is_available()->Signal();  // But each worker can signal another.
   // Wait till we at least start to handle tasks (and we're not all waiting).
   queue.SpinUntilTaskCountLessThan(20);
   // Wait to allow the 10 workers to get done.
   queue.SpinUntilAllThreadsAreWaiting();  // Should take about 60 ms.
 
   {
-    AutoLock auto_lock(*queue.lock());
+    base::AutoLock auto_lock(*queue.lock());
     EXPECT_EQ(10, queue.GetNumThreadsTakingAssignments());
     EXPECT_EQ(10, queue.GetNumThreadsCompletingTasks());
     EXPECT_EQ(0, queue.task_count());
     EXPECT_EQ(20, queue.GetNumberOfCompletedTasks());
 
     // Same as last test, but with Broadcast().
     queue.ResetHistory();
     queue.SetTaskCount(20);  // 2 tasks per thread.
     queue.SetWorkTime(kThirtyMs);
     queue.SetAllowHelp(true);
   }
   queue.work_is_available()->Broadcast();
   // Wait till we at least start to handle tasks (and we're not all waiting).
   queue.SpinUntilTaskCountLessThan(20);
   // Wait to allow the 10 workers to get done.
   queue.SpinUntilAllThreadsAreWaiting();  // Should take about 60 ms.
 
   {
-    AutoLock auto_lock(*queue.lock());
+    base::AutoLock auto_lock(*queue.lock());
     EXPECT_EQ(10, queue.GetNumThreadsTakingAssignments());
     EXPECT_EQ(10, queue.GetNumThreadsCompletingTasks());
     EXPECT_EQ(0, queue.task_count());
     EXPECT_EQ(20, queue.GetNumberOfCompletedTasks());
 
     queue.SetShutdown();
   }
   queue.work_is_available()->Broadcast();  // Force check for shutdown.
 
   SPIN_FOR_TIMEDELTA_OR_UNTIL_TRUE(TimeDelta::FromMinutes(1),
                                    queue.ThreadSafeCheckShutdown(kThreadCount));
 }
 
 TEST_F(ConditionVariableTest, LargeFastTaskTest) {
   const int kThreadCount = 200;
   WorkQueue queue(kThreadCount);  // Start the threads.
 
   Lock private_lock;  // Used locally for master to wait.
-  AutoLock private_held_lock(private_lock);
+  base::AutoLock private_held_lock(private_lock);
   ConditionVariable private_cv(&private_lock);
 
   {
-    AutoLock auto_lock(*queue.lock());
+    base::AutoLock auto_lock(*queue.lock());
     while (!queue.EveryIdWasAllocated())
       queue.all_threads_have_ids()->Wait();
   }
 
   // Wait a bit more to allow threads to reach their wait state.
   queue.SpinUntilAllThreadsAreWaiting();
 
   {
     // Since we have no tasks, all threads should be waiting by now.
-    AutoLock auto_lock(*queue.lock());
+    base::AutoLock auto_lock(*queue.lock());
     EXPECT_EQ(0, queue.GetNumThreadsTakingAssignments());
     EXPECT_EQ(0, queue.GetNumThreadsCompletingTasks());
     EXPECT_EQ(0, queue.task_count());
     EXPECT_EQ(0, queue.GetMaxCompletionsByWorkerThread());
     EXPECT_EQ(0, queue.GetMinCompletionsByWorkerThread());
     EXPECT_EQ(0, queue.GetNumberOfCompletedTasks());
 
     // Set up to make all workers do (an average of) 20 tasks.
     queue.ResetHistory();
     queue.SetTaskCount(20 * kThreadCount);
     queue.SetWorkTime(kFortyFiveMs);
     queue.SetAllowHelp(false);
   }
   queue.work_is_available()->Broadcast();  // Start up all threads.
   // Wait until we've handed out all tasks.
   {
-    AutoLock auto_lock(*queue.lock());
+    base::AutoLock auto_lock(*queue.lock());
     while (queue.task_count() != 0)
       queue.no_more_tasks()->Wait();
   }
 
   // Wait till the last of the tasks complete.
   queue.SpinUntilAllThreadsAreWaiting();
 
   {
     // With Broadcast(), every thread should have participated.
     // but with racing.. they may not all have done equal numbers of tasks.
-    AutoLock auto_lock(*queue.lock());
+    base::AutoLock auto_lock(*queue.lock());
     EXPECT_EQ(kThreadCount, queue.GetNumThreadsTakingAssignments());
     EXPECT_EQ(kThreadCount, queue.GetNumThreadsCompletingTasks());
     EXPECT_EQ(0, queue.task_count());
     EXPECT_LE(20, queue.GetMaxCompletionsByWorkerThread());
     EXPECT_EQ(20 * kThreadCount, queue.GetNumberOfCompletedTasks());
 
     // Set up to make all workers do (an average of) 4 tasks.
     queue.ResetHistory();
     queue.SetTaskCount(kThreadCount * 4);
     queue.SetWorkTime(kFortyFiveMs);
     queue.SetAllowHelp(true);  // Might outperform Broadcast().
   }
   queue.work_is_available()->Signal();  // Start up one thread.
 
   // Wait until we've handed out all tasks
   {
-    AutoLock auto_lock(*queue.lock());
+    base::AutoLock auto_lock(*queue.lock());
     while (queue.task_count() != 0)
       queue.no_more_tasks()->Wait();
   }
 
   // Wait till the last of the tasks complete.
   queue.SpinUntilAllThreadsAreWaiting();
 
   {
     // With Signal(), every thread should have participated.
     // but with racing.. they may not all have done four tasks.
-    AutoLock auto_lock(*queue.lock());
+    base::AutoLock auto_lock(*queue.lock());
     EXPECT_EQ(kThreadCount, queue.GetNumThreadsTakingAssignments());
     EXPECT_EQ(kThreadCount, queue.GetNumThreadsCompletingTasks());
     EXPECT_EQ(0, queue.task_count());
     EXPECT_LE(4, queue.GetMaxCompletionsByWorkerThread());
     EXPECT_EQ(4 * kThreadCount, queue.GetNumberOfCompletedTasks());
 
     queue.SetShutdown();
   }
   queue.work_is_available()->Broadcast();  // Force check for shutdown.
 
@@ skipping 28 matching lines @@
 
   for (int i = 0; i < thread_count_; ++i) {
     PlatformThreadHandle pth;
     EXPECT_TRUE(PlatformThread::Create(0, this, &pth));
     thread_handles_[i] = pth;
   }
 }
 
 WorkQueue::~WorkQueue() {
   {
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
     SetShutdown();
   }
   work_is_available_.Broadcast();  // Tell them all to terminate.
 
   for (int i = 0; i < thread_count_; ++i) {
     PlatformThread::Join(thread_handles_[i]);
   }
   EXPECT_EQ(0, waiting_thread_count_);
 }
 
@@ skipping 37 matching lines @@
   lock_.AssertAcquired();
   DFAKE_SCOPED_RECURSIVE_LOCK(locked_methods_);
   return shutdown_;
 }
 
 // Because this method is called from the test's main thread we need to actually
 // take the lock.  Threads will call the thread_shutting_down() method with the
 // lock already acquired.
 bool WorkQueue::ThreadSafeCheckShutdown(int thread_count) {
   bool all_shutdown;
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   {
     // Declare in scope so DFAKE is guranteed to be destroyed before AutoLock.
     DFAKE_SCOPED_RECURSIVE_LOCK(locked_methods_);
     all_shutdown = (shutdown_task_count_ == thread_count);
   }
   return all_shutdown;
 }
 
 void WorkQueue::thread_shutting_down() {
   lock_.AssertAcquired();
@@ skipping 78 matching lines @@
 }
 
 void WorkQueue::SetShutdown() {
   lock_.AssertAcquired();
   shutdown_ = true;
 }
 
 void WorkQueue::SpinUntilAllThreadsAreWaiting() {
   while (true) {
     {
-      AutoLock auto_lock(lock_);
+      base::AutoLock auto_lock(lock_);
       if (waiting_thread_count_ == thread_count_)
         break;
     }
     PlatformThread::Sleep(30);
   }
 }
 
 void WorkQueue::SpinUntilTaskCountLessThan(int task_count) {
   while (true) {
     {
-      AutoLock auto_lock(lock_);
+      base::AutoLock auto_lock(lock_);
       if (task_count_ < task_count)
         break;
     }
     PlatformThread::Sleep(30);
   }
 }
 
 
 //------------------------------------------------------------------------------
 // Define the standard worker task. Several tests will spin out many of these
 // threads.
 //------------------------------------------------------------------------------
 
 // The multithread tests involve several threads with a task to perform as
 // directed by an instance of the class WorkQueue.
 // The task is to:
 // a) Check to see if there are more tasks (there is a task counter).
 //    a1) Wait on condition variable if there are no tasks currently.
 // b) Call a function to see what should be done.
 // c) Do some computation based on the number of milliseconds returned in (b).
 // d) go back to (a).
 
 // WorkQueue::ThreadMain() implements the above task for all threads.
 // It calls the controlling object to tell the creator about progress, and to
 // ask about tasks.
 
 void WorkQueue::ThreadMain() {
   int thread_id;
   {
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
     thread_id = GetThreadId();
     if (EveryIdWasAllocated())
       all_threads_have_ids()->Signal();  // Tell creator we're ready.
   }
 
   Lock private_lock;  // Used to waste time on "our work".
   while (1) {  // This is the main consumer loop.
     TimeDelta work_time;
     bool could_use_help;
     {
-      AutoLock auto_lock(lock_);
+      base::AutoLock auto_lock(lock_);
       while (0 == task_count() && !shutdown()) {
         ++waiting_thread_count_;
         work_is_available()->Wait();
         --waiting_thread_count_;
       }
       if (shutdown()) {
         // Ack the notification of a shutdown message back to the controller.
         thread_shutting_down();
         return;  // Terminate.
       }
       // Get our task duration from the queue.
       work_time = GetAnAssignment(thread_id);
       could_use_help = (task_count() > 0) && allow_help_requests();
     }  // Release lock
 
     // Do work (outside of locked region.
     if (could_use_help)
       work_is_available()->Signal();  // Get help from other threads.
 
     if (work_time > TimeDelta::FromMilliseconds(0)) {
       // We could just sleep(), but we'll instead further exercise the
       // condition variable class, and do a timed wait.
-      AutoLock auto_lock(private_lock);
+      base::AutoLock auto_lock(private_lock);
       ConditionVariable private_cv(&private_lock);
       private_cv.TimedWait(work_time);  // Unsynchronized waiting.
     }
 
     {
-      AutoLock auto_lock(lock_);
+      base::AutoLock auto_lock(lock_);
       // Send notification that we completed our "work."
       WorkIsCompleted(thread_id);
     }
   }
 }
 
 }  // namespace
 
 }  // namespace base