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

net/base/cert_verifier.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/cert_verifier.h"
 
 #include "base/compiler_specific.h"
-#include "base/lock.h"
 #include "base/message_loop.h"
 #include "base/stl_util-inl.h"
+#include "base/synchronization/lock.h"
 #include "base/threading/worker_pool.h"
 #include "net/base/net_errors.h"
 #include "net/base/x509_certificate.h"
 
 #if defined(USE_NSS)
 #include <private/pprthred.h>  // PR_DetachThread
 #endif
 
 namespace net {
 
@@ skipping 117 matching lines @@
 
     return base::WorkerPool::PostTask(
         FROM_HERE, NewRunnableMethod(this, &CertVerifierWorker::Run),
         true /* task is slow */);
   }
 
   // Cancel is called from the origin loop when the CertVerifier is getting
   // deleted.
   void Cancel() {
     DCHECK_EQ(MessageLoop::current(), origin_loop_);
-    AutoLock locked(lock_);
+    base::AutoLock locked(lock_);
     canceled_ = true;
   }
 
  private:
   void Run() {
     // Runs on a worker thread.
     error_ = cert_->Verify(hostname_, flags_, &verify_result_);
 #if defined(USE_NSS)
     // Detach the thread from NSPR.
     // Calling NSS functions attaches the thread to NSPR, which stores
     // the NSPR thread ID in thread-specific data.
     // The threads in our thread pool terminate after we have called
     // PR_Cleanup.  Unless we detach them from NSPR, net_unittests gets
     // segfaults on shutdown when the threads' thread-specific data
     // destructors run.
     PR_DetachThread();
 #endif
     Finish();
   }
 
   // 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_) {
         cert_verifier_->HandleResult(cert_, hostname_, flags_,
                                      error_, verify_result_);
       }
     }
     delete this;
   }
 
   void Finish() {
     // Runs on the worker thread.
     // We assume that the origin loop outlives the CertVerifier. If the
     // CertVerifier 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 CertVerifier (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, &CertVerifierWorker::DoReply));
       }
     }
 
     if (canceled)
       delete this;
   }
 
   scoped_refptr<X509Certificate> cert_;
   const std::string hostname_;
   const int flags_;
   MessageLoop* const origin_loop_;
   CertVerifier* const cert_verifier_;
 
   // lock_ protects canceled_.
-  Lock lock_;
+  base::Lock lock_;
 
   // If canceled_ is true,
   // * origin_loop_ cannot be accessed by the worker thread,
   // * cert_verifier_ cannot be accessed by any thread.
   bool canceled_;
 
   int error_;
   CertVerifyResult verify_result_;
 
   DISALLOW_COPY_AND_ASSIGN(CertVerifierWorker);
@@ skipping 243 matching lines @@
   cur_request_callback_ = NULL;
 
   // Call the user's original callback.
   callback->Run(result);
 }
 
 }  // namespace net
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(net::CertVerifierWorker);