chrome: Use stl utilities from the base namespace

chrome/browser/media_galleries/gallery_watch_manager.cc

 // Copyright 2014 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/gallery_watch_manager.h"
 
 #include <stddef.h>
 
 #include <tuple>
 
@@ skipping 91 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 }
 
 void GalleryWatchManager::FileWatchManager::AddFileWatch(
     const base::FilePath& path,
     const base::Callback<void(bool)>& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
   // This can occur if the GalleryWatchManager attempts to watch the same path
   // again before recieving the callback. It's benign.
-  if (ContainsKey(watchers_, path)) {
+  if (base::ContainsKey(watchers_, path)) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE, base::Bind(callback, false));
     return;
   }
 
   linked_ptr<base::FilePathWatcher> watcher(new base::FilePathWatcher);
   bool success = watcher->Watch(path,
                                 true /*recursive*/,
                                 base::Bind(&FileWatchManager::OnFilePathChanged,
                                            weak_factory_.GetWeakPtr()));
@@ skipping 66 matching lines @@
   }
 
   BrowserThread::DeleteSoon(
       BrowserThread::FILE, FROM_HERE, watch_manager_.release());
 }
 
 void GalleryWatchManager::AddObserver(BrowserContext* browser_context,
                                       GalleryWatchManagerObserver* observer) {
   DCHECK(browser_context);
   DCHECK(observer);
-  DCHECK(!ContainsKey(observers_, browser_context));
+  DCHECK(!base::ContainsKey(observers_, browser_context));
   observers_[browser_context] = observer;
 }
 
 void GalleryWatchManager::RemoveObserver(BrowserContext* browser_context) {
   DCHECK(browser_context);
   size_t erased = observers_.erase(browser_context);
   DCHECK_EQ(erased, 1u);
 }
 
 void GalleryWatchManager::ShutdownBrowserContext(
@@ skipping 24 matching lines @@
 
 void GalleryWatchManager::AddWatch(BrowserContext* browser_context,
                                    const extensions::Extension* extension,
                                    MediaGalleryPrefId gallery_id,
                                    const ResultCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(browser_context);
   DCHECK(extension);
 
   WatchOwner owner(browser_context, extension->id(), gallery_id);
-  if (ContainsKey(watches_, owner)) {
+  if (base::ContainsKey(watches_, owner)) {
     callback.Run(std::string());
     return;
   }
 
   MediaGalleriesPreferences* preferences =
       g_browser_process->media_file_system_registry()->GetPreferences(
           Profile::FromBrowserContext(browser_context));
 
-  if (!ContainsKey(preferences->known_galleries(), gallery_id)) {
+  if (!base::ContainsKey(preferences->known_galleries(), gallery_id)) {
     callback.Run(kInvalidGalleryIDError);
     return;
   }
 
   MediaGalleryPrefIdSet permitted =
       preferences->GalleriesForExtension(*extension);
-  if (!ContainsKey(permitted, gallery_id)) {
+  if (!base::ContainsKey(permitted, gallery_id)) {
     callback.Run(kNoPermissionError);
     return;
   }
 
   base::FilePath path =
       preferences->known_galleries().find(gallery_id)->second.AbsolutePath();
 
   if (!storage_monitor_observed_) {
     storage_monitor_observed_ = true;
     storage_monitor::StorageMonitor::GetInstance()->AddObserver(this);
   }
 
   // Observe the preferences if we haven't already.
-  if (!ContainsKey(observed_preferences_, preferences)) {
+  if (!base::ContainsKey(observed_preferences_, preferences)) {
     observed_preferences_.insert(preferences);
     preferences->AddGalleryChangeObserver(this);
   }
 
   watches_[owner] = path;
   EnsureBrowserContextSubscription(owner.browser_context);
 
   // Start the FilePathWatcher on |gallery_path| if necessary.
-  if (ContainsKey(watched_paths_, path)) {
+  if (base::ContainsKey(watched_paths_, path)) {
     OnFileWatchActivated(owner, path, callback, true);
   } else {
     base::Callback<void(bool)> on_watch_added =
         base::Bind(&GalleryWatchManager::OnFileWatchActivated,
                    weak_factory_.GetWeakPtr(),
                    owner,
                    path,
                    callback);
     BrowserThread::PostTask(BrowserThread::FILE,
                             FROM_HERE,
@@ skipping 104 matching lines @@
 
   // On error, all watches on that path are dropped, so update records and
   // notify observers.
   if (error) {
     // Make a copy, as |watched_paths_| is modified as we erase watches.
     std::set<WatchOwner> owners = notification_info->second.owners;
     for (std::set<WatchOwner>::iterator it = owners.begin(); it != owners.end();
          ++it) {
       Profile* profile = Profile::FromBrowserContext(it->browser_context);
       RemoveWatch(it->browser_context, it->extension_id, it->gallery_id);
-      if (ContainsKey(observers_, profile))
+      if (base::ContainsKey(observers_, profile))
         observers_[profile]->OnGalleryWatchDropped(it->extension_id,
                                                    it->gallery_id);
     }
 
     return;
   }
 
   base::TimeDelta time_since_last_notify =
       base::Time::Now() - notification_info->second.last_notify_time;
   if (time_since_last_notify <
@@ skipping 15 matching lines @@
     }
     return;
   }
   notification_info->second.delayed_notification_pending = false;
   notification_info->second.last_notify_time = base::Time::Now();
 
   std::set<WatchOwner>::const_iterator it;
   for (it = notification_info->second.owners.begin();
        it != notification_info->second.owners.end();
        ++it) {
-    DCHECK(ContainsKey(watches_, *it));
-    if (ContainsKey(observers_, it->browser_context)) {
+    DCHECK(base::ContainsKey(watches_, *it));
+    if (base::ContainsKey(observers_, it->browser_context)) {
       observers_[it->browser_context]->OnGalleryChanged(it->extension_id,
                                                         it->gallery_id);
     }
   }
 }
 
 void GalleryWatchManager::OnPermissionRemoved(MediaGalleriesPreferences* pref,
                                               const std::string& extension_id,
                                               MediaGalleryPrefId pref_id) {
   RemoveWatch(pref->profile(), extension_id, pref_id);
-  if (ContainsKey(observers_, pref->profile()))
+  if (base::ContainsKey(observers_, pref->profile()))
     observers_[pref->profile()]->OnGalleryWatchDropped(extension_id, pref_id);
 }
 
 void GalleryWatchManager::OnGalleryRemoved(MediaGalleriesPreferences* pref,
                                            MediaGalleryPrefId pref_id) {
   // Removing a watch may update |watches_|, so extract the extension ids first.
   std::set<std::string> extension_ids;
   for (WatchesMap::const_iterator it = watches_.begin(); it != watches_.end();
        ++it) {
     if (it->first.browser_context == pref->profile() &&
         it->first.gallery_id == pref_id) {
       extension_ids.insert(it->first.extension_id);
     }
   }
 
   for (std::set<std::string>::const_iterator it = extension_ids.begin();
        it != extension_ids.end();
        ++it) {
     RemoveWatch(pref->profile(), *it, pref_id);
-    if (ContainsKey(observers_, pref->profile()))
+    if (base::ContainsKey(observers_, pref->profile()))
       observers_[pref->profile()]->OnGalleryWatchDropped(*it, pref_id);
   }
 }
 
 void GalleryWatchManager::OnRemovableStorageDetached(
     const storage_monitor::StorageInfo& info) {
   WatchesMap::iterator it = watches_.begin();
   while (it != watches_.end()) {
     MediaGalleriesPreferences* preferences =
         g_browser_process->media_file_system_registry()->GetPreferences(
             Profile::FromBrowserContext(it->first.browser_context));
     MediaGalleryPrefIdSet detached_ids =
         preferences->LookUpGalleriesByDeviceId(info.device_id());
 
-    if (ContainsKey(detached_ids, it->first.gallery_id)) {
+    if (base::ContainsKey(detached_ids, it->first.gallery_id)) {
       WatchOwner owner = it->first;
       DeactivateFileWatch(owner, it->second);
       // Post increment moves iterator to next element while deleting current.
       watches_.erase(it++);
       observers_[preferences->profile()]->OnGalleryWatchDropped(
           owner.extension_id, owner.gallery_id);
     } else {
       ++it;
     }
   }
 }