content: Use stl utilities from the base namespace

content/browser/cache_storage/cache_storage.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 "content/browser/cache_storage/cache_storage.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <string>
@@ skipping 178 matching lines @@
   }
 
   void LoadIndex(std::unique_ptr<std::vector<std::string>> cache_names,
                  const StringVectorCallback& callback) override {
     callback.Run(std::move(cache_names));
   }
 
   void NotifyCacheCreated(
       const std::string& cache_name,
       std::unique_ptr<CacheStorageCacheHandle> cache_handle) override {
-    DCHECK(!ContainsKey(cache_handles_, cache_name));
+    DCHECK(!base::ContainsKey(cache_handles_, cache_name));
     cache_handles_.insert(std::make_pair(cache_name, std::move(cache_handle)));
   };
 
   void NotifyCacheDoomed(
       std::unique_ptr<CacheStorageCacheHandle> cache_handle) override {
-    DCHECK(ContainsKey(cache_handles_, cache_handle->value()->cache_name()));
+    DCHECK(
+        base::ContainsKey(cache_handles_, cache_handle->value()->cache_name()));
     cache_handles_.erase(cache_handle->value()->cache_name());
   };
 
  private:
   typedef std::map<std::string, std::unique_ptr<CacheStorageCacheHandle>>
       CacheHandles;
   ~MemoryLoader() override {}
 
   // Keep a reference to each cache to ensure that it's not freed before the
   // client calls CacheStorage::Delete or the CacheStorage is
@@ skipping 15 matching lines @@
                     quota_manager_proxy,
                     blob_context,
                     cache_storage,
                     origin),
         origin_path_(origin_path),
         weak_ptr_factory_(this) {}
 
   std::unique_ptr<CacheStorageCache> CreateCache(
       const std::string& cache_name) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
-    DCHECK(ContainsKey(cache_name_to_cache_dir_, cache_name));
+    DCHECK(base::ContainsKey(cache_name_to_cache_dir_, cache_name));
 
     std::string cache_dir = cache_name_to_cache_dir_[cache_name];
     base::FilePath cache_path = origin_path_.AppendASCII(cache_dir);
     return CacheStorageCache::CreatePersistentCache(
         origin_, cache_name, cache_storage_, cache_path,
         request_context_getter_, quota_manager_proxy_, blob_context_);
   }
 
   void PrepareNewCacheDestination(const std::string& cache_name,
                                   const CacheCallback& callback) override {
@@ skipping 27 matching lines @@
       callback.Run(std::unique_ptr<CacheStorageCache>());
       return;
     }
 
     cache_name_to_cache_dir_[cache_name] = cache_dir;
     callback.Run(CreateCache(cache_name));
   }
 
   void CleanUpDeletedCache(CacheStorageCache* cache) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
-    DCHECK(ContainsKey(doomed_cache_to_path_, cache));
+    DCHECK(base::ContainsKey(doomed_cache_to_path_, cache));
 
     base::FilePath cache_path =
         origin_path_.AppendASCII(doomed_cache_to_path_[cache]);
     doomed_cache_to_path_.erase(cache);
 
     cache_task_runner_->PostTask(
         FROM_HERE, base::Bind(&SimpleCacheLoader::CleanUpDeleteCacheDirInPool,
                               cache_path));
   }
 
   static void CleanUpDeleteCacheDirInPool(const base::FilePath& cache_path) {
     base::DeleteFile(cache_path, true /* recursive */);
   }
 
   void WriteIndex(const StringVector& cache_names,
                   const BoolCallback& callback) override {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     // 1. Create the index file as a string. (WriteIndex)
     // 2. Write the file to disk. (WriteIndexWriteToFileInPool)
 
     CacheStorageIndex index;
     index.set_origin(origin_.spec());
 
     for (size_t i = 0u, max = cache_names.size(); i < max; ++i) {
-      DCHECK(ContainsKey(cache_name_to_cache_dir_, cache_names[i]));
+      DCHECK(base::ContainsKey(cache_name_to_cache_dir_, cache_names[i]));
 
       CacheStorageIndex::Cache* index_cache = index.add_cache();
       index_cache->set_name(cache_names[i]);
       index_cache->set_cache_dir(cache_name_to_cache_dir_[cache_names[i]]);
     }
 
     std::string serialized;
     bool success = index.SerializeToString(&serialized);
     DCHECK(success);
 
@@ skipping 59 matching lines @@
     }
 
     cache_task_runner_->PostTask(
         FROM_HERE, base::Bind(&DeleteUnreferencedCachesInPool, origin_path_,
                               base::Passed(&cache_dirs)));
     callback.Run(std::move(names));
   }
 
   void NotifyCacheDoomed(
       std::unique_ptr<CacheStorageCacheHandle> cache_handle) override {
-    DCHECK(ContainsKey(cache_name_to_cache_dir_,
-                       cache_handle->value()->cache_name()));
+    DCHECK(base::ContainsKey(cache_name_to_cache_dir_,
+                             cache_handle->value()->cache_name()));
     auto iter =
         cache_name_to_cache_dir_.find(cache_handle->value()->cache_name());
     doomed_cache_to_path_[cache_handle->value()] = iter->second;
     cache_name_to_cache_dir_.erase(iter);
   };
 
  private:
   friend class MigratedLegacyCacheDirectoryNameTest;
   ~SimpleCacheLoader() override {}
 
   // Iterates over the caches and deletes any directory not found in
   // |cache_dirs|. Runs on cache_task_runner_
   static void DeleteUnreferencedCachesInPool(
       const base::FilePath& cache_base_dir,
       std::unique_ptr<std::set<std::string>> cache_dirs) {
     base::FileEnumerator file_enum(cache_base_dir, false /* recursive */,
                                    base::FileEnumerator::DIRECTORIES);
     std::vector<base::FilePath> dirs_to_delete;
     base::FilePath cache_path;
     while (!(cache_path = file_enum.Next()).empty()) {
-      if (!ContainsKey(*cache_dirs, cache_path.BaseName().AsUTF8Unsafe()))
+      if (!base::ContainsKey(*cache_dirs, cache_path.BaseName().AsUTF8Unsafe()))
         dirs_to_delete.push_back(cache_path);
     }
 
     for (const base::FilePath& cache_path : dirs_to_delete)
       base::DeleteFile(cache_path, true /* recursive */);
   }
 
   // Runs on cache_task_runner_
   static std::string MigrateCachesIfNecessaryInPool(
       const std::string& body,
@@ skipping 322 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(cache_handle);
 
   // TODO(jkarlin): Handle !success.
 
   callback.Run(std::move(cache_handle), CACHE_STORAGE_OK);
 }
 
 void CacheStorage::HasCacheImpl(const std::string& cache_name,
                                 const BoolAndErrorCallback& callback) {
-  bool has_cache = ContainsKey(cache_map_, cache_name);
+  bool has_cache = base::ContainsKey(cache_map_, cache_name);
   callback.Run(has_cache, CACHE_STORAGE_OK);
 }
 
 void CacheStorage::DeleteCacheImpl(const std::string& cache_name,
                                    const BoolAndErrorCallback& callback) {
   if (!GetLoadedCache(cache_name)) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, false, CACHE_STORAGE_ERROR_NOT_FOUND));
     return;
   }
@@ skipping 257 matching lines @@
     std::unique_ptr<CacheStorageCacheHandle> cache_handle =
         GetLoadedCache(cache_name);
     CacheStorageCache* cache = cache_handle->value();
     cache->Size(base::Bind(&SizeRetrievedFromCache,
                            base::Passed(std::move(cache_handle)),
                            barrier_closure, accumulator_ptr));
   }
 }
 
 }  // namespace content