[CacheStorage] Give ownership of all CacheStorageCaches to CacheStorage

content/browser/service_worker/service_worker_browsertest.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 <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "content/browser/blob_storage/chrome_blob_storage_context.h"
 #include "content/browser/cache_storage/cache_storage_cache.h"
+#include "content/browser/cache_storage/cache_storage_cache_handle.h"
 #include "content/browser/cache_storage/cache_storage_context_impl.h"
 #include "content/browser/cache_storage/cache_storage_manager.h"
 #include "content/browser/service_worker/embedded_worker_instance.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/embedded_worker_status.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_observer.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_fetch_dispatcher.h"
 #include "content/browser/service_worker/service_worker_registration.h"
@@ skipping 1612 matching lines @@
     RunOnIOThread(base::Bind(&self::OpenCacheOnIOThread, this, &result));
     return result;
   }
 
   void OpenCacheOnIOThread(int* result, const base::Closure& continuation) {
     cache_storage_context_->cache_manager()->OpenCache(
         origin_, cache_name_, base::Bind(&self::OnCacheStorageOpenCallback,
                                          this, result, continuation));
   }
 
-  void OnCacheStorageOpenCallback(int* result,
-                                  const base::Closure& continuation,
-                                  scoped_refptr<CacheStorageCache> cache,
-                                  CacheStorageError error) {
+  void OnCacheStorageOpenCallback(
+      int* result,
+      const base::Closure& continuation,
+      std::unique_ptr<CacheStorageCacheHandle> cache_handle,
+      CacheStorageError error) {
     ASSERT_EQ(CACHE_STORAGE_OK, error);
     std::unique_ptr<ServiceWorkerFetchRequest> scoped_request(
         new ServiceWorkerFetchRequest());
     scoped_request->url = url_;
-    cache->Match(std::move(scoped_request),
-                 base::Bind(&self::OnCacheStorageCacheMatchCallback, this,
-                            result, continuation));
+    CacheStorageCache* cache = cache_handle->value();
+    cache->Match(
+        std::move(scoped_request),
+        base::Bind(&self::OnCacheStorageCacheMatchCallback, this, result,
+                   continuation, base::Passed(std::move(cache_handle))));
   }
 
   void OnCacheStorageCacheMatchCallback(
       int* result,
       const base::Closure& continuation,
+      std::unique_ptr<CacheStorageCacheHandle> cache_handle,
       CacheStorageError error,
       std::unique_ptr<ServiceWorkerResponse> response,
       std::unique_ptr<storage::BlobDataHandle> blob_data_handle) {
     ASSERT_EQ(CACHE_STORAGE_OK, error);
     blob_data_handle_ = std::move(blob_data_handle);
     blob_reader_ = blob_data_handle_->CreateReader(
         file_system_context_,
         BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE).get());
     const storage::BlobReader::Status status = blob_reader_->CalculateSize(
         base::Bind(&self::OnBlobReaderCalculateSizeCallback, this, result,
@@ skipping 181 matching lines @@
   NavigateToTestPage();
   // The V8 code cache must be stored to the CacheStorage which must be bigger
   // than 12 byte.
   EXPECT_GT(GetSideDataSize(), kV8CacheTimeStampDataSize);
 
   NavigateToTestPage();
   EXPECT_GT(GetSideDataSize(), kV8CacheTimeStampDataSize);
 }
 
 }  // namespace content