[CacheStorage] Use a map of scoped_ptrs instead of raw pointers

content/browser/cache_storage/cache_storage_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 "content/browser/cache_storage/cache_storage_manager.h"
 
 #include <map>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 108 matching lines @@
   scoped_ptr<CacheStorageManager> manager(new CacheStorageManager(
       old_manager->root_path(), old_manager->cache_task_runner(),
       old_manager->quota_manager_proxy_.get()));
   // These values may be NULL, in which case this will be called again later by
   // the dispatcher host per usual.
   manager->SetBlobParametersForCache(old_manager->url_request_context_getter(),
                                      old_manager->blob_storage_context());
   return manager.Pass();
 }
 
-CacheStorageManager::~CacheStorageManager() {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  for (CacheStorageMap::iterator it = cache_storage_map_.begin();
-       it != cache_storage_map_.end(); ++it) {
-    delete it->second;
-  }
-}
+CacheStorageManager::~CacheStorageManager() = default;
 
 void CacheStorageManager::OpenCache(
     const GURL& origin,
     const std::string& cache_name,
     const CacheStorage::CacheAndErrorCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   CacheStorage* cache_storage = FindOrCreateCacheStorage(origin);
 
   cache_storage->OpenCache(cache_name, callback);
@@ skipping 141 matching lines @@
       cache_task_runner_.get(), FROM_HERE,
       base::Bind(&ListOriginsOnDisk, root_path_),
       base::Bind(&GetOriginsForHostDidListOrigins, host, callback));
 }
 
 void CacheStorageManager::DeleteOriginData(
     const GURL& origin,
     const storage::QuotaClient::DeletionCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  CacheStorage* cache_storage = FindOrCreateCacheStorage(origin);
+  CacheStorageMap::iterator it = cache_storage_map_.find(origin);
+  if (it == cache_storage_map_.end()) {
+    callback.Run(storage::kQuotaStatusOk);
+    return;
+  }
+
+  CacheStorage* cache_storage = it->second.release();
   cache_storage_map_.erase(origin);
   cache_storage->CloseAllCaches(
       base::Bind(&CacheStorageManager::DeleteOriginDidClose, origin, callback,
                  base::Passed(make_scoped_ptr(cache_storage)),
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void CacheStorageManager::DeleteOriginData(const GURL& origin) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DeleteOriginData(origin, base::Bind(&EmptyQuotaStatusCallback));
@@ skipping 46 matching lines @@
     const GURL& origin) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(request_context_getter_);
   CacheStorageMap::const_iterator it = cache_storage_map_.find(origin);
   if (it == cache_storage_map_.end()) {
     MigrateOrigin(origin);
     CacheStorage* cache_storage = new CacheStorage(
         ConstructOriginPath(root_path_, origin), IsMemoryBacked(),
         cache_task_runner_.get(), request_context_getter_, quota_manager_proxy_,
         blob_context_, origin);
-    // The map owns fetch_stores.
-    cache_storage_map_.insert(std::make_pair(origin, cache_storage));
+    cache_storage_map_.insert(
+        std::make_pair(origin, make_scoped_ptr(cache_storage)));
     return cache_storage;
   }
-  return it->second;
+  return it->second.get();
 }
 
 // static
 base::FilePath CacheStorageManager::ConstructLegacyOriginPath(
     const base::FilePath& root_path,
     const GURL& origin) {
   const std::string origin_hash = base::SHA1HashString(origin.spec());
   const std::string origin_hash_hex = base::ToLowerASCII(
       base::HexEncode(origin_hash.c_str(), origin_hash.length()));
   return root_path.AppendASCII(origin_hash_hex);
@@ skipping 26 matching lines @@
     const base::FilePath& old_path,
     const base::FilePath& new_path) {
   if (base::PathExists(old_path)) {
     if (!base::PathExists(new_path))
       base::Move(old_path, new_path);
     base::DeleteFile(old_path, /*recursive*/ true);
   }
 }
 
 }  // namespace content