chrome: Use stl utilities from the base namespace

chrome/browser/media_galleries/media_file_system_registry.cc

 // Copyright (c) 2012 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/media_galleries/media_file_system_registry.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <vector>
@@ skipping 73 matching lines @@
 // back informs the caller.
 class RPHReferenceManager {
  public:
   // |no_references_callback| is called when the last WebContents reference
   // goes away. WebContents references are added through
   // ReferenceFromWebContents().
   explicit RPHReferenceManager(const base::Closure& no_references_callback);
   virtual ~RPHReferenceManager();
 
   // Remove all references, but don't call |no_references_callback|.
-  void Reset() { STLDeleteValues(&observer_map_); }
+  void Reset() { base::STLDeleteValues(&observer_map_); }
 
   // Returns true if there are no references;
   bool empty() const { return observer_map_.empty(); }
 
   // Adds a reference to the passed |contents|. Calling this multiple times with
   // the same |contents| is a no-op.
   void ReferenceFromWebContents(content::WebContents* contents);
 
  private:
   class RPHWebContentsObserver : public content::WebContentsObserver {
@@ skipping 49 matching lines @@
 }
 
 RPHReferenceManager::~RPHReferenceManager() {
   Reset();
 }
 
 void RPHReferenceManager::ReferenceFromWebContents(
     content::WebContents* contents) {
   RenderProcessHost* rph = contents->GetRenderProcessHost();
   RPHObserver* state = NULL;
-  if (!ContainsKey(observer_map_, rph)) {
+  if (!base::ContainsKey(observer_map_, rph)) {
     state = new RPHObserver(this, rph);
     observer_map_[rph] = state;
   } else {
     state = observer_map_[rph];
   }
 
   state->AddWebContentsObserver(contents);
 }
 
 RPHReferenceManager::RPHWebContentsObserver::RPHWebContentsObserver(
@@ skipping 16 matching lines @@
 }
 
 RPHReferenceManager::RPHObserver::RPHObserver(
     RPHReferenceManager* manager, RenderProcessHost* host)
     : manager_(manager),
       host_(host) {
   host->AddObserver(this);
 }
 
 RPHReferenceManager::RPHObserver::~RPHObserver() {
-  STLDeleteValues(&observed_web_contentses_);
+  base::STLDeleteValues(&observed_web_contentses_);
   if (host_)
     host_->RemoveObserver(this);
 }
 
 void RPHReferenceManager::RPHObserver::AddWebContentsObserver(
     WebContents* web_contents) {
-  if (ContainsKey(observed_web_contentses_, web_contents))
+  if (base::ContainsKey(observed_web_contentses_, web_contents))
     return;
 
   RPHWebContentsObserver* observer =
     new RPHWebContentsObserver(manager_, web_contents);
   observed_web_contentses_[web_contents] = observer;
 }
 
 void RPHReferenceManager::RPHObserver::RemoveWebContentsObserver(
     WebContents* web_contents) {
   WCObserverMap::iterator wco_iter =
@@ skipping 165 matching lines @@
     }
 
     for (std::set<MediaGalleryPrefId>::const_iterator pref_id_it =
              galleries.begin();
          pref_id_it != galleries.end();
          ++pref_id_it) {
       const MediaGalleryPrefId& pref_id = *pref_id_it;
       const MediaGalleryPrefInfo& gallery_info =
           galleries_info.find(pref_id)->second;
       const std::string& device_id = gallery_info.device_id;
-      if (!ContainsKey(*attached_devices, device_id))
+      if (!base::ContainsKey(*attached_devices, device_id))
         continue;
 
       PrefIdFsInfoMap::const_iterator existing_info =
           pref_id_map_.find(pref_id);
       if (existing_info != pref_id_map_.end()) {
         result.push_back(existing_info->second);
         continue;
       }
 
       base::FilePath path = gallery_info.AbsolutePath();
@@ skipping 34 matching lines @@
 
     // If rph_refs is empty then we're actually in the middle of shutdown, and
     // Filter...() lagging which can invoke this method interleaved in the
     // destruction callback sequence and re-populate pref_id_map_.
     if (!attached_device->empty() && !rph_refs_.empty()) {
       std::string fs_name = MediaFileSystemBackend::ConstructMountName(
           profile_path_, extension_id_, gallery.pref_id);
       base::FilePath path = gallery.AbsolutePath();
       const std::string& device_id = gallery.device_id;
 
-      if (ContainsKey(pref_id_map_, gallery.pref_id)) {
+      if (base::ContainsKey(pref_id_map_, gallery.pref_id)) {
         result = base::File::FILE_OK;
       } else if (MediaStorageUtil::CanCreateFileSystem(device_id, path) &&
                  file_system_context_->RegisterFileSystem(device_id, fs_name,
                                                           path)) {
         result = base::File::FILE_OK;
         pref_id_map_[gallery.pref_id] = MediaFileSystemInfo(
             gallery.GetGalleryDisplayName(),
             file_system_context_->GetRegisteredPath(fs_name),
             fs_name,
             gallery.pref_id,
@@ skipping 94 matching lines @@
   DCHECK_NE(kInvalidMediaGalleryPrefId, pref_id);
 
   Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext());
   MediaGalleriesPreferences* preferences = GetPreferences(profile);
   MediaGalleriesPrefInfoMap::const_iterator gallery =
       preferences->known_galleries().find(pref_id);
   MediaGalleryPrefIdSet permitted_galleries =
       preferences->GalleriesForExtension(*extension);
 
   if (gallery == preferences->known_galleries().end() ||
-      !ContainsKey(permitted_galleries, pref_id)) {
+      !base::ContainsKey(permitted_galleries, pref_id)) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(callback, base::File::FILE_ERROR_NOT_FOUND));
     return;
   }
 
   ExtensionGalleriesHost* extension_host =
       GetExtensionGalleryHost(profile, preferences, extension->id());
 
   // This must come before the GetMediaFileSystems call to make sure the
   // contents of the context is referenced before the filesystems are retrieved.
   extension_host->ReferenceFromWebContents(contents);
 
   extension_host->RegisterMediaFileSystem(gallery->second, callback);
 }
 
 MediaGalleriesPreferences* MediaFileSystemRegistry::GetPreferences(
     Profile* profile) {
   // Create an empty ExtensionHostMap for this profile on first initialization.
-  if (!ContainsKey(extension_hosts_map_, profile)) {
+  if (!base::ContainsKey(extension_hosts_map_, profile)) {
     extension_hosts_map_[profile] = ExtensionHostMap();
-    DCHECK(!ContainsKey(profile_subscription_map_, profile));
+    DCHECK(!base::ContainsKey(profile_subscription_map_, profile));
     profile_subscription_map_[profile] =
         ShutdownNotifierFactory::GetInstance()->Get(profile)->Subscribe(
             base::Bind(&MediaFileSystemRegistry::OnProfileShutdown,
                        base::Unretained(this), profile));
     media_galleries::UsageCount(media_galleries::PROFILES_WITH_USAGE);
   }
 
   return MediaGalleriesPreferencesFactory::GetForProfile(profile);
 }
 
@@ skipping 205 matching lines @@
   // even delete |extension_host_map| altogether. So do this in two loops to
   // avoid using an invalidated iterator or deleted map.
   std::vector<const extensions::Extension*> extensions;
   for (ExtensionHostMap::const_iterator it = extension_host_map.begin();
        it != extension_host_map.end();
        ++it) {
     extensions.push_back(
         extension_registry->enabled_extensions().GetByID(it->first));
   }
   for (size_t i = 0; i < extensions.size(); ++i) {
-    if (!ContainsKey(extension_hosts_map_, profile))
+    if (!base::ContainsKey(extension_hosts_map_, profile))
       break;
     ExtensionHostMap::const_iterator gallery_host_it =
         extension_host_map.find(extensions[i]->id());
     if (gallery_host_it == extension_host_map.end())
       continue;
     gallery_host_it->second->RevokeGalleryByPrefId(pref_id);
   }
 }
 
 ExtensionGalleriesHost* MediaFileSystemRegistry::GetExtensionGalleryHost(
@@ skipping 47 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   auto extension_hosts_it = extension_hosts_map_.find(profile);
   DCHECK(extension_hosts_it != extension_hosts_map_.end());
   extension_hosts_map_.erase(extension_hosts_it);
 
   auto profile_subscription_it = profile_subscription_map_.find(profile);
   DCHECK(profile_subscription_it != profile_subscription_map_.end());
   profile_subscription_map_.erase(profile_subscription_it);
 }