Expose ServiceWorkerCache objects to ServiceWorkerCacheStorageManager clients.

content/browser/service_worker/service_worker_cache.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/service_worker/service_worker_cache.h"
 
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/guid.h"
@@ skipping 587 matching lines @@
         cache(cache),
         out_keys(new ServiceWorkerCache::Requests()),
         backend_iterator(NULL),
         enumerated_entry(NULL) {}
 
   ~KeysContext() {
     for (size_t i = 0, max = entries.size(); i < max; ++i)
       entries[i]->Close();
     if (enumerated_entry)
       enumerated_entry->Close();
-    if (cache && backend_iterator)
+    if (cache && backend_iterator && cache->backend_)
       cache->backend_->EndEnumeration(&backend_iterator);
   }
 
   // The callback passed to the Keys() function.
   ServiceWorkerCache::RequestsCallback original_callback;
 
   // The ServiceWorkerCache that Keys was called on.
   base::WeakPtr<ServiceWorkerCache> cache;
 
   // The vector of open entries in the backend.
   Entries entries;
 
   // The output of the Keys function.
   scoped_ptr<ServiceWorkerCache::Requests> out_keys;
 
   // Used for enumerating cache entries.
   void* backend_iterator;
   disk_cache::Entry* enumerated_entry;
 };
 
 // static
-scoped_ptr<ServiceWorkerCache> ServiceWorkerCache::CreateMemoryCache(
+scoped_refptr<ServiceWorkerCache> ServiceWorkerCache::CreateMemoryCache(
     net::URLRequestContext* request_context,
     base::WeakPtr<storage::BlobStorageContext> blob_context) {
-  return make_scoped_ptr(
+  return make_scoped_refptr(
       new ServiceWorkerCache(base::FilePath(), request_context, blob_context));
 }
 
 // static
-scoped_ptr<ServiceWorkerCache> ServiceWorkerCache::CreatePersistentCache(
+scoped_refptr<ServiceWorkerCache> ServiceWorkerCache::CreatePersistentCache(
     const base::FilePath& path,
     net::URLRequestContext* request_context,
     base::WeakPtr<storage::BlobStorageContext> blob_context) {
-  return make_scoped_ptr(
+  return make_scoped_refptr(
       new ServiceWorkerCache(path, request_context, blob_context));
 }
 
 ServiceWorkerCache::~ServiceWorkerCache() {
 }
 
 base::WeakPtr<ServiceWorkerCache> ServiceWorkerCache::AsWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
@@ skipping 147 matching lines @@
   net::CompletionCallback open_entry_callback =
       base::Bind(KeysDidOpenNextEntry, base::Passed(keys_context.Pass()));
 
   int rv = backend_->OpenNextEntry(
       backend_iterator, enumerated_entry, open_entry_callback);
 
   if (rv != net::ERR_IO_PENDING)
     open_entry_callback.Run(rv);
 }
 
+void ServiceWorkerCache::Close() {
+  backend_.reset();
+}
+
 ServiceWorkerCache::ServiceWorkerCache(
     const base::FilePath& path,
     net::URLRequestContext* request_context,
     base::WeakPtr<storage::BlobStorageContext> blob_context)
     : path_(path),
       request_context_(request_context),
       blob_storage_context_(blob_context),
       initialized_(false),
       weak_ptr_factory_(this) {
 }
@@ skipping 10 matching lines @@
     return;
   }
 
   base::WeakPtr<ServiceWorkerCache> cache = keys_context->cache;
   if (rv < 0 || !cache) {
     keys_context->original_callback.Run(ErrorTypeStorage,
                                         scoped_ptr<Requests>());
     return;
   }
 
+  if (!cache->backend_) {
+    keys_context->original_callback.Run(ErrorTypeNotFound,
+                                        scoped_ptr<Requests>());
+    return;
+  }
+
   // Store the entry.
   keys_context->entries.push_back(keys_context->enumerated_entry);
   keys_context->enumerated_entry = NULL;
 
   // Enumerate the next entry.
   void** backend_iterator = &keys_context->backend_iterator;
   disk_cache::Entry** enumerated_entry = &keys_context->enumerated_entry;
 
   net::CompletionCallback open_entry_callback =
       base::Bind(KeysDidOpenNextEntry, base::Passed(keys_context.Pass()));
@@ skipping 101 matching lines @@
   initialized_ = true;
   for (std::vector<base::Closure>::iterator it = init_callbacks_.begin();
        it != init_callbacks_.end();
        ++it) {
     it->Run();
   }
   init_callbacks_.clear();
 }
 
 }  // namespace content