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

net/proxy/polling_proxy_config_service.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/polling_proxy_config_service.h"
 
-#include "base/lock.h"
 #include "base/message_loop_proxy.h"
 #include "base/observer_list.h"
 #include "base/scoped_ptr.h"
+#include "base/synchronization/lock.h"
 #include "base/threading/worker_pool.h"
 #include "net/proxy/proxy_config.h"
 
 namespace net {
 
 // Reference-counted wrapper that does all the work (needs to be
 // reference-counted since we post tasks between threads; may outlive
 // the parent PollingProxyConfigService).
 class PollingProxyConfigService::Core
     : public base::RefCountedThreadSafe<PollingProxyConfigService::Core> {
  public:
   Core(base::TimeDelta poll_interval,
        GetConfigFunction get_config_func)
       : get_config_func_(get_config_func),
         poll_interval_(poll_interval),
         have_initialized_origin_loop_(false),
         has_config_(false),
         poll_task_outstanding_(false),
         poll_task_queued_(false) {
   }
 
   // Called when the parent PollingProxyConfigService is destroyed
   // (observers should not be called past this point).
   void Orphan() {
-    AutoLock l(lock_);
+    base::AutoLock l(lock_);
     origin_loop_proxy_ = NULL;
   }
 
   bool GetLatestProxyConfig(ProxyConfig* config) {
     LazyInitializeOriginLoop();
     DCHECK(origin_loop_proxy_->BelongsToCurrentThread());
 
     OnLazyPoll();
 
     // If we have already retrieved the proxy settings (on worker thread)
@@ skipping 46 matching lines @@
         FROM_HERE,
         NewRunnableMethod(this, &Core::PollOnWorkerThread, get_config_func_),
         true);
   }
 
  private:
   void PollOnWorkerThread(GetConfigFunction func) {
     ProxyConfig config;
     func(&config);
 
-    AutoLock l(lock_);
+    base::AutoLock l(lock_);
     if (origin_loop_proxy_) {
       origin_loop_proxy_->PostTask(
           FROM_HERE,
           NewRunnableMethod(this, &Core::GetConfigCompleted, config));
     }
   }
 
   // Called after the worker thread has finished retrieving a configuration.
   void GetConfigCompleted(const ProxyConfig& config) {
     DCHECK(poll_task_outstanding_);
@@ skipping 25 matching lines @@
       have_initialized_origin_loop_ = true;
     }
   }
 
   GetConfigFunction get_config_func_;
   ObserverList<Observer> observers_;
   ProxyConfig last_config_;
   base::TimeTicks last_poll_time_;
   base::TimeDelta poll_interval_;
 
-  Lock lock_;
+  base::Lock lock_;
   scoped_refptr<base::MessageLoopProxy> origin_loop_proxy_;
 
   bool have_initialized_origin_loop_;
   bool has_config_;
   bool poll_task_outstanding_;
   bool poll_task_queued_;
 };
 
 PollingProxyConfigService::PollingProxyConfigService(
     base::TimeDelta poll_interval,
@@ skipping 19 matching lines @@
 
 void PollingProxyConfigService::OnLazyPoll() {
   core_->OnLazyPoll();
 }
 
 void PollingProxyConfigService::CheckForChangesNow() {
   core_->CheckForChangesNow();
 }
 
 }  // namespace net