[CacheStorage] Use URLRequestContextGetter instead of URLRequestContext

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 81 matching lines @@
 }
 
 // static
 scoped_ptr<CacheStorageManager> CacheStorageManager::Create(
     CacheStorageManager* old_manager) {
   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(),
+  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;
   }
@@ skipping 53 matching lines @@
 void CacheStorageManager::MatchAllCaches(
     const GURL& origin,
     scoped_ptr<ServiceWorkerFetchRequest> request,
     const CacheStorageCache::ResponseCallback& callback) {
   CacheStorage* cache_storage = FindOrCreateCacheStorage(origin);
 
   cache_storage->MatchAllCaches(request.Pass(), callback);
 }
 
 void CacheStorageManager::SetBlobParametersForCache(
-    net::URLRequestContext* request_context,
+    const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
     base::WeakPtr<storage::BlobStorageContext> blob_storage_context) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(cache_storage_map_.empty());
-  DCHECK(!request_context_ || request_context_ == request_context);
+  DCHECK(!request_context_getter_ ||
+         request_context_getter_.get() == request_context_getter.get());
   DCHECK(!blob_context_ || blob_context_.get() == blob_storage_context.get());
-  request_context_ = request_context;
+  request_context_getter_ = request_context_getter;
   blob_context_ = blob_storage_context;
 }
 
 void CacheStorageManager::GetOriginUsage(
     const GURL& origin_url,
     const storage::QuotaClient::GetUsageCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (IsMemoryBacked()) {
     int64 sum = 0;
@@ skipping 92 matching lines @@
       base::Bind(&DeleteOriginDidDeleteDir, callback));
 }
 
 CacheStorageManager::CacheStorageManager(
     const base::FilePath& path,
     const scoped_refptr<base::SequencedTaskRunner>& cache_task_runner,
     const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy)
     : root_path_(path),
       cache_task_runner_(cache_task_runner),
       quota_manager_proxy_(quota_manager_proxy),
-      request_context_(NULL),
       weak_ptr_factory_(this) {
   if (quota_manager_proxy_.get()) {
     quota_manager_proxy_->RegisterClient(
         new CacheStorageQuotaClient(weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 CacheStorage* CacheStorageManager::FindOrCreateCacheStorage(
     const GURL& origin) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(request_context_);
+  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_, quota_manager_proxy_,
+        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));
     return cache_storage;
   }
   return it->second;
 }
 
 // static
 base::FilePath CacheStorageManager::ConstructLegacyOriginPath(
@@ skipping 32 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