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

net/base/dnsrr_resolver.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/dnsrr_resolver.h"
 
 #if defined(OS_POSIX)
 #include <resolv.h>
 #endif
 
-#include "base/lock.h"
 #include "base/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "base/singleton.h"
 #include "base/stl_util-inl.h"
 #include "base/string_piece.h"
+#include "base/synchronization/lock.h"
 #include "base/task.h"
 #include "base/threading/worker_pool.h"
 #include "net/base/dns_reload_timer.h"
 #include "net/base/dns_util.h"
 #include "net/base/net_errors.h"
 
 // Life of a query:
 //
 // DnsRRResolver RRResolverJob RRResolverWorker       ...         Handle
 //      |                       (origin loop)    (worker loop)
@@ skipping 110 matching lines @@
 
     return base::WorkerPool::PostTask(
         FROM_HERE, NewRunnableMethod(this, &RRResolverWorker::Run),
         true /* task is slow */);
   }
 
   // Cancel is called from the origin loop when the DnsRRResolver is getting
   // deleted.
   void Cancel() {
     DCHECK_EQ(MessageLoop::current(), origin_loop_);
-    AutoLock locked(lock_);
+    base::AutoLock locked(lock_);
     canceled_ = true;
   }
 
  private:
 
 #if defined(OS_POSIX)
 
   void Run() {
     // Runs on a worker thread.
 
@@ skipping 106 matching lines @@
   }
 
   // DoReply runs on the origin thread.
   void DoReply() {
     DCHECK_EQ(MessageLoop::current(), origin_loop_);
     {
       // We lock here because the worker thread could still be in Finished,
       // after the PostTask, but before unlocking |lock_|. If we do not lock in
       // this case, we will end up deleting a locked Lock, which can lead to
       // memory leaks or worse errors.
-      AutoLock locked(lock_);
+      base::AutoLock locked(lock_);
       if (!canceled_)
         dnsrr_resolver_->HandleResult(name_, rrtype_, result_, response_);
     }
     delete this;
   }
 
   void Finish() {
     // Runs on the worker thread.
     // We assume that the origin loop outlives the DnsRRResolver. If the
     // DnsRRResolver is deleted, it will call Cancel on us. If it does so
     // before the Acquire, we'll delete ourselves and return. If it's trying to
     // do so concurrently, then it'll block on the lock and we'll call PostTask
     // while the DnsRRResolver (and therefore the MessageLoop) is still alive.
     // If it does so after this function, we assume that the MessageLoop will
     // process pending tasks. In which case we'll notice the |canceled_| flag
     // in DoReply.
 
     bool canceled;
     {
-      AutoLock locked(lock_);
+      base::AutoLock locked(lock_);
       canceled = canceled_;
       if (!canceled) {
         origin_loop_->PostTask(
             FROM_HERE, NewRunnableMethod(this, &RRResolverWorker::DoReply));
       }
     }
 
     if (canceled)
       delete this;
   }
 
   const std::string name_;
   const uint16 rrtype_;
   const uint16 flags_;
   MessageLoop* const origin_loop_;
   DnsRRResolver* const dnsrr_resolver_;
 
-  Lock lock_;
+  base::Lock lock_;
   bool canceled_;
 
   int result_;
   RRResponse response_;
 
   DISALLOW_COPY_AND_ASSIGN(RRResolverWorker);
 };
 
 
 // A Buffer is used for walking over a DNS packet.
@@ skipping 404 matching lines @@
   inflight_.erase(j);
 
   job->HandleResult(result, response);
   delete job;
 }
 
 }  // namespace net
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(net::RRResolverHandle);
 DISABLE_RUNNABLE_METHOD_REFCOUNT(net::RRResolverWorker);