Expose ServiceWorkerCache objects to ServiceWorkerCacheStorageManager clients.

content/browser/service_worker/service_worker_cache_storage.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_storage.h"
 
 #include <string>
 
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/memory/ref_counted.h"
 #include "base/sha1.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "content/browser/service_worker/service_worker_cache.h"
 #include "content/browser/service_worker/service_worker_cache.pb.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/base/directory_lister.h"
 #include "net/base/net_errors.h"
 #include "webkit/browser/blob/blob_storage_context.h"
 
 namespace content {
 
-// static
-const int ServiceWorkerCacheStorage::kInvalidCacheID = -1;
-
-// The meta information related to each ServiceWorkerCache that the
-// ServiceWorkerCacheManager needs to keep track of.
-// TODO(jkarlin): Add reference counting so that the deletion of javascript
-// objects can delete the ServiceWorkerCache.
-struct ServiceWorkerCacheStorage::CacheContext {
-  CacheContext(const std::string& name,
-               CacheID id,
-               scoped_ptr<ServiceWorkerCache> cache)
-      : name(name), id(id), cache(cache.Pass()) {}
-  std::string name;
-  CacheID id;
-  scoped_ptr<ServiceWorkerCache> cache;
-};
 
 // Handles the loading and clean up of ServiceWorkerCache objects. The
 // callback of every public method is guaranteed to be called.
 class ServiceWorkerCacheStorage::CacheLoader {
  public:
-  typedef base::Callback<void(scoped_ptr<ServiceWorkerCache>)> CacheCallback;
+  typedef base::Callback<void(const scoped_refptr<ServiceWorkerCache>&)>
+      CacheCallback;
   typedef base::Callback<void(bool)> BoolCallback;
   typedef base::Callback<void(scoped_ptr<std::vector<std::string> >)>
       StringsCallback;
 
   CacheLoader(base::SequencedTaskRunner* cache_task_runner,
               net::URLRequestContext* request_context,
               base::WeakPtr<storage::BlobStorageContext> blob_context)
       : cache_task_runner_(cache_task_runner),
         request_context_(request_context),
         blob_context_(blob_context) {}
 
   virtual ~CacheLoader() {}
 
   // Loads the given cache_name, the cache is NULL if it fails. If the cache
   // doesn't exist a new one is created.
-  virtual scoped_ptr<ServiceWorkerCache> CreateServiceWorkerCache(
+  virtual scoped_refptr<ServiceWorkerCache> CreateServiceWorkerCache(
       const std::string& cache_name) = 0;
 
   // Deletes any pre-existing cache of the same name and then loads it.
   virtual void CreateCache(const std::string& cache_name,
                            const CacheCallback& callback) = 0;
 
   // After the backend has been deleted, do any extra house keeping such as
   // removing the cache's directory.
   virtual void CleanUpDeletedCache(const std::string& key,
                                    const BoolCallback& callback) = 0;
 
   // Writes the cache names (and sizes) to disk if applicable.
   virtual void WriteIndex(const CacheMap& caches,
                           const BoolCallback& callback) = 0;
 
   // Loads the cache names from disk if applicable.
   virtual void LoadIndex(scoped_ptr<std::vector<std::string> > cache_names,
                          const StringsCallback& callback) = 0;
 
  protected:
   scoped_refptr<base::SequencedTaskRunner> cache_task_runner_;
   net::URLRequestContext* request_context_;
   base::WeakPtr<storage::BlobStorageContext> blob_context_;
 };
 
+// Creates memory-only ServiceWorkerCaches. Because these caches have no
+// persistent storage it is not safe to free them from memory if they might be
+// used again. Therefore this class holds a reference to each cache until the
+// cache is deleted.
 class ServiceWorkerCacheStorage::MemoryLoader
     : public ServiceWorkerCacheStorage::CacheLoader {
  public:
   MemoryLoader(base::SequencedTaskRunner* cache_task_runner,
                net::URLRequestContext* request_context,
                base::WeakPtr<storage::BlobStorageContext> blob_context)
       : CacheLoader(cache_task_runner, request_context, blob_context) {}
 
-  virtual scoped_ptr<ServiceWorkerCache> CreateServiceWorkerCache(
+  virtual scoped_refptr<ServiceWorkerCache> CreateServiceWorkerCache(
       const std::string& cache_name) OVERRIDE {
     return ServiceWorkerCache::CreateMemoryCache(request_context_,
                                                  blob_context_);
   }
 
   virtual void CreateCache(const std::string& cache_name,
                            const CacheCallback& callback) OVERRIDE {
-    callback.Run(CreateServiceWorkerCache(cache_name).Pass());
+    scoped_refptr<ServiceWorkerCache> cache =
+        ServiceWorkerCache::CreateMemoryCache(request_context_, blob_context_);
+    cache_refs_.insert(std::make_pair(cache_name, cache));
+    callback.Run(cache);
   }
 
   virtual void CleanUpDeletedCache(const std::string& cache_name,
                                    const BoolCallback& callback) OVERRIDE {
+    CacheRefMap::iterator it = cache_refs_.find(cache_name);
+    DCHECK(it != cache_refs_.end());
+    cache_refs_.erase(it);
     callback.Run(true);
   }
 
   virtual void WriteIndex(const CacheMap& caches,
                           const BoolCallback& callback) OVERRIDE {
     callback.Run(false);
   }
 
   virtual void LoadIndex(scoped_ptr<std::vector<std::string> > cache_names,
                          const StringsCallback& callback) OVERRIDE {
     callback.Run(cache_names.Pass());
   }
 
  private:
+  typedef std::map<std::string, scoped_refptr<ServiceWorkerCache> > CacheRefMap;
   virtual ~MemoryLoader() {}
+
+  // Keep a reference to each cache to ensure that it's not freed before the
+  // client calls ServiceWorkerCacheStorage::Delete or the CacheStorage is
+  // freed.
+  CacheRefMap cache_refs_;
 };
 
 class ServiceWorkerCacheStorage::SimpleCacheLoader
     : public ServiceWorkerCacheStorage::CacheLoader {
  public:
   SimpleCacheLoader(const base::FilePath& origin_path,
                     base::SequencedTaskRunner* cache_task_runner,
                     net::URLRequestContext* request_context,
                     base::WeakPtr<storage::BlobStorageContext> blob_context)
       : CacheLoader(cache_task_runner, request_context, blob_context),
         origin_path_(origin_path),
         weak_ptr_factory_(this) {}
 
-  virtual scoped_ptr<ServiceWorkerCache> CreateServiceWorkerCache(
+  virtual scoped_refptr<ServiceWorkerCache> CreateServiceWorkerCache(
       const std::string& cache_name) OVERRIDE {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     return ServiceWorkerCache::CreatePersistentCache(
         CreatePersistentCachePath(origin_path_, cache_name),
         request_context_,
         blob_context_);
   }
 
   virtual void CreateCache(const std::string& cache_name,
@@ skipping 21 matching lines @@
     if (base::PathExists(cache_path))
       base::DeleteFile(cache_path, /* recursive */ true);
     return base::CreateDirectory(cache_path);
   }
 
   static void CreateCachePreppedDir(const std::string& cache_name,
                                     const CacheCallback& callback,
                                     base::WeakPtr<SimpleCacheLoader> loader,
                                     bool success) {
     if (!success || !loader) {
-      callback.Run(scoped_ptr<ServiceWorkerCache>());
+      callback.Run(scoped_refptr<ServiceWorkerCache>());
       return;
     }
 
     callback.Run(loader->CreateServiceWorkerCache(cache_name));
   }
 
   virtual void CleanUpDeletedCache(const std::string& cache_name,
                                    const BoolCallback& callback) OVERRIDE {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
@@ skipping 21 matching lines @@
                           const BoolCallback& callback) OVERRIDE {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     // 1. Create the index file as a string. (WriteIndex)
     // 2. Write the file to disk. (WriteIndexWriteToFileInPool)
 
     ServiceWorkerCacheStorageIndex index;
 
     for (CacheMap::const_iterator it = caches.begin(); it != caches.end();
          ++it) {
-      const CacheContext* cache = it->second;
       ServiceWorkerCacheStorageIndex::Cache* index_cache = index.add_cache();
-      index_cache->set_name(cache->name);
+      index_cache->set_name(it->first);
       index_cache->set_size(0);  // TODO(jkarlin): Make this real.
     }
 
     std::string serialized;
     bool success = index.SerializeToString(&serialized);
     DCHECK(success);
 
     base::FilePath tmp_path = origin_path_.AppendASCII("index.txt.tmp");
     base::FilePath index_path = origin_path_.AppendASCII("index.txt");
 
@@ skipping 96 matching lines @@
   base::WeakPtrFactory<SimpleCacheLoader> weak_ptr_factory_;
 };
 
 ServiceWorkerCacheStorage::ServiceWorkerCacheStorage(
     const base::FilePath& path,
     bool memory_only,
     base::SequencedTaskRunner* cache_task_runner,
     net::URLRequestContext* request_context,
     base::WeakPtr<storage::BlobStorageContext> blob_context)
     : initialized_(false),
-      next_cache_id_(0),
       origin_path_(path),
       cache_task_runner_(cache_task_runner),
+      memory_only_(memory_only),
       weak_factory_(this) {
   if (memory_only)
     cache_loader_.reset(new MemoryLoader(
         cache_task_runner_.get(), request_context, blob_context));
   else
     cache_loader_.reset(new SimpleCacheLoader(
         origin_path_, cache_task_runner_.get(), request_context, blob_context));
 }
 
 ServiceWorkerCacheStorage::~ServiceWorkerCacheStorage() {
-  STLDeleteContainerPairSecondPointers(cache_map_.begin(), cache_map_.end());
 }
 
 void ServiceWorkerCacheStorage::CreateCache(
     const std::string& cache_name,
     const CacheAndErrorCallback& callback) {
   if (!initialized_) {
     LazyInit(base::Bind(&ServiceWorkerCacheStorage::CreateCache,
                         weak_factory_.GetWeakPtr(),
                         cache_name,
                         callback));
     return;
   }
 
-  if (GetLoadedCache(cache_name)) {
-    callback.Run(kInvalidCacheID, CACHE_STORAGE_ERROR_EXISTS);
+  if (cache_map_.find(cache_name) != cache_map_.end()) {
+    callback.Run(scoped_refptr<ServiceWorkerCache>(),
+                 CACHE_STORAGE_ERROR_EXISTS);
     return;
   }
 
   cache_loader_->CreateCache(
       cache_name,
       base::Bind(&ServiceWorkerCacheStorage::CreateCacheDidCreateCache,
                  weak_factory_.GetWeakPtr(),
                  cache_name,
                  callback));
 }
 
 void ServiceWorkerCacheStorage::GetCache(
     const std::string& cache_name,
     const CacheAndErrorCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_) {
     LazyInit(base::Bind(&ServiceWorkerCacheStorage::GetCache,
                         weak_factory_.GetWeakPtr(),
                         cache_name,
                         callback));
     return;
   }
 
-  CacheContext* cache_context = GetLoadedCache(cache_name);
-  if (!cache_context) {
-    callback.Run(kInvalidCacheID, CACHE_STORAGE_ERROR_NOT_FOUND);
+  scoped_refptr<ServiceWorkerCache> cache = GetLoadedCache(cache_name);
+  if (!cache.get()) {
+    callback.Run(scoped_refptr<ServiceWorkerCache>(),
+                 CACHE_STORAGE_ERROR_NOT_FOUND);
     return;
   }
 
-  callback.Run(cache_context->id, CACHE_STORAGE_ERROR_NO_ERROR);
+  callback.Run(cache, CACHE_STORAGE_ERROR_NO_ERROR);
 }
 
 void ServiceWorkerCacheStorage::HasCache(const std::string& cache_name,
                                          const BoolAndErrorCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_) {
     LazyInit(base::Bind(&ServiceWorkerCacheStorage::HasCache,
                         weak_factory_.GetWeakPtr(),
                         cache_name,
                         callback));
     return;
   }
 
-  bool has_cache = GetLoadedCache(cache_name) != NULL;
+  bool has_cache = cache_map_.find(cache_name) != cache_map_.end();
 
   callback.Run(has_cache, CACHE_STORAGE_ERROR_NO_ERROR);
 }
 
 void ServiceWorkerCacheStorage::DeleteCache(
     const std::string& cache_name,
     const BoolAndErrorCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_) {
     LazyInit(base::Bind(&ServiceWorkerCacheStorage::DeleteCache,
                         weak_factory_.GetWeakPtr(),
                         cache_name,
                         callback));
     return;
   }
 
-  scoped_ptr<CacheContext> cache_context(GetLoadedCache(cache_name));
-  if (!cache_context) {
+
+  CacheMap::iterator it = cache_map_.find(cache_name);
+  if (it == cache_map_.end()) {
     callback.Run(false, CACHE_STORAGE_ERROR_NOT_FOUND);
     return;
   }
 
-  name_map_.erase(cache_name);
-  cache_map_.erase(cache_context->id);
-  cache_context.reset();
+  base::WeakPtr<ServiceWorkerCache> cache = it->second;
+  if (cache)
+    cache->Close();
+
+  cache_map_.erase(it);
 
   // Update the Index
   cache_loader_->WriteIndex(
       cache_map_,
       base::Bind(&ServiceWorkerCacheStorage::DeleteCacheDidWriteIndex,
                  weak_factory_.GetWeakPtr(),
                  cache_name,
                  callback));
 }
 
 void ServiceWorkerCacheStorage::EnumerateCaches(
     const StringsAndErrorCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!initialized_) {
     LazyInit(base::Bind(&ServiceWorkerCacheStorage::EnumerateCaches,
                         weak_factory_.GetWeakPtr(),
                         callback));
     return;
   }
 
   std::vector<std::string> names;
-  for (NameMap::const_iterator it = name_map_.begin(); it != name_map_.end();
+  for (CacheMap::const_iterator it = cache_map_.begin(); it != cache_map_.end();
        ++it) {
     names.push_back(it->first);
   }
 
   callback.Run(names, CACHE_STORAGE_ERROR_NO_ERROR);
 }
 
 // Init is run lazily so that it is called on the proper MessageLoop.
 void ServiceWorkerCacheStorage::LazyInit(const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 19 matching lines @@
       base::Bind(&ServiceWorkerCacheStorage::LazyInitDidLoadIndex,
                  weak_factory_.GetWeakPtr(),
                  callback));
 }
 
 void ServiceWorkerCacheStorage::LazyInitDidLoadIndex(
     const base::Closure& callback,
     scoped_ptr<std::vector<std::string> > indexed_cache_names) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  for (std::vector<std::string>::iterator it = indexed_cache_names->begin();
-       it != indexed_cache_names->end();
-       ++it) {
-    scoped_ptr<ServiceWorkerCache> cache =
-        cache_loader_->CreateServiceWorkerCache(*it);
-    if (!cache)
-      continue;
-    AddCacheToMaps(*it, cache.Pass());
+
+  for (size_t i = 0u, max = indexed_cache_names->size(); i < max; ++i) {
+    cache_map_.insert(std::make_pair(indexed_cache_names->at(i),
+                                     base::WeakPtr<ServiceWorkerCache>()));
   }
 
   initialized_ = true;
   for (std::vector<base::Closure>::iterator it = init_callbacks_.begin();
        it != init_callbacks_.end();
        ++it) {
     it->Run();
   }
   init_callbacks_.clear();
 }
 
-ServiceWorkerCacheStorage::CacheContext*
-ServiceWorkerCacheStorage::AddCacheToMaps(
-    const std::string& cache_name,
-    scoped_ptr<ServiceWorkerCache> cache) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-
-  CacheID id = next_cache_id_++;
-  CacheContext* cache_context = new CacheContext(cache_name, id, cache.Pass());
-  cache_map_.insert(std::make_pair(id, cache_context));  // Takes ownership
-  name_map_.insert(std::make_pair(cache_name, id));
-  return cache_context;
-}
-
 void ServiceWorkerCacheStorage::CreateCacheDidCreateCache(
     const std::string& cache_name,
     const CacheAndErrorCallback& callback,
-    scoped_ptr<ServiceWorkerCache> cache) {
+    const scoped_refptr<ServiceWorkerCache>& cache) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  if (!cache) {
-    callback.Run(kInvalidCacheID, CACHE_STORAGE_ERROR_CLOSING);
+  if (!cache.get()) {
+    callback.Run(scoped_refptr<ServiceWorkerCache>(),
+                 CACHE_STORAGE_ERROR_CLOSING);
     return;
   }
 
-  CacheContext* cache_context = AddCacheToMaps(cache_name, cache.Pass());
+  cache_map_.insert(std::make_pair(cache_name, cache->AsWeakPtr()));
 
   cache_loader_->WriteIndex(
       cache_map_,
       base::Bind(&ServiceWorkerCacheStorage::CreateCacheDidWriteIndex,
                  weak_factory_.GetWeakPtr(),
                  callback,
-                 cache_context->cache->AsWeakPtr(),
-                 cache_context->id));
+                 cache));
 }
 
 void ServiceWorkerCacheStorage::CreateCacheDidWriteIndex(
     const CacheAndErrorCallback& callback,
-    base::WeakPtr<ServiceWorkerCache> cache,
-    CacheID id,
+    const scoped_refptr<ServiceWorkerCache>& cache,
     bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (!cache) {
-    callback.Run(kInvalidCacheID, CACHE_STORAGE_ERROR_CLOSING);
-    return;
-  }
+  DCHECK(cache.get());
 
-  callback.Run(id, CACHE_STORAGE_ERROR_NO_ERROR);
+  callback.Run(cache, CACHE_STORAGE_ERROR_NO_ERROR);
 }
 
 void ServiceWorkerCacheStorage::DeleteCacheDidWriteIndex(
     const std::string& cache_name,
     const BoolAndErrorCallback& callback,
     bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   cache_loader_->CleanUpDeletedCache(
       cache_name,
       base::Bind(&ServiceWorkerCacheStorage::DeleteCacheDidCleanUp,
                  weak_factory_.GetWeakPtr(),
                  callback));
 }
 
 void ServiceWorkerCacheStorage::DeleteCacheDidCleanUp(
     const BoolAndErrorCallback& callback,
     bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   callback.Run(true, CACHE_STORAGE_ERROR_NO_ERROR);
 }
 
-ServiceWorkerCacheStorage::CacheContext*
-ServiceWorkerCacheStorage::GetLoadedCache(const std::string& cache_name) const {
+scoped_refptr<ServiceWorkerCache> ServiceWorkerCacheStorage::GetLoadedCache(
+    const std::string& cache_name) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(initialized_);
 
-  NameMap::const_iterator name_iter = name_map_.find(cache_name);
-  if (name_iter == name_map_.end())
-    return NULL;
+  CacheMap::iterator map_iter = cache_map_.find(cache_name);
+  if (map_iter == cache_map_.end())
+    return scoped_refptr<ServiceWorkerCache>();
 
-  CacheMap::const_iterator map_iter = cache_map_.find(name_iter->second);
-  DCHECK(map_iter != cache_map_.end());
-  return map_iter->second;
+  base::WeakPtr<ServiceWorkerCache> cache = map_iter->second;
+
+  if (!cache) {
+    scoped_refptr<ServiceWorkerCache> new_cache =
+        cache_loader_->CreateServiceWorkerCache(cache_name);
+    map_iter->second = new_cache->AsWeakPtr();
+    return new_cache;
+  }
+
+  return make_scoped_refptr(cache.get());
 }
 
 }  // namespace content