Creates CacheContext for ServiceWorkerCacheStorage.

Creates CacheContext which the CacheStorage uses to keep track of
Cache metadata rather than sticking it in the ServiceWorkerCache where
it doesn't belong.  The CacheContext will be used in a downstream CL
to keep reference count information for each cache.

This CL also changes the CacheMap from an IDMap to a std::map with our own id counting.
This lets us change to int64 from int32 as well as helps the transition to reference counting the caches.

Some other upcoming CLs affecting CacheStorage:
* Reference count CacheContext so that the deletion of javascript objects can delete the ServiceWorkerCache
* Make the callbacks in ServiceWorkerCacheStorage unnamed functions that don't require weak pointers.
* Change the CacheID to int64.

BUG=392621

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

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

content/browser/service_worker/service_worker_cache.cc

@@ -565,21 +565,19 @@ void CreateBackendDidCreate(const ServiceWorkerCache::ErrorCallback& callback,
 
 // static
 scoped_ptr<ServiceWorkerCache> ServiceWorkerCache::CreateMemoryCache(
-    const std::string& name,
     net::URLRequestContext* request_context,
     base::WeakPtr<storage::BlobStorageContext> blob_context) {
-  return make_scoped_ptr(new ServiceWorkerCache(
-      base::FilePath(), name, request_context, blob_context));
+  return make_scoped_ptr(
+      new ServiceWorkerCache(base::FilePath(), request_context, blob_context));
 }
 
 // static
 scoped_ptr<ServiceWorkerCache> ServiceWorkerCache::CreatePersistentCache(
     const base::FilePath& path,
-    const std::string& name,
     net::URLRequestContext* request_context,
     base::WeakPtr<storage::BlobStorageContext> blob_context) {
   return make_scoped_ptr(
-      new ServiceWorkerCache(path, name, request_context, blob_context));
+      new ServiceWorkerCache(path, request_context, blob_context));
 }
 
 ServiceWorkerCache::~ServiceWorkerCache() {
@@ -709,14 +707,11 @@ bool ServiceWorkerCache::HasCreatedBackend() const {
 
 ServiceWorkerCache::ServiceWorkerCache(
     const base::FilePath& path,
-    const std::string& name,
     net::URLRequestContext* request_context,
     base::WeakPtr<storage::BlobStorageContext> blob_context)
     : path_(path),
-      name_(name),
       request_context_(request_context),
       blob_storage_context_(blob_context),
-      id_(0),
       weak_ptr_factory_(this) {
 }
 

content/browser/service_worker/service_worker_cache.h

@@ -47,12 +47,10 @@ class CONTENT_EXPORT ServiceWorkerCache {
                               scoped_ptr<storage::BlobDataHandle>)>
       ResponseCallback;
   static scoped_ptr<ServiceWorkerCache> CreateMemoryCache(
-      const std::string& name,
       net::URLRequestContext* request_context,
       base::WeakPtr<storage::BlobStorageContext> blob_context);
   static scoped_ptr<ServiceWorkerCache> CreatePersistentCache(
       const base::FilePath& path,
-      const std::string& name,
       net::URLRequestContext* request_context,
       base::WeakPtr<storage::BlobStorageContext> blob_context);
 
@@ -88,25 +86,18 @@ class CONTENT_EXPORT ServiceWorkerCache {
   void set_backend(scoped_ptr<disk_cache::Backend> backend) {
     backend_ = backend.Pass();
   }
-  void set_name(const std::string& name) { name_ = name; }
-  const std::string& name() const { return name_; }
-  int32 id() const { return id_; }
-  void set_id(int32 id) { id_ = id; }
 
   base::WeakPtr<ServiceWorkerCache> AsWeakPtr();
 
  private:
   ServiceWorkerCache(const base::FilePath& path,
-                     const std::string& name,
                      net::URLRequestContext* request_context,
                      base::WeakPtr<storage::BlobStorageContext> blob_context);
 
   scoped_ptr<disk_cache::Backend> backend_;
   base::FilePath path_;
-  std::string name_;
   net::URLRequestContext* request_context_;
   base::WeakPtr<storage::BlobStorageContext> blob_storage_context_;
-  int32 id_;
 
   base::WeakPtrFactory<ServiceWorkerCache> weak_ptr_factory_;
 

content/browser/service_worker/service_worker_cache_listener.cc

@@ -40,6 +40,10 @@ WebServiceWorkerCacheError ToWebServiceWorkerCacheError(
       // TODO(jkarlin): Update this to CACHE_STORAGE_ERROR_EMPTY_KEY once that's
       // added.
       return WebServiceWorkerCacheError::WebServiceWorkerCacheErrorNotFound;
+    case ServiceWorkerCacheStorage::CACHE_STORAGE_ERROR_CLOSING:
+      // TODO(jkarlin): Update this to CACHE_STORAGE_ERROR_CLOSING once that's
+      // added.
+      return WebServiceWorkerCacheError::WebServiceWorkerCacheErrorNotFound;
   }
   NOTREACHED();
   return WebServiceWorkerCacheError::WebServiceWorkerCacheErrorNotImplemented;

content/browser/service_worker/service_worker_cache_storage.h

@@ -10,7 +10,6 @@
 
 #include "base/callback.h"
 #include "base/files/file_path.h"
-#include "base/id_map.h"
 #include "base/memory/weak_ptr.h"
 #include "content/browser/service_worker/service_worker_cache.h"
 
@@ -33,8 +32,15 @@ namespace content {
 // ServiceWorkerCacheStorage holds the set of caches for a given origin. It is
 // owned by the ServiceWorkerCacheStorageManager. This class expects to be run
 // on the IO thread.
-class ServiceWorkerCacheStorage {
+class CONTENT_EXPORT ServiceWorkerCacheStorage {
  public:
+  // TODO(jkarlin): Convert this (and everything that uses it) to int64_t so
+  // that we don't run out of id space.
+  typedef int32_t CacheID;
+
+  // The CacheID returned on failed cache operations.
+  const static int kInvalidCacheID;
+
   enum CacheStorageError {
     CACHE_STORAGE_ERROR_NO_ERROR,
     CACHE_STORAGE_ERROR_NOT_IMPLEMENTED,
@@ -42,6 +48,7 @@ class ServiceWorkerCacheStorage {
     CACHE_STORAGE_ERROR_EXISTS,
     CACHE_STORAGE_ERROR_STORAGE,
     CACHE_STORAGE_ERROR_EMPTY_KEY,
+    CACHE_STORAGE_ERROR_CLOSING
   };
 
   typedef base::Callback<void(bool, CacheStorageError)> BoolAndErrorCallback;
@@ -87,12 +94,12 @@ class ServiceWorkerCacheStorage {
   class MemoryLoader;
   class SimpleCacheLoader;
   class CacheLoader;
+  struct CacheContext;
 
-  typedef IDMap<ServiceWorkerCache, IDMapOwnPointer> CacheMap;
-  typedef CacheMap::KeyType CacheID;
+  typedef std::map<CacheID, CacheContext*> CacheMap;
   typedef std::map<std::string, CacheID> NameMap;
 
-  ServiceWorkerCache* GetLoadedCache(const std::string& cache_name) const;
+  CacheContext* GetLoadedCache(const std::string& cache_name) const;
 
   // Initializer and its callback are below.
   void LazyInit(const base::Closure& closure);
@@ -103,14 +110,17 @@ class ServiceWorkerCacheStorage {
       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);
   void LazyInitDone();
 
   void DidCreateBackend(base::WeakPtr<ServiceWorkerCache> cache,
+                        CacheID cache_id,
                         const CacheAndErrorCallback& callback,
                         ServiceWorkerCache::ErrorType error);
 
-  void AddCacheToMaps(scoped_ptr<ServiceWorkerCache> cache);
+  CacheContext* AddCacheToMaps(const std::string& cache_name,
+                               scoped_ptr<ServiceWorkerCache> cache);
 
   // The CreateCache callbacks are below.
   void CreateCacheDidCreateCache(const std::string& cache_name,
@@ -118,6 +128,7 @@ class ServiceWorkerCacheStorage {
                                  scoped_ptr<ServiceWorkerCache> cache);
   void CreateCacheDidWriteIndex(const CacheAndErrorCallback& callback,
                                 base::WeakPtr<ServiceWorkerCache> cache,
+                                CacheID id,
                                 bool success);
 
   // The DeleteCache callbacks are below.
@@ -133,9 +144,11 @@ class ServiceWorkerCacheStorage {
   // The list of operations waiting on initialization.
   std::vector<base::Closure> init_callbacks_;
 
-  // The map of ServiceWorkerCache objects to their integer ids that
-  // ServiceWorkers reference.  Owns the cache objects.
+  // The map of CacheIDs to their CacheContext objects. Owns the CacheContext
+  // object. The CacheIDs are used by JavaScript to reference a
+  // ServiceWorkerCache.
   CacheMap cache_map_;
+  CacheID next_cache_id_;  // The next CacheID to use in cache_map_
 
   // The map of cache names to their integer ids.
   NameMap name_map_;

content/browser/service_worker/service_worker_cache_storage_manager_unittest.cc

@@ -92,9 +92,9 @@ class ServiceWorkerCacheStorageManagerTest : public testing::Test {
     bool error = callback_error_ !=
                  ServiceWorkerCacheStorage::CACHE_STORAGE_ERROR_NO_ERROR;
     if (error)
-      EXPECT_EQ(0, callback_cache_id_);
+      EXPECT_EQ(ServiceWorkerCacheStorage::kInvalidCacheID, callback_cache_id_);
     else
-      EXPECT_LT(0, callback_cache_id_);
+      EXPECT_LE(0, callback_cache_id_);
     return !error;
   }
 
@@ -111,9 +111,9 @@ class ServiceWorkerCacheStorageManagerTest : public testing::Test {
     bool error = callback_error_ !=
                  ServiceWorkerCacheStorage::CACHE_STORAGE_ERROR_NO_ERROR;
     if (error)
-      EXPECT_EQ(0, callback_cache_id_);
+      EXPECT_EQ(ServiceWorkerCacheStorage::kInvalidCacheID, callback_cache_id_);
     else
-      EXPECT_LT(0, callback_cache_id_);
+      EXPECT_LE(0, callback_cache_id_);
     return !error;
   }
 
@@ -181,7 +181,7 @@ class ServiceWorkerCacheStorageManagerTest : public testing::Test {
   scoped_ptr<ServiceWorkerCacheStorageManager> cache_manager_;
 
   int callback_bool_;
-  int callback_cache_id_;
+  ServiceWorkerCacheStorage::CacheID callback_cache_id_;
   ServiceWorkerCacheStorage::CacheStorageError callback_error_;
   std::vector<std::string> callback_strings_;
 
@@ -223,6 +223,14 @@ TEST_P(ServiceWorkerCacheStorageManagerTestP, CreateTwoCaches) {
   EXPECT_TRUE(CreateCache(origin1_, "bar"));
 }
 
+TEST_P(ServiceWorkerCacheStorageManagerTestP, IDsDiffer) {
+  EXPECT_TRUE(CreateCache(origin1_, "foo"));
+  ServiceWorkerCacheStorage::CacheID id1 = callback_cache_id_;
+  EXPECT_TRUE(CreateCache(origin1_, "bar"));
+  ServiceWorkerCacheStorage::CacheID id2 = callback_cache_id_;
+  EXPECT_NE(id1, id2);
+}
+
 TEST_P(ServiceWorkerCacheStorageManagerTestP, Create2CachesSameNameDiffSWs) {
   EXPECT_TRUE(CreateCache(origin1_, "foo"));
   EXPECT_TRUE(CreateCache(origin2_, "foo"));

content/browser/service_worker/service_worker_cache_unittest.cc

@@ -66,14 +66,12 @@ class ServiceWorkerCacheTest : public testing::Test {
 
     if (MemoryOnly()) {
       cache_ = ServiceWorkerCache::CreateMemoryCache(
-          "test",
           url_request_context,
           blob_storage_context->context()->AsWeakPtr());
     } else {
       ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
       cache_ = ServiceWorkerCache::CreatePersistentCache(
           temp_dir_.path(),
-          "test",
           url_request_context,
           blob_storage_context->context()->AsWeakPtr());
     }