Remove obsolete base/lock.h and fix up callers to use the new header file and

the base namespace. Fix several files including lock.h unnecessarily.

BUG=none
TEST=none
Original review=http://codereview.chromium.org/6142009/
Patch by leviw@chromium.org

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@72106 0039d316-1c4b-4281-b951-d872f2087c98

27 files changed, 125 insertions, 143 deletions

diff --git a/base/at_exit.h b/base/at_exit.h
index 35c96b9..15dcfc8 100644
--- a/base/at_exit.h
+++ b/base/at_exit.h
@@ -9,7 +9,7 @@
 #include <stack>
 
 #include "base/basictypes.h"
-#include "base/lock.h"
+#include "base/synchronization/lock.h"
 
 namespace base {
 
@@ -60,7 +60,7 @@ class AtExitManager {
     void* param_;
   };
 
-  Lock lock_;
+  base::Lock lock_;
   std::stack<CallbackAndParam> stack_;
   AtExitManager* next_manager_;  // Stack of managers to allow shadowing.
 
diff --git a/base/crypto/capi_util.cc b/base/crypto/capi_util.cc
index cf47a50..ef57a3c 100644
--- a/base/crypto/capi_util.cc
+++ b/base/crypto/capi_util.cc
@@ -5,8 +5,8 @@
 #include "base/crypto/capi_util.h"
 
 #include "base/basictypes.h"
-#include "base/lock.h"
 #include "base/singleton.h"
+#include "base/synchronization/lock.h"
 
 namespace {
 
@@ -18,7 +18,7 @@ class CAPIUtilSingleton {
 
   // Returns a lock to guard calls to CryptAcquireContext with
   // CRYPT_DELETEKEYSET or CRYPT_NEWKEYSET.
-  Lock& acquire_context_lock() {
+  base::Lock& acquire_context_lock() {
     return acquire_context_lock_;
   }
 
@@ -28,7 +28,7 @@ class CAPIUtilSingleton {
 
   CAPIUtilSingleton() {}
 
-  Lock acquire_context_lock_;
+  base::Lock acquire_context_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(CAPIUtilSingleton);
 };
@@ -43,7 +43,7 @@ BOOL CryptAcquireContextLocked(HCRYPTPROV* prov,
                                DWORD prov_type,
                                DWORD flags)
 {
-  AutoLock lock(CAPIUtilSingleton::GetInstance()->acquire_context_lock());
+  base::AutoLock lock(CAPIUtilSingleton::GetInstance()->acquire_context_lock());
   return CryptAcquireContext(prov, container, provider, prov_type, flags);
 }
 
diff --git a/base/debug/stack_trace_win.cc b/base/debug/stack_trace_win.cc
index 6f4ad02..510d35b 100644
--- a/base/debug/stack_trace_win.cc
+++ b/base/debug/stack_trace_win.cc
@@ -10,9 +10,9 @@
 #include <iostream>
 
 #include "base/basictypes.h"
-#include "base/lock.h"
 #include "base/logging.h"
 #include "base/singleton.h"
+#include "base/synchronization/lock.h"
 
 namespace base {
 namespace debug {
@@ -59,7 +59,7 @@ class SymbolContext {
   void OutputTraceToStream(const void* const* trace,
                            int count,
                            std::ostream* os) {
-    AutoLock lock(lock_);
+    base::AutoLock lock(lock_);
 
     for (size_t i = 0; (i < count) && os->good(); ++i) {
       const int kMaxNameLength = 256;
@@ -129,7 +129,7 @@ class SymbolContext {
   }
 
   DWORD init_error_;
-  Lock lock_;
+  base::Lock lock_;
   DISALLOW_COPY_AND_ASSIGN(SymbolContext);
 };
 
diff --git a/base/debug/trace_event.h b/base/debug/trace_event.h
index 160bbc8..3eb1f49a 100644
--- a/base/debug/trace_event.h
+++ b/base/debug/trace_event.h
@@ -31,9 +31,9 @@
 
 #include <string>
 
-#include "base/lock.h"
 #include "base/scoped_ptr.h"
 #include "base/singleton.h"
+#include "base/synchronization/lock.h"
 #include "base/time.h"
 #include "base/timer.h"
 
@@ -135,7 +135,7 @@ class TraceLog {
 
   bool enabled_;
   FILE* log_file_;
-  Lock file_lock_;
+  base::Lock file_lock_;
   TimeTicks trace_start_time_;
   scoped_ptr<base::ProcessMetrics> process_metrics_;
   RepeatingTimer<TraceLog> timer_;
diff --git a/base/i18n/file_util_icu.cc b/base/i18n/file_util_icu.cc
index 34eefac..ba69da0 100644
--- a/base/i18n/file_util_icu.cc
+++ b/base/i18n/file_util_icu.cc
@@ -90,7 +90,7 @@ class LocaleAwareComparator {
   int Compare(const string16& a, const string16& b) {
     // We are not sure if Collator::compare is thread-safe.
     // Use an AutoLock just in case.
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
 
     UErrorCode error_code = U_ZERO_ERROR;
     UCollationResult result = collator_->compare(
@@ -120,7 +120,7 @@ class LocaleAwareComparator {
   }
 
   scoped_ptr<icu::Collator> collator_;
-  Lock lock_;
+  base::Lock lock_;
   friend struct DefaultSingletonTraits<LocaleAwareComparator>;
 
   DISALLOW_COPY_AND_ASSIGN(LocaleAwareComparator);
diff --git a/base/linux_util.cc b/base/linux_util.cc
index e1f7275..4e7cc5c 100644
--- a/base/linux_util.cc
+++ b/base/linux_util.cc
@@ -17,12 +17,12 @@
 
 #include "base/command_line.h"
 #include "base/file_util.h"
-#include "base/lock.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/singleton.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
+#include "base/synchronization/lock.h"
 
 namespace {
 
@@ -51,7 +51,7 @@ class LinuxDistroHelper {
   // we automatically move to STATE_CHECK_STARTED so nobody else will
   // do the check.
   LinuxDistroState State() {
-    AutoLock scoped_lock(lock_);
+    base::AutoLock scoped_lock(lock_);
     if (STATE_DID_NOT_CHECK == state_) {
       state_ = STATE_CHECK_STARTED;
       return STATE_DID_NOT_CHECK;
@@ -61,13 +61,13 @@ class LinuxDistroHelper {
 
   // Indicate the check finished, move to STATE_CHECK_FINISHED.
   void CheckFinished() {
-    AutoLock scoped_lock(lock_);
+    base::AutoLock scoped_lock(lock_);
     DCHECK(state_ == STATE_CHECK_STARTED);
     state_ = STATE_CHECK_FINISHED;
   }
 
  private:
-  Lock lock_;
+  base::Lock lock_;
   LinuxDistroState state_;
 };
 #endif  // if defined(OS_LINUX)
diff --git a/base/lock.h b/base/lock.h
deleted file mode 100644
index 7c90d86..0000000
--- a/base/lock.h
+++ /dev/null
@@ -1,18 +0,0 @@
-// 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.
-
-#ifndef BASE_LOCK_H_
-#define BASE_LOCK_H_
-#pragma once
-
-// This is a temporary forwarding file so not every user of lock needs to
-// be updated at once.
-// TODO(brettw) remove this and fix everybody up to using the new location.
-#include "base/synchronization/lock.h"
-
-using base::AutoLock;
-using base::AutoUnlock;
-using base::Lock;
-
-#endif  // BASE_LOCK_H_
diff --git a/base/message_loop.cc b/base/message_loop.cc
index e74331a..518a0fd 100644
--- a/base/message_loop.cc
+++ b/base/message_loop.cc
@@ -394,7 +394,7 @@ void MessageLoop::ReloadWorkQueue() {
 
   // Acquire all we can from the inter-thread queue with one lock acquisition.
   {
-    AutoLock lock(incoming_queue_lock_);
+    base::AutoLock lock(incoming_queue_lock_);
     if (incoming_queue_.empty())
       return;
     incoming_queue_.Swap(&work_queue_);  // Constant time
@@ -495,7 +495,7 @@ void MessageLoop::PostTask_Helper(
 
   scoped_refptr<base::MessagePump> pump;
   {
-    AutoLock locked(incoming_queue_lock_);
+    base::AutoLock locked(incoming_queue_lock_);
 
     bool was_empty = incoming_queue_.empty();
     incoming_queue_.push(pending_task);
diff --git a/base/message_loop.h b/base/message_loop.h
index d5093a9..7a3af6e 100644
--- a/base/message_loop.h
+++ b/base/message_loop.h
@@ -10,10 +10,10 @@
 #include <string>
 
 #include "base/basictypes.h"
-#include "base/lock.h"
 #include "base/message_pump.h"
 #include "base/observer_list.h"
 #include "base/ref_counted.h"
+#include "base/synchronization/lock.h"
 #include "base/task.h"
 
 #if defined(OS_WIN)
@@ -466,7 +466,7 @@ class MessageLoop : public base::MessagePump::Delegate {
   // will be handled by the TimerManager.
   TaskQueue incoming_queue_;
   // Protect access to incoming_queue_.
-  Lock incoming_queue_lock_;
+  base::Lock incoming_queue_lock_;
 
   RunState* state_;
 
diff --git a/base/message_loop_proxy_impl.h b/base/message_loop_proxy_impl.h
index 44ab2ea..03e0271 100644
--- a/base/message_loop_proxy_impl.h
+++ b/base/message_loop_proxy_impl.h
@@ -6,9 +6,9 @@
 #define BASE_MESSAGE_LOOP_PROXY_IMPL_H_
 #pragma once
 
-#include "base/lock.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
+#include "base/synchronization/lock.h"
 
 namespace base {
 
@@ -50,7 +50,7 @@ class MessageLoopProxyImpl : public MessageLoopProxy,
   friend class MessageLoopProxy;
 
   // The lock that protects access to target_message_loop_.
-  mutable Lock message_loop_lock_;
+  mutable base::Lock message_loop_lock_;
   MessageLoop* target_message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(MessageLoopProxyImpl);
diff --git a/base/metrics/field_trial.h b/base/metrics/field_trial.h
index 077a88c..ec3a483 100644
--- a/base/metrics/field_trial.h
+++ b/base/metrics/field_trial.h
@@ -67,8 +67,8 @@
 #include <string>
 
 #include "base/gtest_prod_util.h"
-#include "base/lock.h"
 #include "base/ref_counted.h"
+#include "base/synchronization/lock.h"
 #include "base/time.h"
 
 namespace base {
@@ -271,7 +271,7 @@ class FieldTrialList {
   TimeTicks application_start_time_;
 
   // Lock for access to registered_.
-  Lock lock_;
+  base::Lock lock_;
   RegistrationList registered_;
 
   DISALLOW_COPY_AND_ASSIGN(FieldTrialList);
diff --git a/base/metrics/stats_table.h b/base/metrics/stats_table.h
index 32b22eb..aaf8062 100644
--- a/base/metrics/stats_table.h
+++ b/base/metrics/stats_table.h
@@ -25,7 +25,7 @@
 
 #include "base/basictypes.h"
 #include "base/hash_tables.h"
-#include "base/lock.h"
+#include "base/synchronization/lock.h"
 #include "base/threading/thread_local_storage.h"
 
 namespace base {
@@ -175,7 +175,7 @@ class StatsTable {
   Private* impl_;
 
   // The counters_lock_ protects the counters_ hash table.
-  Lock counters_lock_;
+  base::Lock counters_lock_;
 
   // The counters_ hash map is an in-memory hash of the counters.
   // It is used for quick lookup of counters, but is cannot be used
diff --git a/base/nss_util.cc b/base/nss_util.cc
index 384cc0d..8e250c4 100644
--- a/base/nss_util.cc
+++ b/base/nss_util.cc
@@ -31,8 +31,8 @@
 #if defined(USE_NSS)
 #include "base/crypto/crypto_module_blocking_password_delegate.h"
 #include "base/environment.h"
-#include "base/lock.h"
 #include "base/scoped_ptr.h"
+#include "base/synchronization/lock.h"
 #endif  // defined(USE_NSS)
 
 namespace base {
diff --git a/base/observer_list_threadsafe.h b/base/observer_list_threadsafe.h
index ecdad90..47a662e 100644
--- a/base/observer_list_threadsafe.h
+++ b/base/observer_list_threadsafe.h
@@ -93,7 +93,7 @@ class ObserverListThreadSafe
     if (!loop)
       return;  // Some unittests may access this without a message loop.
     {
-      AutoLock lock(list_lock_);
+      base::AutoLock lock(list_lock_);
       if (observer_lists_.find(loop) == observer_lists_.end())
         observer_lists_[loop] = new ObserverList<ObserverType>(type_);
       list = observer_lists_[loop];
@@ -112,7 +112,7 @@ class ObserverListThreadSafe
     if (!loop)
       return;  // On shutdown, it is possible that current() is already null.
     {
-      AutoLock lock(list_lock_);
+      base::AutoLock lock(list_lock_);
       list = observer_lists_[loop];
       if (!list) {
         NOTREACHED() << "RemoveObserver called on for unknown thread";
@@ -165,7 +165,7 @@ class ObserverListThreadSafe
 
   template <class Method, class Params>
   void Notify(const UnboundMethod<ObserverType, Method, Params>& method) {
-    AutoLock lock(list_lock_);
+    base::AutoLock lock(list_lock_);
     typename ObserversListMap::iterator it;
     for (it = observer_lists_.begin(); it != observer_lists_.end(); ++it) {
       MessageLoop* loop = (*it).first;
@@ -187,7 +187,7 @@ class ObserverListThreadSafe
 
     // Check that this list still needs notifications.
     {
-      AutoLock lock(list_lock_);
+      base::AutoLock lock(list_lock_);
       typename ObserversListMap::iterator it =
           observer_lists_.find(MessageLoop::current());
 
@@ -209,7 +209,7 @@ class ObserverListThreadSafe
     // If there are no more observers on the list, we can now delete it.
     if (list->size() == 0) {
       {
-        AutoLock lock(list_lock_);
+        base::AutoLock lock(list_lock_);
         // Remove |list| if it's not already removed.
         // This can happen if multiple observers got removed in a notification.
         // See http://crbug.com/55725.
@@ -225,7 +225,7 @@ class ObserverListThreadSafe
   typedef std::map<MessageLoop*, ObserverList<ObserverType>*> ObserversListMap;
 
   // These are marked mutable to facilitate having NotifyAll be const.
-  Lock list_lock_;  // Protects the observer_lists_.
+  base::Lock list_lock_;  // Protects the observer_lists_.
   ObserversListMap observer_lists_;
   const NotificationType type_;
 
diff --git a/base/openssl_util.cc b/base/openssl_util.cc
index bc174fa..931485a 100644
--- a/base/openssl_util.cc
+++ b/base/openssl_util.cc
@@ -7,11 +7,11 @@
 #include <openssl/err.h>
 #include <openssl/ssl.h>
 
-#include "base/lock.h"
 #include "base/logging.h"
 #include "base/scoped_vector.h"
 #include "base/singleton.h"
 #include "base/string_piece.h"
+#include "base/synchronization/lock.h"
 
 namespace base {
 
@@ -46,7 +46,7 @@ class OpenSSLInitSingleton {
     int num_locks = CRYPTO_num_locks();
     locks_.reserve(num_locks);
     for (int i = 0; i < num_locks; ++i)
-      locks_.push_back(new Lock());
+      locks_.push_back(new base::Lock());
     CRYPTO_set_locking_callback(LockingCallback);
     CRYPTO_set_id_callback(CurrentThreadId);
   }
@@ -70,7 +70,7 @@ class OpenSSLInitSingleton {
   }
 
   // These locks are used and managed by OpenSSL via LockingCallback().
-  ScopedVector<Lock> locks_;
+  ScopedVector<base::Lock> locks_;
 
   DISALLOW_COPY_AND_ASSIGN(OpenSSLInitSingleton);
 };
diff --git a/base/path_service.cc b/base/path_service.cc
index 56ce5fa..117feb5 100644
--- a/base/path_service.cc
+++ b/base/path_service.cc
@@ -14,8 +14,8 @@
 #include "base/file_util.h"
 #include "base/hash_tables.h"
 #include "base/lazy_instance.h"
-#include "base/lock.h"
 #include "base/logging.h"
+#include "base/synchronization/lock.h"
 
 namespace base {
   bool PathProvider(int key, FilePath* result);
@@ -92,9 +92,9 @@ static Provider base_provider_posix = {
 
 
 struct PathData {
-  Lock      lock;
-  PathMap   cache;      // Cache mappings from path key to path value.
-  PathMap   overrides;  // Track path overrides.
+  base::Lock lock;
+  PathMap cache;        // Cache mappings from path key to path value.
+  PathMap overrides;    // Track path overrides.
   Provider* providers;  // Linked list of path service providers.
 
   PathData() {
@@ -130,7 +130,7 @@ static PathData* GetPathData() {
 // static
 bool PathService::GetFromCache(int key, FilePath* result) {
   PathData* path_data = GetPathData();
-  AutoLock scoped_lock(path_data->lock);
+  base::AutoLock scoped_lock(path_data->lock);
 
   // check for a cached version
   PathMap::const_iterator it = path_data->cache.find(key);
@@ -144,7 +144,7 @@ bool PathService::GetFromCache(int key, FilePath* result) {
 // static
 bool PathService::GetFromOverrides(int key, FilePath* result) {
   PathData* path_data = GetPathData();
-  AutoLock scoped_lock(path_data->lock);
+  base::AutoLock scoped_lock(path_data->lock);
 
   // check for an overriden version.
   PathMap::const_iterator it = path_data->overrides.find(key);
@@ -158,7 +158,7 @@ bool PathService::GetFromOverrides(int key, FilePath* result) {
 // static
 void PathService::AddToCache(int key, const FilePath& path) {
   PathData* path_data = GetPathData();
-  AutoLock scoped_lock(path_data->lock);
+  base::AutoLock scoped_lock(path_data->lock);
   // Save the computed path in our cache.
   path_data->cache[key] = path;
 }
@@ -225,7 +225,7 @@ bool PathService::Override(int key, const FilePath& path) {
   if (!file_util::AbsolutePath(&file_path))
     return false;
 
-  AutoLock scoped_lock(path_data->lock);
+  base::AutoLock scoped_lock(path_data->lock);
 
   // Clear the cache now. Some of its entries could have depended
   // on the value we are overriding, and are now out of sync with reality.
@@ -243,7 +243,7 @@ void PathService::RegisterProvider(ProviderFunc func, int key_start,
   DCHECK(path_data);
   DCHECK(key_end > key_start);
 
-  AutoLock scoped_lock(path_data->lock);
+  base::AutoLock scoped_lock(path_data->lock);
 
   Provider* p;
 
diff --git a/base/synchronization/condition_variable.h b/base/synchronization/condition_variable.h
index 3acd0ac..db75a49 100644
--- a/base/synchronization/condition_variable.h
+++ b/base/synchronization/condition_variable.h
@@ -75,7 +75,7 @@
 #endif
 
 #include "base/basictypes.h"
-#include "base/lock.h"
+#include "base/synchronization/lock.h"
 
 namespace base {
 
@@ -156,10 +156,10 @@ class ConditionVariable {
   RunState run_state_;
 
   // Private critical section for access to member data.
-  Lock internal_lock_;
+  base::Lock internal_lock_;
 
   // Lock that is acquired before calling Wait().
-  Lock& user_lock_;
+  base::Lock& user_lock_;
 
   // Events that threads are blocked on.
   Event waiting_list_;
@@ -176,7 +176,7 @@ class ConditionVariable {
   pthread_cond_t condition_;
   pthread_mutex_t* user_mutex_;
 #if !defined(NDEBUG)
-  Lock* user_lock_;     // Needed to adjust shadow lock state on wait.
+  base::Lock* user_lock_;     // Needed to adjust shadow lock state on wait.
 #endif
 
 #endif
diff --git a/base/synchronization/condition_variable_unittest.cc b/base/synchronization/condition_variable_unittest.cc
index 8cfe4fe..cf18320 100644
--- a/base/synchronization/condition_variable_unittest.cc
+++ b/base/synchronization/condition_variable_unittest.cc
@@ -8,11 +8,11 @@
 #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"
@@ -198,7 +198,7 @@ TEST_F(ConditionVariableTest, MultiThreadConsumerTest) {
   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();
   }
@@ -209,7 +209,7 @@ TEST_F(ConditionVariableTest, MultiThreadConsumerTest) {
 
   {
     // 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());
@@ -232,7 +232,7 @@ TEST_F(ConditionVariableTest, MultiThreadConsumerTest) {
 
   {
     // 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
@@ -252,7 +252,7 @@ TEST_F(ConditionVariableTest, MultiThreadConsumerTest) {
 
   {
     // 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());
@@ -278,7 +278,7 @@ TEST_F(ConditionVariableTest, MultiThreadConsumerTest) {
 
   {
     // 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();
 
@@ -301,7 +301,7 @@ TEST_F(ConditionVariableTest, MultiThreadConsumerTest) {
   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());
@@ -322,7 +322,7 @@ TEST_F(ConditionVariableTest, MultiThreadConsumerTest) {
   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());
@@ -343,7 +343,7 @@ TEST_F(ConditionVariableTest, MultiThreadConsumerTest) {
   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());
@@ -362,7 +362,7 @@ TEST_F(ConditionVariableTest, MultiThreadConsumerTest) {
   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());
@@ -381,11 +381,11 @@ TEST_F(ConditionVariableTest, LargeFastTaskTest) {
   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();
   }
@@ -395,7 +395,7 @@ TEST_F(ConditionVariableTest, LargeFastTaskTest) {
 
   {
     // 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());
@@ -412,7 +412,7 @@ TEST_F(ConditionVariableTest, LargeFastTaskTest) {
   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();
   }
@@ -423,7 +423,7 @@ TEST_F(ConditionVariableTest, LargeFastTaskTest) {
   {
     // 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());
@@ -440,7 +440,7 @@ TEST_F(ConditionVariableTest, LargeFastTaskTest) {
 
   // 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();
   }
@@ -451,7 +451,7 @@ TEST_F(ConditionVariableTest, LargeFastTaskTest) {
   {
     // 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());
@@ -500,7 +500,7 @@ WorkQueue::WorkQueue(int thread_count)
 
 WorkQueue::~WorkQueue() {
   {
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
     SetShutdown();
   }
   work_is_available_.Broadcast();  // Tell them all to terminate.
@@ -558,7 +558,7 @@ bool WorkQueue::shutdown() const {
 // 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_);
@@ -657,7 +657,7 @@ void WorkQueue::SetShutdown() {
 void WorkQueue::SpinUntilAllThreadsAreWaiting() {
   while (true) {
     {
-      AutoLock auto_lock(lock_);
+      base::AutoLock auto_lock(lock_);
       if (waiting_thread_count_ == thread_count_)
         break;
     }
@@ -668,7 +668,7 @@ void WorkQueue::SpinUntilAllThreadsAreWaiting() {
 void WorkQueue::SpinUntilTaskCountLessThan(int task_count) {
   while (true) {
     {
-      AutoLock auto_lock(lock_);
+      base::AutoLock auto_lock(lock_);
       if (task_count_ < task_count)
         break;
     }
@@ -698,7 +698,7 @@ void WorkQueue::SpinUntilTaskCountLessThan(int task_count) {
 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.
@@ -709,7 +709,7 @@ void WorkQueue::ThreadMain() {
     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();
@@ -732,13 +732,13 @@ void WorkQueue::ThreadMain() {
     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);
     }
diff --git a/base/synchronization/waitable_event.h b/base/synchronization/waitable_event.h
index 01b5987..9f357d1 100644
--- a/base/synchronization/waitable_event.h
+++ b/base/synchronization/waitable_event.h
@@ -15,8 +15,8 @@
 #if defined(OS_POSIX)
 #include <list>
 #include <utility>
-#include "base/lock.h"
 #include "base/ref_counted.h"
+#include "base/synchronization/lock.h"
 #endif
 
 namespace base {
@@ -149,7 +149,7 @@ class WaitableEvent {
 
     bool Dequeue(Waiter* waiter, void* tag);
 
-    Lock lock_;
+    base::Lock lock_;
     const bool manual_reset_;
     bool signaled_;
     std::list<Waiter*> waiters_;
diff --git a/base/third_party/dmg_fp/dtoa_wrapper.cc b/base/third_party/dmg_fp/dtoa_wrapper.cc
index fbbaf80..e34b8a6 100644
--- a/base/third_party/dmg_fp/dtoa_wrapper.cc
+++ b/base/third_party/dmg_fp/dtoa_wrapper.cc
@@ -4,12 +4,12 @@
 //
 // The purpose of this file is to supply the macro definintions necessary
 // to make third_party/dmg_fp/dtoa.cc threadsafe.
-#include "base/lock.h"
+#include "base/synchronization/lock.h"
 #include "base/logging.h"
 
 // We need two locks because they're sometimes grabbed at the same time.
 // A single lock would lead to an attempted recursive grab.
-static Lock dtoa_locks[2];
+static base::Lock dtoa_locks[2];
 
 /*
  * This define and the code below is to trigger thread-safe behavior
diff --git a/base/threading/simple_thread.h b/base/threading/simple_thread.h
index f55bd62..1631336 100644
--- a/base/threading/simple_thread.h
+++ b/base/threading/simple_thread.h
@@ -46,8 +46,8 @@
 #include <vector>
 
 #include "base/basictypes.h"
-#include "base/lock.h"
 #include "base/threading/platform_thread.h"
+#include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 
 namespace base {
@@ -173,7 +173,7 @@ class DelegateSimpleThreadPool : public DelegateSimpleThread::Delegate {
   int num_threads_;
   std::vector<DelegateSimpleThread*> threads_;
   std::queue<Delegate*> delegates_;
-  Lock lock_;            // Locks delegates_
+  base::Lock lock_;            // Locks delegates_
   WaitableEvent dry_;    // Not signaled when there is no work to do.
 };
 
diff --git a/base/threading/thread_checker.h b/base/threading/thread_checker.h
index c0010fb..712b5b5 100644
--- a/base/threading/thread_checker.h
+++ b/base/threading/thread_checker.h
@@ -7,7 +7,7 @@
 #pragma once
 
 #ifndef NDEBUG
-#include "base/lock.h"
+#include "base/synchronization/lock.h"
 #include "base/threading/platform_thread.h"
 #endif // NDEBUG
 
@@ -51,7 +51,7 @@ class ThreadChecker {
  private:
   void EnsureThreadIdAssigned() const;
 
-  mutable Lock lock_;
+  mutable base::Lock lock_;
   // This is mutable so that CalledOnValidThread can set it.
   // It's guarded by |lock_|.
   mutable PlatformThreadId valid_thread_id_;
diff --git a/base/threading/thread_collision_warner_unittest.cc b/base/threading/thread_collision_warner_unittest.cc
index 68987c3..a3d3b66 100644
--- a/base/threading/thread_collision_warner_unittest.cc
+++ b/base/threading/thread_collision_warner_unittest.cc
@@ -3,8 +3,8 @@
 // found in the LICENSE file.
 
 #include "base/compiler_specific.h"
-#include "base/lock.h"
 #include "base/scoped_ptr.h"
+#include "base/synchronization/lock.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/simple_thread.h"
 #include "base/threading/thread_collision_warner.h"
@@ -266,30 +266,30 @@ TEST(ThreadCollisionTest, MTSynchedScopedBookCriticalSectionTest) {
   // a lock.
   class QueueUser : public base::DelegateSimpleThread::Delegate {
    public:
-    QueueUser(NonThreadSafeQueue& queue, Lock& lock)
+    QueueUser(NonThreadSafeQueue& queue, base::Lock& lock)
         : queue_(queue),
           lock_(lock) {}
 
     virtual void Run() {
       {
-        AutoLock auto_lock(lock_);
+        base::AutoLock auto_lock(lock_);
         queue_.push(0);
       }
       {
-        AutoLock auto_lock(lock_);
+        base::AutoLock auto_lock(lock_);
         queue_.pop();
       }
     }
    private:
     NonThreadSafeQueue& queue_;
-    Lock& lock_;
+    base::Lock& lock_;
   };
 
   AssertReporter* local_reporter = new AssertReporter();
 
   NonThreadSafeQueue queue(local_reporter);
 
-  Lock lock;
+  base::Lock lock;
 
   QueueUser queue_user_a(queue, lock);
   QueueUser queue_user_b(queue, lock);
@@ -340,34 +340,34 @@ TEST(ThreadCollisionTest, MTSynchedScopedRecursiveBookCriticalSectionTest) {
   // a lock.
   class QueueUser : public base::DelegateSimpleThread::Delegate {
    public:
-    QueueUser(NonThreadSafeQueue& queue, Lock& lock)
+    QueueUser(NonThreadSafeQueue& queue, base::Lock& lock)
         : queue_(queue),
           lock_(lock) {}
 
     virtual void Run() {
       {
-        AutoLock auto_lock(lock_);
+        base::AutoLock auto_lock(lock_);
         queue_.push(0);
       }
       {
-        AutoLock auto_lock(lock_);
+        base::AutoLock auto_lock(lock_);
         queue_.bar();
       }
       {
-        AutoLock auto_lock(lock_);
+        base::AutoLock auto_lock(lock_);
         queue_.pop();
       }
     }
    private:
     NonThreadSafeQueue& queue_;
-    Lock& lock_;
+    base::Lock& lock_;
   };
 
   AssertReporter* local_reporter = new AssertReporter();
 
   NonThreadSafeQueue queue(local_reporter);
 
-  Lock lock;
+  base::Lock lock;
 
   QueueUser queue_user_a(queue, lock);
   QueueUser queue_user_b(queue, lock);
diff --git a/base/threading/worker_pool_posix_unittest.cc b/base/threading/worker_pool_posix_unittest.cc
index 332c55e..c984ee3 100644
--- a/base/threading/worker_pool_posix_unittest.cc
+++ b/base/threading/worker_pool_posix_unittest.cc
@@ -6,8 +6,8 @@
 
 #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"
@@ -61,12 +61,12 @@ class IncrementingTask : public Task {
 
   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());
   }
 
@@ -100,7 +100,7 @@ class BlockingIncrementingTask : public Task {
 
   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();
@@ -138,14 +138,14 @@ class PosixDynamicThreadPoolTest : public testing::Test {
   }
 
   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();
     }
@@ -249,7 +249,7 @@ TEST_F(PosixDynamicThreadPoolTest, Complex) {
 
   // 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();
diff --git a/base/time_win.cc b/base/time_win.cc
index ca3aef1..601211c 100644
--- a/base/time_win.cc
+++ b/base/time_win.cc
@@ -41,10 +41,10 @@
 #include <mmsystem.h>
 
 #include "base/basictypes.h"
-#include "base/lock.h"
 #include "base/logging.h"
 #include "base/cpu.h"
 #include "base/singleton.h"
+#include "base/synchronization/lock.h"
 
 using base::Time;
 using base::TimeDelta;
@@ -262,7 +262,7 @@ DWORD last_seen_now = 0;
 // easy to use a Singleton without even knowing it, and that may lead to many
 // gotchas). Its impact on startup time should be negligible due to low-level
 // nature of time code.
-Lock rollover_lock;
+base::Lock rollover_lock;
 
 // We use timeGetTime() to implement TimeTicks::Now().  This can be problematic
 // because it returns the number of milliseconds since Windows has started,
@@ -270,7 +270,7 @@ Lock rollover_lock;
 // rollover ourselves, which works if TimeTicks::Now() is called at least every
 // 49 days.
 TimeDelta RolloverProtectedNow() {
-  AutoLock locked(rollover_lock);
+  base::AutoLock locked(rollover_lock);
   // We should hold the lock while calling tick_function to make sure that
   // we keep last_seen_now stay correctly in sync.
   DWORD now = tick_function();
@@ -409,4 +409,4 @@ int64 TimeTicks::GetQPCDriftMicroseconds() {
 // static
 bool TimeTicks::IsHighResClockWorking() {
   return HighResNowSingleton::GetInstance()->IsUsingHighResClock();
-}
\ No newline at end of file
+}
diff --git a/base/tracked_objects.cc b/base/tracked_objects.cc
index d62aa59..a9f81b1 100644
--- a/base/tracked_objects.cc
+++ b/base/tracked_objects.cc
@@ -85,7 +85,7 @@ Births::Births(const Location& location)
 // static
 ThreadData* ThreadData::first_ = NULL;
 // static
-Lock ThreadData::list_lock_;
+base::Lock ThreadData::list_lock_;
 
 // static
 ThreadData::Status ThreadData::status_ = ThreadData::UNINITIALIZED;
@@ -111,7 +111,7 @@ ThreadData* ThreadData::current() {
     bool too_late_to_create = false;
     {
       registry = new ThreadData;
-      AutoLock lock(list_lock_);
+      base::AutoLock lock(list_lock_);
       // Use lock to insure we have most recent status.
       if (!IsActive()) {
         too_late_to_create = true;
@@ -285,7 +285,7 @@ Births* ThreadData::TallyABirth(const Location& location) {
   Births* tracker = new Births(location);
   // Lock since the map may get relocated now, and other threads sometimes
   // snapshot it (but they lock before copying it).
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   birth_map_[location] = tracker;
   return tracker;
 }
@@ -305,13 +305,13 @@ void ThreadData::TallyADeath(const Births& lifetimes,
     return;
   }
 
-  AutoLock lock(lock_);  // Lock since the map may get relocated now.
+  base::AutoLock lock(lock_);  // Lock since the map may get relocated now.
   death_map_[&lifetimes].RecordDeath(duration);
 }
 
 // static
 ThreadData* ThreadData::first() {
-  AutoLock lock(list_lock_);
+  base::AutoLock lock(list_lock_);
   return first_;
 }
 
@@ -323,7 +323,7 @@ const std::string ThreadData::ThreadName() const {
 
 // This may be called from another thread.
 void ThreadData::SnapshotBirthMap(BirthMap *output) const {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   for (BirthMap::const_iterator it = birth_map_.begin();
        it != birth_map_.end(); ++it)
     (*output)[it->first] = it->second;
@@ -331,7 +331,7 @@ void ThreadData::SnapshotBirthMap(BirthMap *output) const {
 
 // This may be called from another thread.
 void ThreadData::SnapshotDeathMap(DeathMap *output) const {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   for (DeathMap::const_iterator it = death_map_.begin();
        it != death_map_.end(); ++it)
     (*output)[it->first] = it->second;
@@ -348,7 +348,7 @@ void ThreadData::ResetAllThreadData() {
 }
 
 void ThreadData::Reset() {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
   for (DeathMap::iterator it = death_map_.begin();
        it != death_map_.end(); ++it)
     it->second.Clear();
@@ -372,7 +372,7 @@ class ThreadData::ThreadSafeDownCounter {
 
  private:
   size_t remaining_count_;
-  Lock lock_;  // protect access to remaining_count_.
+  base::Lock lock_;  // protect access to remaining_count_.
 };
 
 ThreadData::ThreadSafeDownCounter::ThreadSafeDownCounter(size_t count)
@@ -382,7 +382,7 @@ ThreadData::ThreadSafeDownCounter::ThreadSafeDownCounter(size_t count)
 
 bool ThreadData::ThreadSafeDownCounter::LastCaller() {
   {
-    AutoLock lock(lock_);
+    base::AutoLock lock(lock_);
     if (--remaining_count_)
       return false;
   }  // Release lock, so we can delete everything in this instance.
@@ -461,12 +461,12 @@ bool ThreadData::StartTracking(bool status) {
 #endif
 
   if (!status) {
-    AutoLock lock(list_lock_);
+    base::AutoLock lock(list_lock_);
     DCHECK(status_ == ACTIVE || status_ == SHUTDOWN);
     status_ = SHUTDOWN;
     return true;
   }
-  AutoLock lock(list_lock_);
+  base::AutoLock lock(list_lock_);
   DCHECK(status_ == UNINITIALIZED);
   CHECK(tls_index_.Initialize(NULL));
   status_ = ACTIVE;
@@ -504,7 +504,7 @@ void ThreadData::ShutdownSingleThreadedCleanup() {
     return;
   ThreadData* thread_data_list;
   {
-    AutoLock lock(list_lock_);
+    base::AutoLock lock(list_lock_);
     thread_data_list = first_;
     first_ = NULL;
   }
@@ -614,7 +614,7 @@ void DataCollector::Append(const ThreadData& thread_data) {
   thread_data.SnapshotDeathMap(&death_map);
 
   // Use our lock to protect our accumulation activity.
-  AutoLock lock(accumulation_lock_);
+  base::AutoLock lock(accumulation_lock_);
 
   DCHECK(count_of_contributing_threads_);
 
diff --git a/base/tracked_objects.h b/base/tracked_objects.h
index 07731ff..ed629c3 100644
--- a/base/tracked_objects.h
+++ b/base/tracked_objects.h
@@ -10,7 +10,7 @@
 #include <string>
 #include <vector>
 
-#include "base/lock.h"
+#include "base/synchronization/lock.h"
 #include "base/tracked.h"
 #include "base/threading/thread_local_storage.h"
 
@@ -322,7 +322,7 @@ class DataCollector {
   // seen a death count.
   BirthCount global_birth_count_;
 
-  Lock accumulation_lock_;  // Protects access during accumulation phase.
+  base::Lock accumulation_lock_;  // Protects access during accumulation phase.
 
   DISALLOW_COPY_AND_ASSIGN(DataCollector);
 };
@@ -577,7 +577,7 @@ class ThreadData {
   // Link to the most recently created instance (starts a null terminated list).
   static ThreadData* first_;
   // Protection for access to first_.
-  static Lock list_lock_;
+  static base::Lock list_lock_;
 
   // We set status_ to SHUTDOWN when we shut down the tracking service. This
   // setting is redundantly established by all participating threads so that we
@@ -613,7 +613,7 @@ class ThreadData {
   // thread, or reading from another thread.  For reading from this thread we
   // don't need a lock, as there is no potential for a conflict since the
   // writing is only done from this thread.
-  mutable Lock lock_;
+  mutable base::Lock lock_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadData);
 };