Expose ServiceWorkerCache objects to ServiceWorkerCacheStorageManager clients.

content/browser/service_worker/service_worker_cache_listener.h

Index: content/browser/service_worker/service_worker_cache_listener.h
diff --git a/content/browser/service_worker/service_worker_cache_listener.h b/content/browser/service_worker/service_worker_cache_listener.h
index 27a6089019946382624155b3db88bf1eb8933ba0..9408f4f0a57733cc60ca83626e7417fc019e1bd6 100644
--- a/content/browser/service_worker/service_worker_cache_listener.h
+++ b/content/browser/service_worker/service_worker_cache_listener.h
@@ -35,12 +35,18 @@ class ServiceWorkerCacheListener : public EmbeddedWorkerInstance::Listener {
                            const base::string16& cache_name);
   void OnCacheStorageKeys(int request_id);
 
+  // TODO(gavinp,jkarlin): Plumb a message up from the renderer saying that the
+  // renderer is done with a cache id.
+
  private:
+  typedef int32_t CacheID;  // TODO(jkarlin): Bump to 64 bit.

[michaeln, 2014/09/09 20:04:58]

Up till now cacheID uniquely identified a particular cache for an origin (modulo
browser restarts). With this change, cacheID now identifies an instance of a
scoped_refptr<> to a cache, so two different invocations on
OnCacheStorageGet('fred') will return two different ids. In other places we use
the term 'handle' for this sort of indirection.

Does this change matter to the client-side logic? Seems like it would? It can be
made to work either way, but I think stable cacheids would help, otherwise
maintaining a single client-side cache for a given swcache will be more
difficult.

If the indirection sticks, not sure it makes sense to bump to int64, and working
'handle' into the name might be good.

If the indirection doesn't stick and 'ids' identify caches, maybe SWCache can
have an id data member.

[jkarlin, 2014/09/10 15:06:13]

Nice catch.  Fixed.  CacheListener now only stores 1 reference to the
ServiceWorkerCache because the renderer is only going to call drop once, when
it's done with all references to the cacheid.

On 2014/09/09 20:04:58, michaeln wrote:

+  typedef std::map<CacheID, scoped_refptr<ServiceWorkerCache> > IDToCacheMap;
+
   void Send(const IPC::Message& message);
 
   void OnCacheStorageGetCallback(
       int request_id,
-      int cache_id,
+      const scoped_refptr<ServiceWorkerCache>& cache,
       ServiceWorkerCacheStorage::CacheStorageError error);
   void OnCacheStorageHasCallback(
       int request_id,
@@ -48,7 +54,7 @@ class ServiceWorkerCacheListener : public EmbeddedWorkerInstance::Listener {
       ServiceWorkerCacheStorage::CacheStorageError error);
   void OnCacheStorageCreateCallback(
       int request_id,
-      int cache_id,
+      const scoped_refptr<ServiceWorkerCache>& cache,
       ServiceWorkerCacheStorage::CacheStorageError error);
   void OnCacheStorageDeleteCallback(
       int request_id,
@@ -65,6 +71,9 @@ class ServiceWorkerCacheListener : public EmbeddedWorkerInstance::Listener {
   // The ServiceWorkerContextCore should always outlive this.
   base::WeakPtr<ServiceWorkerContextCore> context_;
 
+  IDToCacheMap cache_map_;
+  CacheID next_cache_id_;
+
   base::WeakPtrFactory<ServiceWorkerCacheListener> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerCacheListener);