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

net/proxy/sync_host_resolver_bridge.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 "net/proxy/sync_host_resolver_bridge.h"
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
-#include "base/lock.h"
 #include "base/message_loop.h"
+#include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 
 namespace net {
 
 // SyncHostResolverBridge::Core ----------------------------------------------
 
 class SyncHostResolverBridge::Core
     : public base::RefCountedThreadSafe<SyncHostResolverBridge::Core> {
  public:
   Core(HostResolver* resolver, MessageLoop* host_resolver_loop);
 
   int ResolveSynchronously(const HostResolver::RequestInfo& info,
                            AddressList* addresses);
 
   // Returns true if Shutdown() has been called.
   bool HasShutdown() const {
-    AutoLock l(lock_);
+    base::AutoLock l(lock_);
     return HasShutdownLocked();
   }
 
   // Called on |host_resolver_loop_|.
   void Shutdown();
 
  private:
   friend class base::RefCountedThreadSafe<SyncHostResolverBridge::Core>;
 
   bool HasShutdownLocked() const {
@@ skipping 19 matching lines @@
   HostResolver::RequestHandle outstanding_request_;
 
   // Event to notify completion of resolve request.  We always Signal() on
   // |host_resolver_loop_| and Wait() on a different thread.
   base::WaitableEvent event_;
 
   // True if Shutdown() has been called. Must hold |lock_| to access it.
   bool has_shutdown_;
 
   // Mutex to guard accesses to |has_shutdown_|.
-  mutable Lock lock_;
+      mutable base::Lock lock_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
 SyncHostResolverBridge::Core::Core(HostResolver* host_resolver,
                                    MessageLoop* host_resolver_loop)
     : host_resolver_(host_resolver),
       host_resolver_loop_(host_resolver_loop),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           callback_(this, &Core::OnResolveCompletion)),
@@ skipping 34 matching lines @@
   err_ = result;
   outstanding_request_ = NULL;
   event_.Signal();
 }
 
 int SyncHostResolverBridge::Core::WaitForResolveCompletion() {
   DCHECK_NE(MessageLoop::current(), host_resolver_loop_);
   event_.Wait();
 
   {
-    AutoLock l(lock_);
+    base::AutoLock l(lock_);
     if (HasShutdownLocked())
       return ERR_ABORTED;
     event_.Reset();
   }
 
   return err_;
 }
 
 void SyncHostResolverBridge::Core::Shutdown() {
   DCHECK_EQ(MessageLoop::current(), host_resolver_loop_);
 
   if (outstanding_request_) {
     host_resolver_->CancelRequest(outstanding_request_);
     outstanding_request_ = NULL;
   }
 
   {
-    AutoLock l(lock_);
+    base::AutoLock l(lock_);
     has_shutdown_ = true;
   }
 
   // Wake up the PAC thread in case it was waiting for resolve completion.
   event_.Signal();
 }
 
 // SyncHostResolverBridge -----------------------------------------------------
 
 SyncHostResolverBridge::SyncHostResolverBridge(HostResolver* host_resolver,
@@ skipping 29 matching lines @@
 void SyncHostResolverBridge::RemoveObserver(Observer* observer) {
   NOTREACHED();
 }
 
 void SyncHostResolverBridge::Shutdown() {
   DCHECK_EQ(MessageLoop::current(), host_resolver_loop_);
   core_->Shutdown();
 }
 
 }  // namespace net