Creates CacheContext for ServiceWorkerCacheStorage

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/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 {
 
+// The meta information related to each ServiceWorkerCache that the
+// ServiceWorkerCacheManager needs to keep track of.
+// TODO(jkarlin): Add reference counting.

[falken, 2014/08/26 06:31:32]

Depending on how long you plan to take, it might be good to make this TODO more
specific. Something like "so that the deletion of javascript objects can delete
the ServiceWorkerCache" as in the CL description.

[jkarlin, 2014/08/26 12:03:10]

Done.

+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.
 class ServiceWorkerCacheStorage::CacheLoader
     : public base::RefCountedThreadSafe<
           ServiceWorkerCacheStorage::CacheLoader> {
  public:
   typedef base::Callback<void(scoped_ptr<ServiceWorkerCache>)> CacheCallback;
   typedef base::Callback<void(bool)> BoolCallback;
   typedef base::Callback<void(scoped_ptr<std::vector<std::string> >)>
       StringsCallback;
 
@@ skipping 12 matching lines @@
   // 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(CacheMap* caches, const BoolCallback& callback) = 0;
+  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:
   friend class base::RefCountedThreadSafe<
       ServiceWorkerCacheStorage::CacheLoader>;
 
   virtual ~CacheLoader() {};
@@ skipping 12 matching lines @@
                base::WeakPtr<storage::BlobStorageContext> blob_context)
       : CacheLoader(cache_task_runner, request_context, blob_context) {}
   virtual void LoadCache(const std::string& cache_name,
                          const CacheCallback& callback) OVERRIDE {
     NOTREACHED();
   }
 
   virtual void CreateCache(const std::string& cache_name,
                            const CacheCallback& callback) OVERRIDE {
     scoped_ptr<ServiceWorkerCache> cache =
-        ServiceWorkerCache::CreateMemoryCache(
-            cache_name, request_context_, blob_context_);
+        ServiceWorkerCache::CreateMemoryCache(request_context_, blob_context_);
     callback.Run(cache.Pass());
   }
 
   virtual void CleanUpDeletedCache(const std::string& cache_name,
                                    const BoolCallback& callback) OVERRIDE {
     callback.Run(true);
   }
 
-  virtual void WriteIndex(CacheMap* caches,
+  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:
@@ skipping 50 matching lines @@
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     if (!dir_rv) {
       callback.Run(scoped_ptr<ServiceWorkerCache>());
       return;
     }
 
     scoped_ptr<ServiceWorkerCache> cache =
         ServiceWorkerCache::CreatePersistentCache(
             CreatePersistentCachePath(origin_path_, cache_name),
-            cache_name,
             request_context_,
             blob_context_);
     callback.Run(cache.Pass());
   }
 
   virtual void CreateCache(const std::string& cache_name,
                            const CacheCallback& callback) OVERRIDE {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
     // 1. Delete the cache's directory if it exists.
@@ skipping 55 matching lines @@
   void CleanUpDeleteCacheDirInPool(
       const base::FilePath& cache_path,
       const BoolCallback& callback,
       const scoped_refptr<base::MessageLoopProxy>& original_loop) {
     DCHECK(cache_task_runner_->RunsTasksOnCurrentThread());
 
     bool rv = base::DeleteFile(cache_path, true);
     original_loop->PostTask(FROM_HERE, base::Bind(callback, rv));
   }
 
-  virtual void WriteIndex(CacheMap* caches,
+  virtual void WriteIndex(const CacheMap& caches,
                           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 iter(caches); !iter.IsAtEnd();
-         iter.Advance()) {
-      const ServiceWorkerCache* cache = iter.GetCurrentValue();
+    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(cache->name);
       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");
 
     cache_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&SimpleCacheLoader::WriteIndexWriteToFileInPool,
                    this,
                    tmp_path,
                    index_path,
                    serialized,
-                   caches,
                    callback,
                    base::MessageLoopProxy::current()));
   }
 
   void WriteIndexWriteToFileInPool(
       const base::FilePath& tmp_path,
       const base::FilePath& index_path,
       const std::string& data,
-      CacheMap* caches,
       const BoolCallback& callback,
       const scoped_refptr<base::MessageLoopProxy>& original_loop) {
     DCHECK(cache_task_runner_->RunsTasksOnCurrentThread());
 
     int bytes_written = base::WriteFile(tmp_path, data.c_str(), data.size());
     if (bytes_written != implicit_cast<int>(data.size())) {
       base::DeleteFile(tmp_path, /* recursive */ false);
       original_loop->PostTask(FROM_HERE, base::Bind(callback, false));
     }
 
@@ skipping 75 matching lines @@
   const base::FilePath origin_path_;
 };
 
 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),
       weak_factory_(this) {
   if (memory_only)
     cache_loader_ =
         new MemoryLoader(cache_task_runner_, request_context, blob_context);
   else
     cache_loader_ = new SimpleCacheLoader(
         origin_path_, cache_task_runner_, 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 (cache_name.empty()) {
-    callback.Run(0, CACHE_STORAGE_ERROR_EMPTY_KEY);
+    callback.Run(-1, CACHE_STORAGE_ERROR_EMPTY_KEY);

[falken, 2014/08/26 06:31:33]

Should we have a kInvalidCacheId constant?

[jkarlin, 2014/08/26 12:03:10]

Done. Now used in the tests as well.

     return;
   }
 
   if (GetLoadedCache(cache_name)) {
-    callback.Run(0, CACHE_STORAGE_ERROR_EXISTS);
+    callback.Run(-1, 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;
   }
 
   if (cache_name.empty()) {
-    callback.Run(0, CACHE_STORAGE_ERROR_EMPTY_KEY);
+    callback.Run(-1, CACHE_STORAGE_ERROR_EMPTY_KEY);
     return;
   }
 
-  ServiceWorkerCache* cache = GetLoadedCache(cache_name);
-  if (!cache) {
-    callback.Run(0, CACHE_STORAGE_ERROR_NOT_FOUND);
+  CacheContext* cache_context = GetLoadedCache(cache_name);
+  if (!cache_context) {
+    callback.Run(-1, CACHE_STORAGE_ERROR_NOT_FOUND);
     return;
   }
 
+  ServiceWorkerCache* cache = cache_context->cache.get();
   cache->CreateBackend(base::Bind(&ServiceWorkerCacheStorage::DidCreateBackend,
                                   weak_factory_.GetWeakPtr(),
                                   cache->AsWeakPtr(),
+                                  cache_context->id,
                                   callback));
 }
 
 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(),
@@ skipping 23 matching lines @@
                         cache_name,
                         callback));
     return;
   }
 
   if (cache_name.empty()) {
     callback.Run(false, CACHE_STORAGE_ERROR_EMPTY_KEY);
     return;
   }
 
-  ServiceWorkerCache* cache = GetLoadedCache(cache_name);
-  if (!cache) {
+  scoped_ptr<CacheContext> cache_context(GetLoadedCache(cache_name));

[falken, 2014/08/26 06:31:32]

It's a bit subtle that the raw pointer returned by GetLoadedCache is wrapped in
a scoped_ptr specifically to delete it. Maybe add a brief comment?

[jkarlin, 2014/08/26 12:03:10]

Agree.  Specifically call .reset() now to make it clear.

+  if (!cache_context) {
     callback.Run(false, CACHE_STORAGE_ERROR_NOT_FOUND);
     return;
   }
 
   name_map_.erase(cache_name);
-  cache_map_.Remove(cache->id());  // deletes cache
+  cache_map_.erase(cache_context->id);
 
   // Update the Index
   cache_loader_->WriteIndex(
-      &cache_map_,
+      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();
        ++it) {
     names.push_back(it->first);
   }
 
   callback.Run(names, CACHE_STORAGE_ERROR_NO_ERROR);
 }
 
 void ServiceWorkerCacheStorage::DidCreateBackend(
     base::WeakPtr<ServiceWorkerCache> cache,
+    CacheID cache_id,
     const CacheAndErrorCallback& callback,
     bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!success || !cache) {
     // TODO(jkarlin): This should delete the directory and try again in case
     // the cache is simply corrupt.
-    callback.Run(0, CACHE_STORAGE_ERROR_STORAGE);
+    callback.Run(-1, CACHE_STORAGE_ERROR_STORAGE);
     return;
   }
-  callback.Run(cache->id(), CACHE_STORAGE_ERROR_NO_ERROR);
+  callback.Run(cache_id, 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);
   DCHECK(!initialized_);
 
   init_callbacks_.push_back(callback);
 
   // If this isn't the first call to LazyInit then return as the initialization
@@ skipping 28 matching lines @@
 
   std::vector<std::string>::const_iterator iter = indexed_cache_names->begin();
   std::vector<std::string>::const_iterator iter_next = iter + 1;
 
   cache_loader_->LoadCache(
       *iter,
       base::Bind(&ServiceWorkerCacheStorage::LazyInitIterateAndLoadCacheName,
                  weak_factory_.GetWeakPtr(),
                  callback,
                  base::Passed(indexed_cache_names.Pass()),
-                 iter_next));
+                 iter_next,
+                 *iter));
 }
 
 void ServiceWorkerCacheStorage::LazyInitIterateAndLoadCacheName(
     const base::Closure& callback,
     scoped_ptr<std::vector<std::string> > indexed_cache_names,
     const std::vector<std::string>::const_iterator& iter,
+    const std::string& cache_name,
     scoped_ptr<ServiceWorkerCache> cache) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (cache)
-    AddCacheToMaps(cache.Pass());
+    AddCacheToMaps(cache_name, cache.Pass());
 
   if (iter == indexed_cache_names->end()) {
     LazyInitDone();
     return;
   }
 
   std::vector<std::string>::const_iterator iter_next = iter + 1;
   cache_loader_->LoadCache(
       *iter,
       base::Bind(&ServiceWorkerCacheStorage::LazyInitIterateAndLoadCacheName,
                  weak_factory_.GetWeakPtr(),
                  callback,
                  base::Passed(indexed_cache_names.Pass()),
-                 iter_next));
+                 iter_next,
+                 *iter));
 }
 
 void ServiceWorkerCacheStorage::LazyInitDone() {
   initialized_ = true;
   for (std::vector<base::Closure>::iterator it = init_callbacks_.begin();
        it != init_callbacks_.end();
        ++it) {
     it->Run();
   }
   init_callbacks_.clear();
 }
 
-void ServiceWorkerCacheStorage::AddCacheToMaps(
-    scoped_ptr<ServiceWorkerCache> cache) {
+ServiceWorkerCacheStorage::CacheContext*
+ServiceWorkerCacheStorage::AddCacheToMaps(
+    const std::string& cache_name,
+    scoped_ptr<ServiceWorkerCache> sw_cache) {

[falken, 2014/08/26 06:31:32]

nit: Why rename? The other ServiceWorkerCache objects in this file are just
"cache".

[jkarlin, 2014/08/26 12:03:10]

Done.

   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  ServiceWorkerCache* cache_ptr = cache.release();
-  CacheID id = cache_map_.Add(cache_ptr);
-  name_map_.insert(std::make_pair(cache_ptr->name(), id));
-  cache_ptr->set_id(id);
+  CacheID id = next_cache_id_++;
+  CacheContext* cache_context =
+      new CacheContext(cache_name, id, sw_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) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!cache) {
-    callback.Run(0, CACHE_STORAGE_ERROR_STORAGE);
+    callback.Run(-1, CACHE_STORAGE_ERROR_CLOSING);
     return;
   }
 
-  base::WeakPtr<ServiceWorkerCache> cache_ptr = cache->AsWeakPtr();
-
-  AddCacheToMaps(cache.Pass());
+  CacheContext* cache_context = AddCacheToMaps(cache_name, cache.Pass());
 
   cache_loader_->WriteIndex(
-      &cache_map_,
-      base::Bind(
-          &ServiceWorkerCacheStorage::CreateCacheDidWriteIndex,
-          weak_factory_.GetWeakPtr(),
-          callback,
-          cache_ptr));  // cache is owned by this->CacheMap and won't be deleted
+      cache_map_,
+      base::Bind(&ServiceWorkerCacheStorage::CreateCacheDidWriteIndex,
+                 weak_factory_.GetWeakPtr(),
+                 callback,
+                 cache_context->cache->AsWeakPtr(),
+                 cache_context->id));
 }
 
 void ServiceWorkerCacheStorage::CreateCacheDidWriteIndex(
     const CacheAndErrorCallback& callback,
     base::WeakPtr<ServiceWorkerCache> cache,
+    CacheID id,
     bool success) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!cache) {
-    callback.Run(false, CACHE_STORAGE_ERROR_STORAGE);
+    callback.Run(false, CACHE_STORAGE_ERROR_CLOSING);
     return;
   }
   cache->CreateBackend(base::Bind(&ServiceWorkerCacheStorage::DidCreateBackend,
                                   weak_factory_.GetWeakPtr(),
                                   cache,
+                                  id,
                                   callback));
 }
 
 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);
 }
 
-ServiceWorkerCache* ServiceWorkerCacheStorage::GetLoadedCache(
-    const std::string& cache_name) const {
+ServiceWorkerCacheStorage::CacheContext*
+ServiceWorkerCacheStorage::GetLoadedCache(const std::string& cache_name) const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(initialized_);
 
-  NameMap::const_iterator it = name_map_.find(cache_name);
-  if (it == name_map_.end())
+  NameMap::const_iterator name_iter = name_map_.find(cache_name);
+  if (name_iter == name_map_.end())
     return NULL;
 
-  ServiceWorkerCache* cache = cache_map_.Lookup(it->second);
-  DCHECK(cache);
-  return cache;
+  CacheMap::const_iterator map_iter = cache_map_.find(name_iter->second);
+  DCHECK(map_iter != cache_map_.end());
+  return map_iter->second;
 }
 
 }  // namespace content