[CacheStorage] Use URLRequestContextGetter instead of URLRequestContext

The CacheStorage classes shouldn't store raw pointers to
URLRequestContext. Use the getter class instead. This is part of a
cleanup to ensure that URLRequests are canceled before
URLRequestContext is deleted.

BUG=498563

Review URL: https://codereview.chromium.org/1174943004

Cr-Commit-Position: refs/heads/master@{#333783}

content/browser/cache_storage/cache_storage.cc

@@ -24,6 +24,7 @@
 #include "content/public/browser/browser_thread.h"
 #include "net/base/directory_lister.h"
 #include "net/base/net_errors.h"
+#include "net/url_request/url_request_context_getter.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
 
@@ -52,12 +53,12 @@ class CacheStorage::CacheLoader {
 
   CacheLoader(
       base::SequencedTaskRunner* cache_task_runner,
-      net::URLRequestContext* request_context,
+      const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
       const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context,
       const GURL& origin)
       : cache_task_runner_(cache_task_runner),
-        request_context_(request_context),
+        request_context_getter_(request_context_getter),
         quota_manager_proxy_(quota_manager_proxy),
         blob_context_(blob_context),
         origin_(origin) {
@@ -90,7 +91,7 @@ class CacheStorage::CacheLoader {
 
  protected:
   scoped_refptr<base::SequencedTaskRunner> cache_task_runner_;
-  net::URLRequestContext* request_context_;
+  scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
   scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy_;
   base::WeakPtr<storage::BlobStorageContext> blob_context_;
   GURL origin_;
@@ -104,7 +105,7 @@ class CacheStorage::MemoryLoader : public CacheStorage::CacheLoader {
  public:
   MemoryLoader(
       base::SequencedTaskRunner* cache_task_runner,
-      net::URLRequestContext* request_context,
+      const scoped_refptr<net::URLRequestContextGetter>& request_context,
       const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context,
       const GURL& origin)
@@ -117,7 +118,7 @@ class CacheStorage::MemoryLoader : public CacheStorage::CacheLoader {
   scoped_refptr<CacheStorageCache> CreateCache(
       const std::string& cache_name) override {
     return CacheStorageCache::CreateMemoryCache(
-        origin_, request_context_, quota_manager_proxy_, blob_context_);
+        origin_, request_context_getter_, quota_manager_proxy_, blob_context_);
   }
 
   void CreateCache(const std::string& cache_name,
@@ -160,7 +161,7 @@ class CacheStorage::SimpleCacheLoader : public CacheStorage::CacheLoader {
   SimpleCacheLoader(
       const base::FilePath& origin_path,
       base::SequencedTaskRunner* cache_task_runner,
-      net::URLRequestContext* request_context,
+      const scoped_refptr<net::URLRequestContextGetter>& request_context,
       const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context,
       const GURL& origin)
@@ -178,7 +179,7 @@ class CacheStorage::SimpleCacheLoader : public CacheStorage::CacheLoader {
 
     return CacheStorageCache::CreatePersistentCache(
         origin_, CreatePersistentCachePath(origin_path_, cache_name),
-        request_context_, quota_manager_proxy_, blob_context_);
+        request_context_getter_, quota_manager_proxy_, blob_context_);
   }
 
   void CreateCache(const std::string& cache_name,
@@ -357,7 +358,7 @@ CacheStorage::CacheStorage(
     const base::FilePath& path,
     bool memory_only,
     base::SequencedTaskRunner* cache_task_runner,
-    net::URLRequestContext* request_context,
+    const scoped_refptr<net::URLRequestContextGetter>& request_context,
     const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
     base::WeakPtr<storage::BlobStorageContext> blob_context,
     const GURL& origin)

content/browser/cache_storage/cache_storage.h

@@ -10,6 +10,7 @@
 
 #include "base/callback.h"
 #include "base/files/file_path.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "content/browser/cache_storage/cache_storage_cache.h"
 
@@ -18,7 +19,7 @@ class SequencedTaskRunner;
 }
 
 namespace net {
-class URLRequestContext;
+class URLRequestContextGetter;
 }
 
 namespace storage {
@@ -48,7 +49,7 @@ class CONTENT_EXPORT CacheStorage {
       const base::FilePath& origin_path,
       bool memory_only,
       base::SequencedTaskRunner* cache_task_runner,
-      net::URLRequestContext* request_context,
+      const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
       const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context,
       const GURL& origin);

content/browser/cache_storage/cache_storage_cache.cc

@@ -19,7 +19,7 @@
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
-#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/blob/blob_storage_context.h"
@@ -178,15 +178,20 @@ class CacheStorageCache::BlobReader : public net::URLRequest::Delegate {
         weak_ptr_factory_(this) {}
 
   // |entry| is passed to the callback once complete.
-  void StreamBlobToCache(disk_cache::ScopedEntryPtr entry,
-                         net::URLRequestContext* request_context,
-                         scoped_ptr<storage::BlobDataHandle> blob_data_handle,
-                         const EntryAndBoolCallback& callback) {
+  void StreamBlobToCache(
+      disk_cache::ScopedEntryPtr entry,
+      const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
+      scoped_ptr<storage::BlobDataHandle> blob_data_handle,
+      const EntryAndBoolCallback& callback) {
     DCHECK(entry);
+    DCHECK(request_context_getter->GetURLRequestContext());
+
     entry_ = entry.Pass();
     callback_ = callback;
+
     blob_request_ = storage::BlobProtocolHandler::CreateBlobRequest(
-        blob_data_handle.Pass(), request_context, this);
+        blob_data_handle.Pass(), request_context_getter->GetURLRequestContext(),
+        this);
     blob_request_->Start();
   }
 
@@ -341,14 +346,14 @@ struct CacheStorageCache::PutContext {
       scoped_ptr<ServiceWorkerResponse> response,
       scoped_ptr<storage::BlobDataHandle> blob_data_handle,
       const CacheStorageCache::ErrorCallback& callback,
-      net::URLRequestContext* request_context,
+      const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
       const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy)
       : origin(origin),
         request(request.Pass()),
         response(response.Pass()),
         blob_data_handle(blob_data_handle.Pass()),
         callback(callback),
-        request_context(request_context),
+        request_context_getter(request_context_getter),
         quota_manager_proxy(quota_manager_proxy),
         cache_entry(NULL) {}
   ~PutContext() {
@@ -362,7 +367,7 @@ struct CacheStorageCache::PutContext {
   scoped_ptr<ServiceWorkerResponse> response;
   scoped_ptr<storage::BlobDataHandle> blob_data_handle;
   CacheStorageCache::ErrorCallback callback;
-  net::URLRequestContext* request_context;
+  scoped_refptr<net::URLRequestContextGetter> request_context_getter;
   scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy;
 
   // This isn't a scoped_ptr because the disk_cache needs an Entry** as input to
@@ -375,11 +380,11 @@ struct CacheStorageCache::PutContext {
 // static
 scoped_refptr<CacheStorageCache> CacheStorageCache::CreateMemoryCache(
     const GURL& origin,
-    net::URLRequestContext* request_context,
+    const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
     const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
     base::WeakPtr<storage::BlobStorageContext> blob_context) {
   return make_scoped_refptr(
-      new CacheStorageCache(origin, base::FilePath(), request_context,
+      new CacheStorageCache(origin, base::FilePath(), request_context_getter,
                             quota_manager_proxy, blob_context));
 }
 
@@ -387,11 +392,11 @@ scoped_refptr<CacheStorageCache> CacheStorageCache::CreateMemoryCache(
 scoped_refptr<CacheStorageCache> CacheStorageCache::CreatePersistentCache(
     const GURL& origin,
     const base::FilePath& path,
-    net::URLRequestContext* request_context,
+    const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
     const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
     base::WeakPtr<storage::BlobStorageContext> blob_context) {
   return make_scoped_refptr(new CacheStorageCache(
-      origin, path, request_context, quota_manager_proxy, blob_context));
+      origin, path, request_context_getter, quota_manager_proxy, blob_context));
 }
 
 CacheStorageCache::~CacheStorageCache() {
@@ -554,12 +559,12 @@ int64 CacheStorageCache::MemoryBackedSize() const {
 CacheStorageCache::CacheStorageCache(
     const GURL& origin,
     const base::FilePath& path,
-    net::URLRequestContext* request_context,
+    const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
     const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
     base::WeakPtr<storage::BlobStorageContext> blob_context)
     : origin_(origin),
       path_(path),
-      request_context_(request_context),
+      request_context_getter_(request_context_getter),
       quota_manager_proxy_(quota_manager_proxy),
       blob_storage_context_(blob_context),
       backend_state_(BACKEND_UNINITIALIZED),
@@ -794,7 +799,7 @@ void CacheStorageCache::Put(const CacheStorageBatchOperation& operation,
 
   scoped_ptr<PutContext> put_context(new PutContext(
       origin_, request.Pass(), response.Pass(), blob_data_handle.Pass(),
-      pending_callback, request_context_, quota_manager_proxy_));
+      pending_callback, request_context_getter_, quota_manager_proxy_));
 
   scheduler_->ScheduleOperation(base::Bind(&CacheStorageCache::PutImpl,
                                            weak_ptr_factory_.GetWeakPtr(),
@@ -932,12 +937,13 @@ void CacheStorageCache::PutDidWriteHeaders(scoped_ptr<PutContext> put_context,
   BlobReader* reader_ptr = reader.get();
 
   // Grab some pointers before passing put_context in Bind.
-  net::URLRequestContext* request_context = put_context->request_context;
+  scoped_refptr<net::URLRequestContextGetter> request_context_getter =
+      put_context->request_context_getter;
   scoped_ptr<storage::BlobDataHandle> blob_data_handle =
       put_context->blob_data_handle.Pass();
 
   reader_ptr->StreamBlobToCache(
-      entry.Pass(), request_context, blob_data_handle.Pass(),
+      entry.Pass(), request_context_getter, blob_data_handle.Pass(),
       base::Bind(&CacheStorageCache::PutDidWriteBlobToCache,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(put_context.Pass()),

content/browser/cache_storage/cache_storage_cache.h

@@ -16,7 +16,7 @@
 #include "net/disk_cache/disk_cache.h"
 
 namespace net {
-class URLRequestContext;
+class URLRequestContextGetter;
 class IOBufferWithSize;
 }
 
@@ -50,13 +50,13 @@ class CONTENT_EXPORT CacheStorageCache
 
   static scoped_refptr<CacheStorageCache> CreateMemoryCache(
       const GURL& origin,
-      net::URLRequestContext* request_context,
+      const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
       const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context);
   static scoped_refptr<CacheStorageCache> CreatePersistentCache(
       const GURL& origin,
       const base::FilePath& path,
-      net::URLRequestContext* request_context,
+      const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
       const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context);
 
@@ -121,7 +121,7 @@ class CONTENT_EXPORT CacheStorageCache
   CacheStorageCache(
       const GURL& origin,
       const base::FilePath& path,
-      net::URLRequestContext* request_context,
+      const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
       const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context);
 
@@ -206,7 +206,7 @@ class CONTENT_EXPORT CacheStorageCache
 
   GURL origin_;
   base::FilePath path_;
-  net::URLRequestContext* request_context_;
+  scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
   scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy_;
   base::WeakPtr<storage::BlobStorageContext> blob_storage_context_;
   BackendState backend_state_;

content/browser/cache_storage/cache_storage_cache_unittest.cc

@@ -6,6 +6,7 @@
 
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
+#include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/strings/string_split.h"
 #include "base/thread_task_runner_handle.h"
@@ -128,12 +129,12 @@ class TestCacheStorageCache : public CacheStorageCache {
   TestCacheStorageCache(
       const GURL& origin,
       const base::FilePath& path,
-      net::URLRequestContext* request_context,
+      const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
       const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
       base::WeakPtr<storage::BlobStorageContext> blob_context)
       : CacheStorageCache(origin,
                           path,
-                          request_context,
+                          request_context_getter,
                           quota_manager_proxy,
                           blob_context),
         delay_backend_creation_(false) {}
@@ -204,7 +205,7 @@ class CacheStorageCacheTest : public testing::Test {
     base::FilePath path = MemoryOnly() ? base::FilePath() : temp_dir_.path();
 
     cache_ = make_scoped_refptr(new TestCacheStorageCache(
-        GURL("http://example.com"), path, url_request_context,
+        GURL("http://example.com"), path, browser_context_.GetRequestContext(),
         quota_manager_proxy_, blob_storage_context->context()->AsWeakPtr()));
   }
 

content/browser/cache_storage/cache_storage_context_impl.cc

@@ -71,14 +71,13 @@ CacheStorageManager* CacheStorageContextImpl::cache_manager() const {
 }
 
 void CacheStorageContextImpl::SetBlobParametersForCache(
-    net::URLRequestContextGetter* request_context,
+    net::URLRequestContextGetter* request_context_getter,
     ChromeBlobStorageContext* blob_storage_context) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  if (cache_manager_ && request_context && blob_storage_context) {
+  if (cache_manager_ && request_context_getter && blob_storage_context) {
     cache_manager_->SetBlobParametersForCache(
-        request_context->GetURLRequestContext(),
-        blob_storage_context->context()->AsWeakPtr());
+        request_context_getter, blob_storage_context->context()->AsWeakPtr());
   }
 }
 

content/browser/cache_storage/cache_storage_context_impl.h

@@ -59,7 +59,7 @@ class CONTENT_EXPORT CacheStorageContextImpl
   // function immediately returns without forwarding to the
   // CacheStorageManager.
   void SetBlobParametersForCache(
-      net::URLRequestContextGetter* request_context,
+      net::URLRequestContextGetter* request_context_getter,
       ChromeBlobStorageContext* blob_storage_context);
 
  private:

content/browser/cache_storage/cache_storage_manager.cc

@@ -99,7 +99,7 @@ scoped_ptr<CacheStorageManager> CacheStorageManager::Create(
       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();
 }
@@ -173,13 +173,14 @@ void CacheStorageManager::MatchAllCaches(
 }
 
 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;
 }
 
@@ -292,7 +293,6 @@ CacheStorageManager::CacheStorageManager(
     : 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(
@@ -303,13 +303,13 @@ CacheStorageManager::CacheStorageManager(
 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));

content/browser/cache_storage/cache_storage_manager.h

@@ -11,8 +11,10 @@
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/gtest_prod_util.h"
+#include "base/memory/ref_counted.h"
 #include "content/browser/cache_storage/cache_storage.h"
 #include "content/common/content_export.h"
+#include "net/url_request/url_request_context_getter.h"
 #include "storage/browser/quota/quota_client.h"
 #include "url/gurl.h"
 
@@ -20,10 +22,6 @@ namespace base {
 class SequencedTaskRunner;
 }
 
-namespace net {
-class URLRequestContext;
-}
-
 namespace storage {
 class BlobStorageContext;
 class QuotaManagerProxy;
@@ -73,7 +71,7 @@ class CONTENT_EXPORT CacheStorageManager {
   // This must be called before creating any of the public *Cache functions
   // above.
   void SetBlobParametersForCache(
-      net::URLRequestContext* request_context,
+      const scoped_refptr<net::URLRequestContextGetter>& request_context_getter,
       base::WeakPtr<storage::BlobStorageContext> blob_storage_context);
 
   base::WeakPtr<CacheStorageManager> AsWeakPtr() {
@@ -110,8 +108,9 @@ class CONTENT_EXPORT CacheStorageManager {
       scoped_ptr<CacheStorage> cache_storage,
       base::WeakPtr<CacheStorageManager> cache_manager);
 
-  net::URLRequestContext* url_request_context() const {
-    return request_context_;
+  scoped_refptr<net::URLRequestContextGetter> url_request_context_getter()
+      const {
+    return request_context_getter_;
   }
   base::WeakPtr<storage::BlobStorageContext> blob_storage_context() const {
     return blob_context_;
@@ -147,7 +146,7 @@ class CONTENT_EXPORT CacheStorageManager {
   // |cache_task_runner_|.
   CacheStorageMap cache_storage_map_;
 
-  net::URLRequestContext* request_context_;
+  scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
   base::WeakPtr<storage::BlobStorageContext> blob_context_;
 
   base::WeakPtrFactory<CacheStorageManager> weak_ptr_factory_;

content/browser/cache_storage/cache_storage_manager_unittest.cc

@@ -41,8 +41,6 @@ class CacheStorageManagerTest : public testing::Test {
     quota_manager_proxy_ = new MockQuotaManagerProxy(
         nullptr, base::ThreadTaskRunnerHandle::Get().get());
 
-    net::URLRequestContext* url_request_context =
-        browser_context_.GetRequestContext()->GetURLRequestContext();
     if (MemoryOnly()) {
       cache_manager_ = CacheStorageManager::Create(
           base::FilePath(), base::ThreadTaskRunnerHandle::Get(),
@@ -55,7 +53,8 @@ class CacheStorageManagerTest : public testing::Test {
     }
 
     cache_manager_->SetBlobParametersForCache(
-        url_request_context, blob_storage_context->context()->AsWeakPtr());
+        browser_context_.GetRequestContext(),
+        blob_storage_context->context()->AsWeakPtr());
   }
 
   void TearDown() override {