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

chrome/browser/content_settings/host_content_settings_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 "chrome/browser/content_settings/host_content_settings_map.h"
 
 #include "base/command_line.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/browser_thread.h"
@@ skipping 207 matching lines @@
       switches::kEnableResourceContentSettings)) {
     DCHECK(!resource_identifier.empty());
   }
 
   // Host content settings are ignored if the default_content_setting is
   // managed.
   if (IsDefaultContentSettingManaged(content_type)) {
     return GetDefaultContentSetting(content_type);
   }
 
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
 
   const std::string host(net::GetHostOrSpecFromURL(url));
   ContentSettingsTypeResourceIdentifierPair
       requested_setting(content_type, resource_identifier);
 
   // Check for exact matches first.
   HostContentSettings::const_iterator i(host_content_settings_.find(host));
   if (i != host_content_settings_.end() &&
       i->second.content_settings_for_resources.find(requested_setting) !=
       i->second.content_settings_for_resources.end()) {
@@ skipping 61 matching lines @@
     }
   }
   return output;
 }
 
 ContentSettings HostContentSettingsMap::GetNonDefaultContentSettings(
     const GURL& url) const {
   if (ShouldAllowAllContent(url))
       return ContentSettings(CONTENT_SETTING_ALLOW);
 
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
 
   const std::string host(net::GetHostOrSpecFromURL(url));
   ContentSettings output;
   for (int j = 0; j < CONTENT_SETTINGS_NUM_TYPES; ++j)
     output.settings[j] = CONTENT_SETTING_DEFAULT;
 
   // Check for exact matches first.
   HostContentSettings::const_iterator i(host_content_settings_.find(host));
   if (i != host_content_settings_.end())
     output = i->second.content_settings;
@@ skipping 43 matching lines @@
   DCHECK(RequiresResourceIdentifier(content_type) !=
          resource_identifier.empty());
   DCHECK(settings);
   settings->clear();
 
   const HostContentSettings* map_to_return =
       is_off_the_record_ ? &off_the_record_settings_ : &host_content_settings_;
   ContentSettingsTypeResourceIdentifierPair
       requested_setting(content_type, resource_identifier);
 
-  AutoLock auto_lock(lock_);
+  base::AutoLock auto_lock(lock_);
   for (HostContentSettings::const_iterator i(map_to_return->begin());
        i != map_to_return->end(); ++i) {
     ContentSetting setting;
     if (RequiresResourceIdentifier(content_type)) {
       if (i->second.content_settings_for_resources.find(requested_setting) !=
           i->second.content_settings_for_resources.end())
         setting = i->second.content_settings_for_resources.find(
             requested_setting)->second;
       else
         setting = CONTENT_SETTING_DEFAULT;
@@ skipping 54 matching lines @@
   DictionaryValue* all_settings_dictionary = NULL;
   HostContentSettings* map_to_modify = &off_the_record_settings_;
   if (!is_off_the_record_) {
     prefs = profile_->GetPrefs();
     all_settings_dictionary =
       prefs->GetMutableDictionary(prefs::kContentSettingsPatterns);
     map_to_modify = &host_content_settings_;
   }
 
   {
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
     if (!map_to_modify->count(pattern_str))
       (*map_to_modify)[pattern_str].content_settings = ContentSettings();
     HostContentSettings::iterator
         i(map_to_modify->find(pattern_str));
     ContentSettings& settings = i->second.content_settings;
     if (RequiresResourceIdentifier(content_type)) {
       settings.settings[content_type] = CONTENT_SETTING_DEFAULT;
       if (setting != CONTENT_SETTING_DEFAULT) {
         i->second.content_settings_for_resources[
             ContentSettingsTypeResourceIdentifierPair(content_type,
@@ skipping 89 matching lines @@
   HostContentSettings* map_to_modify = &off_the_record_settings_;
 
   if (!is_off_the_record_) {
     prefs = profile_->GetPrefs();
     all_settings_dictionary =
       prefs->GetMutableDictionary(prefs::kContentSettingsPatterns);
     map_to_modify = &host_content_settings_;
   }
 
   {
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
     for (HostContentSettings::iterator i(map_to_modify->begin());
          i != map_to_modify->end(); ) {
       if (RequiresResourceIdentifier(content_type) ||
           i->second.content_settings.settings[content_type] !=
           CONTENT_SETTING_DEFAULT) {
         if (RequiresResourceIdentifier(content_type))
           i->second.content_settings_for_resources.clear();
         i->second.content_settings.settings[content_type] =
             CONTENT_SETTING_DEFAULT;
         std::string host(i->first);
@@ skipping 49 matching lines @@
 
   PrefService* prefs = profile_->GetPrefs();
   // If the preference block-third-party-cookies is managed then do not allow to
   // change it.
   if (prefs->IsManagedPreference(prefs::kBlockThirdPartyCookies)) {
     NOTREACHED();
     return;
   }
 
   {
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
     block_third_party_cookies_ = block;
   }
 
   if (block)
     prefs->SetBoolean(prefs::kBlockThirdPartyCookies, true);
   else
     prefs->ClearPref(prefs::kBlockThirdPartyCookies);
 }
 
 void HostContentSettingsMap::SetBlockNonsandboxedPlugins(bool block) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // This setting may not be directly modified for OTR sessions.  Instead, it
   // is synced to the main profile's setting.
   if (is_off_the_record_) {
     NOTREACHED();
     return;
   }
 
   {
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
     block_nonsandboxed_plugins_ = block;
   }
 
 
   PrefService* prefs = profile_->GetPrefs();
   if (block) {
     UserMetrics::RecordAction(
         UserMetricsAction("BlockNonsandboxedPlugins_Enable"));
     prefs->SetBoolean(prefs::kBlockNonsandboxedPlugins, true);
   } else {
     UserMetrics::RecordAction(
         UserMetricsAction("BlockNonsandboxedPlugins_Disable"));
     prefs->ClearPref(prefs::kBlockNonsandboxedPlugins);
   }
 }
 
 void HostContentSettingsMap::ResetToDefaults() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   {
-    AutoLock auto_lock(lock_);
+    base::AutoLock auto_lock(lock_);
     for (provider_iterator provider = content_settings_providers_.begin();
          provider != content_settings_providers_.end(); ++provider) {
       (*provider)->ResetToDefaults();
     }
     host_content_settings_.clear();
     off_the_record_settings_.clear();
     // Don't reset block third party cookies if they are managed.
     if (!IsBlockThirdPartyCookiesManaged())
       block_third_party_cookies_ = false;
     block_nonsandboxed_plugins_ = false;
@@ skipping 22 matching lines @@
 
   if (type == NotificationType::PREF_CHANGED) {
     DCHECK_EQ(profile_->GetPrefs(), Source<PrefService>(source).ptr());
     if (updating_preferences_)
       return;
 
     std::string* name = Details<std::string>(details).ptr();
     if (*name == prefs::kContentSettingsPatterns) {
       ReadExceptions(true);
     } else if (*name == prefs::kBlockThirdPartyCookies) {
-      AutoLock auto_lock(lock_);
+      base::AutoLock auto_lock(lock_);
       block_third_party_cookies_ = profile_->GetPrefs()->GetBoolean(
           prefs::kBlockThirdPartyCookies);
       is_block_third_party_cookies_managed_ =
           profile_->GetPrefs()->IsManagedPreference(
               prefs::kBlockThirdPartyCookies);
     } else if (*name == prefs::kBlockNonsandboxedPlugins) {
-      AutoLock auto_lock(lock_);
+      base::AutoLock auto_lock(lock_);
       block_nonsandboxed_plugins_ = profile_->GetPrefs()->GetBoolean(
           prefs::kBlockNonsandboxedPlugins);
     } else {
       NOTREACHED() << "Unexpected preference observed";
       return;
     }
 
     if (!is_off_the_record_) {
       NotifyObservers(ContentSettingsDetails(ContentSettingsPattern(),
                                              CONTENT_SETTINGS_TYPE_DEFAULT,
@@ skipping 83 matching lines @@
     ContentSettingsType content_type) const {
   for (const_provider_iterator provider = content_settings_providers_.begin();
        provider != content_settings_providers_.end(); ++provider) {
     if ((*provider)->DefaultSettingIsManaged(content_type))
       return true;
   }
   return false;
 }
 
 void HostContentSettingsMap::ReadExceptions(bool overwrite) {
-  AutoLock lock(lock_);
+  base::AutoLock lock(lock_);
 
   PrefService* prefs = profile_->GetPrefs();
   DictionaryValue* all_settings_dictionary =
       prefs->GetMutableDictionary(prefs::kContentSettingsPatterns);
 
   if (overwrite)
     host_content_settings_.clear();
 
   // Careful: The returned value could be NULL if the pref has never been set.
   if (all_settings_dictionary != NULL) {
@@ skipping 132 matching lines @@
   }
 
   for (size_t i = 0; i < move_items.size(); ++i) {
     Value* pattern_settings_dictionary = NULL;
     all_settings_dictionary->RemoveWithoutPathExpansion(
         move_items[i].first, &pattern_settings_dictionary);
     all_settings_dictionary->SetWithoutPathExpansion(
         move_items[i].second, pattern_settings_dictionary);
   }
 }