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

chrome/browser/host_zoom_map.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 <cmath>
 
 #include "chrome/browser/host_zoom_map.h"
 
 #include "base/string_piece.h"
 #include "base/utf_string_conversions.h"
@@ skipping 33 matching lines @@
 
   registrar_.Add(
       this, NotificationType::RENDER_VIEW_HOST_WILL_CLOSE_RENDER_VIEW,
       NotificationService::AllSources());
 }
 
 void HostZoomMap::Load() {
   if (!profile_)
     return;
 
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   host_zoom_levels_.clear();
   const DictionaryValue* host_zoom_dictionary =
       profile_->GetPrefs()->GetDictionary(prefs::kPerHostZoomLevels);
   // Careful: The returned value could be NULL if the pref has never been set.
   if (host_zoom_dictionary != NULL) {
     for (DictionaryValue::key_iterator i(host_zoom_dictionary->begin_keys());
          i != host_zoom_dictionary->end_keys(); ++i) {
       const std::string& host(*i);
       double zoom_level = 0;
 
@@ skipping 23 matching lines @@
   }
 }
 
 // static
 void HostZoomMap::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterDictionaryPref(prefs::kPerHostZoomLevels);
 }
 
 double HostZoomMap::GetZoomLevel(const GURL& url) const {
   std::string host(net::GetHostOrSpecFromURL(url));
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   HostZoomLevels::const_iterator i(host_zoom_levels_.find(host));
   return (i == host_zoom_levels_.end()) ? default_zoom_level_ : i->second;
 }
 
 void HostZoomMap::SetZoomLevel(const GURL& url, double level) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!profile_)
     return;
 
   std::string host(net::GetHostOrSpecFromURL(url));
 
   {
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
     if (level == default_zoom_level_)
       host_zoom_levels_.erase(host);
     else
       host_zoom_levels_[host] = level;
   }
 
   NotificationService::current()->Notify(NotificationType::ZOOM_LEVEL_CHANGED,
                                          Source<Profile>(profile_),
                                          NotificationService::NoDetails());
 
@@ skipping 12 matching lines @@
     } else {
       host_zoom_dictionary->SetWithoutPathExpansion(
           host, Value::CreateRealValue(level));
     }
   }
   updating_preferences_ = false;
 }
 
 double HostZoomMap::GetTemporaryZoomLevel(int render_process_id,
                                           int render_view_id) const {
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   for (size_t i = 0; i < temporary_zoom_levels_.size(); ++i) {
     if (temporary_zoom_levels_[i].render_process_id == render_process_id &&
         temporary_zoom_levels_[i].render_view_id == render_view_id) {
       return temporary_zoom_levels_[i].zoom_level;
     }
   }
   return 0;
 }
 
 void HostZoomMap::SetTemporaryZoomLevel(int render_process_id,
                                         int render_view_id,
                                         double level) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!profile_)
     return;
 
   {
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
     size_t i;
     for (i = 0; i < temporary_zoom_levels_.size(); ++i) {
       if (temporary_zoom_levels_[i].render_process_id == render_process_id &&
           temporary_zoom_levels_[i].render_view_id == render_view_id) {
         if (level) {
           temporary_zoom_levels_[i].zoom_level = level;
         } else {
           temporary_zoom_levels_.erase(temporary_zoom_levels_.begin() + i);
         }
         break;
@@ skipping 13 matching lines @@
                                          Source<Profile>(profile_),
                                          NotificationService::NoDetails());
 }
 
 void HostZoomMap::ResetToDefaults() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!profile_)
     return;
 
   {
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
     host_zoom_levels_.clear();
   }
 
   updating_preferences_ = true;
   profile_->GetPrefs()->ClearPref(prefs::kPerHostZoomLevels);
   updating_preferences_ = false;
 }
 
 void HostZoomMap::Shutdown() {
   if (!profile_)
@@ skipping 10 matching lines @@
     const NotificationSource& source,
     const NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   switch (type.value) {
     case NotificationType::PROFILE_DESTROYED:
       // If the profile is going away, we need to stop using it.
       Shutdown();
       break;
     case NotificationType::RENDER_VIEW_HOST_WILL_CLOSE_RENDER_VIEW: {
-      AutoLock auto_lock(lock_);
+      base::AutoLock auto_lock(lock_);
       int render_view_id = Source<RenderViewHost>(source)->routing_id();
       int render_process_id = Source<RenderViewHost>(source)->process()->id();
 
       for (size_t i = 0; i < temporary_zoom_levels_.size(); ++i) {
         if (temporary_zoom_levels_[i].render_process_id == render_process_id &&
             temporary_zoom_levels_[i].render_view_id == render_view_id) {
           temporary_zoom_levels_.erase(temporary_zoom_levels_.begin() + i);
           break;
         }
       }
@@ skipping 13 matching lines @@
       break;
     }
     default:
       NOTREACHED() << "Unexpected preference observed.";
   }
 }
 
 HostZoomMap::~HostZoomMap() {
   Shutdown();
 }