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

net/base/host_resolver_impl.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/base/host_resolver_impl.h"
 
 #if defined(OS_WIN)
 #include <Winsock2.h>
 #elif defined(OS_POSIX)
 #include <netdb.h>
 #endif
 
 #include <cmath>
 #include <deque>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/debug/debugger.h"
 #include "base/debug/stack_trace.h"
-#include "base/lock.h"
 #include "base/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
+#include "base/synchronization/lock.h"
 #include "base/threading/worker_pool.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "net/base/address_list.h"
 #include "net/base/address_list_net_log_param.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/host_resolver_proc.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
@@ skipping 361 matching lines @@
   // Cancels the current job. Callable from origin thread.
   void Cancel() {
     net_log_.AddEvent(NetLog::TYPE_CANCELLED, NULL);
 
     HostResolver* resolver = resolver_;
     resolver_ = NULL;
 
     // Mark the job as cancelled, so when worker thread completes it will
     // not try to post completion to origin loop.
     {
-      AutoLock locked(origin_loop_lock_);
+      base::AutoLock locked(origin_loop_lock_);
       origin_loop_ = NULL;
     }
 
     // End here to prevent issues when a Job outlives the HostResolver that
     // spawned it.
     net_log_.EndEvent(NetLog::TYPE_HOST_RESOLVER_IMPL_JOB, NULL);
 
     // We will call HostResolverImpl::CancelRequest(Request*) on each one
     // in order to notify any observers.
     for (RequestsList::const_iterator it = requests_.begin();
@@ skipping 56 matching lines @@
     error_ = ResolveAddrInfo(resolver_proc_,
                              key_.hostname,
                              key_.address_family,
                              key_.host_resolver_flags,
                              &results_,
                              &os_error_);
 
     // The origin loop could go away while we are trying to post to it, so we
     // need to call its PostTask method inside a lock.  See ~HostResolver.
     {
-      AutoLock locked(origin_loop_lock_);
+      base::AutoLock locked(origin_loop_lock_);
       if (origin_loop_) {
         origin_loop_->PostTask(FROM_HERE,
                                NewRunnableMethod(this, &Job::OnLookupComplete));
       }
     }
   }
 
   // Callback for when DoLookup() completes (runs on origin thread).
   void OnLookupComplete() {
     // Should be running on origin loop.
@@ skipping 100 matching lines @@
   const int id_;
 
   // Set on the origin thread, read on the worker thread.
   Key key_;
 
   // Only used on the origin thread (where Resolve was called).
   HostResolverImpl* resolver_;
   RequestsList requests_;  // The requests waiting on this job.
 
   // Used to post ourselves onto the origin thread.
-  Lock origin_loop_lock_;
+  base::Lock origin_loop_lock_;
   MessageLoop* origin_loop_;
 
   // Hold an owning reference to the HostResolverProc that we are going to use.
   // This may not be the current resolver procedure by the time we call
   // ResolveAddrInfo, but that's OK... we'll use it anyways, and the owning
   // reference ensures that it remains valid until we are done.
   scoped_refptr<HostResolverProc> resolver_proc_;
 
   // Assigned on the worker thread, read on the origin thread.
   int error_;
@@ skipping 37 matching lines @@
         FROM_HERE, NewRunnableMethod(this, &IPv6ProbeJob::DoProbe), kIsSlow);
   }
 
   // Cancels the current job.
   void Cancel() {
     if (was_cancelled())
       return;
     DCHECK(IsOnOriginThread());
     resolver_ = NULL;  // Read/write ONLY on origin thread.
     {
-      AutoLock locked(origin_loop_lock_);
+      base::AutoLock locked(origin_loop_lock_);
       // Origin loop may be destroyed before we can use it!
       origin_loop_ = NULL;  // Write ONLY on origin thread.
     }
   }
 
  private:
   friend class base::RefCountedThreadSafe<HostResolverImpl::IPv6ProbeJob>;
 
   ~IPv6ProbeJob() {
   }
@@ skipping 13 matching lines @@
     // Do actual testing on this thread, as it takes 40-100ms.
     AddressFamily family = IPv6Supported() ? ADDRESS_FAMILY_UNSPECIFIED
                                            : ADDRESS_FAMILY_IPV4;
 
     Task* reply = NewRunnableMethod(this, &IPv6ProbeJob::OnProbeComplete,
                                     family);
 
     // The origin loop could go away while we are trying to post to it, so we
     // need to call its PostTask method inside a lock.  See ~HostResolver.
     {
-      AutoLock locked(origin_loop_lock_);
+      base::AutoLock locked(origin_loop_lock_);
       if (origin_loop_) {
         origin_loop_->PostTask(FROM_HERE, reply);
         return;
       }
     }
 
     // We didn't post, so delete the reply.
     delete reply;
   }
 
   // Callback for when DoProbe() completes (runs on origin thread).
   void OnProbeComplete(AddressFamily address_family) {
     if (was_cancelled())
       return;
     DCHECK(IsOnOriginThread());
     resolver_->IPv6ProbeSetDefaultAddressFamily(address_family);
   }
 
   bool IsOnOriginThread() const {
     return !MessageLoop::current() || origin_loop_ == MessageLoop::current();
   }
 
   // Used/set only on origin thread.
   HostResolverImpl* resolver_;
 
   // Used to post ourselves onto the origin thread.
-  Lock origin_loop_lock_;
+  base::Lock origin_loop_lock_;
   MessageLoop* origin_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(IPv6ProbeJob);
 };
 
 //-----------------------------------------------------------------------------
 
 // We rely on the priority enum values being sequential having starting at 0,
 // and increasing for lower priorities.
 COMPILE_ASSERT(HIGHEST == 0u &&
@@ skipping 716 matching lines @@
     job_pools_[i]->ResetNumOutstandingJobs();
   JobMap jobs;
   jobs.swap(jobs_);
   for (JobMap::iterator it = jobs.begin(); it != jobs.end(); ++it) {
     AbortJob(it->second);
     it->second->Cancel();
   }
 }
 
 }  // namespace net