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

chrome/browser/cert_store.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 "chrome/browser/cert_store.h"
 
 #include <algorithm>
 #include <functional>
 
 #include "base/stl_util-inl.h"
@@ skipping 28 matching lines @@
                  NotificationService::AllSources());
   registrar_.Add(this, NotificationType::RENDERER_PROCESS_CLOSED,
                  NotificationService::AllSources());
 }
 
 CertStore::~CertStore() {
 }
 
 int CertStore::StoreCert(net::X509Certificate* cert, int process_id) {
   DCHECK(cert);
-  AutoLock autoLock(cert_lock_);
+  base::AutoLock autoLock(cert_lock_);
 
   int cert_id;
 
   // Do we already know this cert?
   ReverseCertMap::iterator cert_iter = cert_to_id_.find(cert);
   if (cert_iter == cert_to_id_.end()) {
     cert_id = next_cert_id_++;
     // We use 0 as an invalid cert_id value.  In the unlikely event that
     // next_cert_id_ wraps around, we reset it to 1.
     if (next_cert_id_ == 0)
@@ skipping 19 matching lines @@
                    MatchSecond<int>(process_id)) ==
         cert_id_to_process_id_.upper_bound(cert_id)) {
     cert_id_to_process_id_.insert(std::make_pair(cert_id, process_id));
   }
 
   return cert_id;
 }
 
 bool CertStore::RetrieveCert(int cert_id,
                              scoped_refptr<net::X509Certificate>* cert) {
-  AutoLock autoLock(cert_lock_);
+  base::AutoLock autoLock(cert_lock_);
 
   CertMap::iterator iter = id_to_cert_.find(cert_id);
   if (iter == id_to_cert_.end())
     return false;
   if (cert)
     *cert = iter->second;
   return true;
 }
 
 void CertStore::RemoveCertInternal(int cert_id) {
   CertMap::iterator cert_iter = id_to_cert_.find(cert_id);
   DCHECK(cert_iter != id_to_cert_.end());
 
   ReverseCertMap::iterator id_iter = cert_to_id_.find(cert_iter->second);
   DCHECK(id_iter != cert_to_id_.end());
   cert_to_id_.erase(id_iter);
 
   cert_iter->second->Release();
   id_to_cert_.erase(cert_iter);
 }
 
 void CertStore::RemoveCertsForRenderProcesHost(int process_id) {
-  AutoLock autoLock(cert_lock_);
+  base::AutoLock autoLock(cert_lock_);
 
   // We iterate through all the cert ids for that process.
   IDMap::iterator ids_iter;
   for (ids_iter = process_id_to_cert_id_.lower_bound(process_id);
        ids_iter != process_id_to_cert_id_.upper_bound(process_id);) {
     int cert_id = ids_iter->second;
     // Remove this process from cert_id_to_process_id_.
     IDMap::iterator proc_iter =
         std::find_if(cert_id_to_process_id_.lower_bound(cert_id),
                      cert_id_to_process_id_.upper_bound(cert_id),
@@ skipping 14 matching lines @@
 
 void CertStore::Observe(NotificationType type,
                         const NotificationSource& source,
                         const NotificationDetails& details) {
   DCHECK(type == NotificationType::RENDERER_PROCESS_TERMINATED ||
          type == NotificationType::RENDERER_PROCESS_CLOSED);
   RenderProcessHost* rph = Source<RenderProcessHost>(source).ptr();
   DCHECK(rph);
   RemoveCertsForRenderProcesHost(rph->id());
 }