Introducing the WebServiceWorkerCache.

public/platform/WebServiceWorkerCacheStorage.h

 // 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.
 
 #ifndef WebServiceWorkerCacheStorage_h
 #define WebServiceWorkerCacheStorage_h
 
 #include "WebCommon.h"
 #include "public/platform/WebCallbacks.h"
 #include "public/platform/WebServiceWorkerCacheError.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebVector.h"
 
 namespace blink {
 
 class WebServiceWorkerCache;
 
-// An interface to the CacheStorage API, implemented by the embedder and passed in to blink. Blink's implementation
+// An interface to the CacheStorage API, implemented by the embedder and passed in to Blink. Blink's implementation
 // of the ServiceWorker spec will call these methods to create/open caches, and expect callbacks from the embedder
 // after operations complete.
 class WebServiceWorkerCacheStorage {
 public:
     typedef WebCallbacks<void, WebServiceWorkerCacheError> CacheStorageCallbacks;
     typedef WebCallbacks<WebServiceWorkerCache, WebServiceWorkerCacheError> CacheStorageWithCacheCallbacks;
     typedef WebCallbacks<WebVector<WebString>, WebServiceWorkerCacheError> CacheStorageKeysCallbacks;
 
     virtual ~WebServiceWorkerCacheStorage() { }
 
-    // Ownership of the CacheStorage*Callbacks methods passes to the WebServiceWorkerCacheStorage
-    // instance, which will delete it after calling onSuccess or onFailure.
+    // Ownership of the CacheStorage*Callbacks methods passes to the WebServiceWorkerCacheStorage instance, which
+    // will delete it after calling onSuccess or onFailure.
+
+    // dispatchGet() or dispatchCreate() can return a WebServiceWorkerCache object, and these objects are owned by
+    // Blink, and should be destroyed when they are no longer needed. However, the implementation also will return
+    // the same WebServiceWorkerCache* object if the user opens the same Cache again.

[dominicc (has gone to gerrit), 2014/08/15 06:20:24]

This seems fraught; how is the ownership transferred from (random place in the
V8 heap, where a wrapper is holding onto the cache) to here if the same cache is
returned twice?

If any JavaScript runs, or in future Oilpan GC happens, we could be in trouble.

In fact, how do we *ever* release a Cache if the same object can be returned
again later?

[gavinp, 2014/08/19 21:09:37]

I think we spoke about this offline: if the blink Cache object is deleted, it
destroys its corresponding WebServiceWorkerCache object. We carefully insure
that one, and only one WebServiceWorkerCache object exists for every scope, so
this doesn't cause double deletes.

     virtual void dispatchGet(CacheStorageWithCacheCallbacks*, const WebString& cacheName) = 0;
     virtual void dispatchHas(CacheStorageCallbacks*, const WebString& cacheName) = 0;
     virtual void dispatchCreate(CacheStorageWithCacheCallbacks*, const WebString& cacheName) = 0;
     virtual void dispatchDelete(CacheStorageCallbacks*, const WebString& cacheName) = 0;
     virtual void dispatchKeys(CacheStorageKeysCallbacks*) = 0;
 };
 
 } // namespace blink
 
 #endif // WebServiceWorkerCacheStorage_h