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

base/threading/worker_pool_posix_unittest.cc

 // Copyright (c) 2010 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/threading/worker_pool_posix.h"
 
 #include <set>
 
-#include "base/lock.h"
 #include "base/synchronization/condition_variable.h"
+#include "base/synchronization/lock.h"
 #include "base/task.h"
 #include "base/threading/platform_thread.h"
 #include "base/synchronization/waitable_event.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
 // Peer class to provide passthrough access to PosixDynamicThreadPool internals.
 class PosixDynamicThreadPool::PosixDynamicThreadPoolPeer {
  public:
@@ skipping 33 matching lines @@
                    int* counter,
                    Lock* unique_threads_lock,
                    std::set<PlatformThreadId>* unique_threads)
       : counter_lock_(counter_lock),
         unique_threads_lock_(unique_threads_lock),
         unique_threads_(unique_threads),
         counter_(counter) {}
 
   virtual void Run() {
     AddSelfToUniqueThreadSet();
-    AutoLock locked(*counter_lock_);
+    base::AutoLock locked(*counter_lock_);
     (*counter_)++;
   }
 
   void AddSelfToUniqueThreadSet() {
-    AutoLock locked(*unique_threads_lock_);
+    base::AutoLock locked(*unique_threads_lock_);
     unique_threads_->insert(PlatformThread::CurrentId());
   }
 
  private:
   Lock* counter_lock_;
   Lock* unique_threads_lock_;
   std::set<PlatformThreadId>* unique_threads_;
   int* counter_;
 
   DISALLOW_COPY_AND_ASSIGN(IncrementingTask);
@@ skipping 13 matching lines @@
                            base::WaitableEvent* start)
       : incrementer_(
           counter_lock, counter, unique_threads_lock, unique_threads),
         num_waiting_to_start_lock_(num_waiting_to_start_lock),
         num_waiting_to_start_(num_waiting_to_start),
         num_waiting_to_start_cv_(num_waiting_to_start_cv),
         start_(start) {}
 
   virtual void Run() {
     {
-      AutoLock num_waiting_to_start_locked(*num_waiting_to_start_lock_);
+      base::AutoLock num_waiting_to_start_locked(*num_waiting_to_start_lock_);
       (*num_waiting_to_start_)++;
     }
     num_waiting_to_start_cv_->Signal();
     CHECK(start_->Wait());
     incrementer_.Run();
   }
 
  private:
   IncrementingTask incrementer_;
   Lock* num_waiting_to_start_lock_;
@@ skipping 17 matching lines @@
   virtual void SetUp() {
     peer_.set_num_idle_threads_cv(new ConditionVariable(peer_.lock()));
   }
 
   virtual void TearDown() {
     // Wake up the idle threads so they can terminate.
     if (pool_.get()) pool_->Terminate();
   }
 
   void WaitForTasksToStart(int num_tasks) {
-    AutoLock num_waiting_to_start_locked(num_waiting_to_start_lock_);
+    base::AutoLock num_waiting_to_start_locked(num_waiting_to_start_lock_);
     while (num_waiting_to_start_ < num_tasks) {
       num_waiting_to_start_cv_.Wait();
     }
   }
 
   void WaitForIdleThreads(int num_idle_threads) {
-    AutoLock pool_locked(*peer_.lock());
+    base::AutoLock pool_locked(*peer_.lock());
     while (peer_.num_idle_threads() < num_idle_threads) {
       peer_.num_idle_threads_cv()->Wait();
     }
   }
 
   Task* CreateNewIncrementingTask() {
     return new IncrementingTask(&counter_lock_, &counter_,
                                 &unique_threads_lock_, &unique_threads_);
   }
 
@@ skipping 83 matching lines @@
   WaitForTasksToStart(2);
   start_.Signal();
   WaitForIdleThreads(2);
 
   EXPECT_EQ(3, counter_);
   EXPECT_EQ(2, peer_.num_idle_threads());
   EXPECT_EQ(2U, unique_threads_.size());
 
   // Wake up all idle threads so they can exit.
   {
-    AutoLock locked(*peer_.lock());
+    base::AutoLock locked(*peer_.lock());
     while (peer_.num_idle_threads() > 0) {
       peer_.tasks_available_cv()->Signal();
       peer_.num_idle_threads_cv()->Wait();
     }
   }
 
   // Add another non blocking task.  There are no threads to reuse.
   pool_->PostTask(CreateNewIncrementingTask());
   WaitForIdleThreads(1);
 
   EXPECT_EQ(3U, unique_threads_.size());
   EXPECT_EQ(1, peer_.num_idle_threads());
   EXPECT_EQ(4, counter_);
 }
 
 }  // namespace base