Introducing the WebServiceWorkerCache.

Source/modules/serviceworkers/Cache.cpp

Index: Source/modules/serviceworkers/Cache.cpp
diff --git a/Source/modules/serviceworkers/Cache.cpp b/Source/modules/serviceworkers/Cache.cpp
index b6609c63677ce3d83f96eba24a7965c4db9e2c76..7cf8e7a18f6b98beb5a9c726ebcbdeb8155b82d1 100644
--- a/Source/modules/serviceworkers/Cache.cpp
+++ b/Source/modules/serviceworkers/Cache.cpp
@@ -5,96 +5,287 @@
 #include "config.h"
 #include "modules/serviceworkers/Cache.h"
 
+#include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
+#include "bindings/core/v8/V8ThrowException.h"
+#include "core/dom/DOMException.h"
+#include "modules/serviceworkers/Request.h"
+#include "modules/serviceworkers/Response.h"
+#include "public/platform/WebServiceWorkerCache.h"
 
 namespace blink {
 
 namespace {
 
-ScriptPromise rejectAsNotImplemented(ScriptState* scriptState)
+WebServiceWorkerCache::QueryParams queryParamsFromDictionary(const Dictionary& dictionary)
 {
-    RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
-    const ScriptPromise promise = resolver->promise();
-    resolver->reject(DOMException::create(NotSupportedError, "Cache is not implemented"));
-    return promise;
+    WebServiceWorkerCache::QueryParams queryParams;
+    DictionaryHelper::get(dictionary, "ignoreSearch", queryParams.ignoreSearch);
+    DictionaryHelper::get(dictionary, "ignoreMethod", queryParams.ignoreMethod);
+    DictionaryHelper::get(dictionary, "ignoreVary", queryParams.ignoreVary);
+    DictionaryHelper::get(dictionary, "prefixMatch", queryParams.prefixMatch);
+    {
+        String cacheName;
+        DictionaryHelper::get(dictionary, "cacheName", cacheName);
+        queryParams.cacheName = cacheName;
+    }
+    return queryParams;
+}
+
+class CacheMatchCallbacks : public WebServiceWorkerCache::CacheMatchCallbacks {
+    WTF_MAKE_NONCOPYABLE(CacheMatchCallbacks);
+public:
+    CacheMatchCallbacks(PassRefPtr<ScriptPromiseResolver> resolver)
+        : m_resolver(resolver) { }
+
+    virtual void onSuccess(WebServiceWorkerResponse* webResponse) OVERRIDE
+    {
+        m_resolver->resolve(Response::create(m_resolver->scriptState()->executionContext(), *webResponse));
+        m_resolver.clear();
+    }
+
+    virtual void onError(WebServiceWorkerCacheError* reason) OVERRIDE
+    {
+        m_resolver->reject(Cache::domExceptionForCacheError(*reason));
+        m_resolver.clear();
+    }
+
+private:
+    RefPtr<ScriptPromiseResolver> m_resolver;
+};
+
+class CacheWithResponsesCallbacks : public WebServiceWorkerCache::CacheWithResponsesCallbacks {
+    WTF_MAKE_NONCOPYABLE(CacheWithResponsesCallbacks);
+public:
+    CacheWithResponsesCallbacks(PassRefPtr<ScriptPromiseResolver> resolver)
+        : m_resolver(resolver) { }
+
+    virtual void onSuccess(WebVector<WebServiceWorkerResponse>* webResponses) OVERRIDE
+    {
+        Vector<Response*> responses;
+        for (size_t i = 0; i < webResponses->size(); ++i)
+            responses.append(Response::create(m_resolver->scriptState()->executionContext(), (*webResponses)[i]));
+        m_resolver->resolve(responses);
+        m_resolver.clear();
+    }
+
+    virtual void onError(WebServiceWorkerCacheError* reason) OVERRIDE
+    {
+        m_resolver->reject(Cache::domExceptionForCacheError(*reason));
+        m_resolver.clear();
+    }
+
+private:
+    RefPtr<ScriptPromiseResolver> m_resolver;
+};
+
+class CacheWithRequestsCallbacks : public WebServiceWorkerCache::CacheWithRequestsCallbacks {
+    WTF_MAKE_NONCOPYABLE(CacheWithRequestsCallbacks);
+public:
+    CacheWithRequestsCallbacks(PassRefPtr<ScriptPromiseResolver> resolver)
+        : m_resolver(resolver) { }
+
+    virtual void onSuccess(WebVector<WebServiceWorkerRequest>* webRequests) OVERRIDE
+    {
+        Vector<Request*> requests;
+        for (size_t i = 0; i < webRequests->size(); ++i)
+            requests.append(Request::create(m_resolver->scriptState()->executionContext(), (*webRequests)[i]));
+        m_resolver->resolve(requests);
+        m_resolver.clear();
+    }
+
+    virtual void onError(WebServiceWorkerCacheError* reason) OVERRIDE
+    {
+        m_resolver->reject(Cache::domExceptionForCacheError(*reason));
+        m_resolver.clear();
+    }
+
+private:
+    RefPtr<ScriptPromiseResolver> m_resolver;
+};
+
+ScriptPromise rejectForCacheError(ScriptState* scriptState, WebServiceWorkerCacheError error)
+{
+    return ScriptPromise::rejectWithDOMException(scriptState, Cache::domExceptionForCacheError(error));
 }
 
+ScriptPromise rejectAsNotImplemented(ScriptState* scriptState)
+{
+    return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError, "Cache is not implemented"));
 }
 
+} // namespace
+
 Cache* Cache::fromWebServiceWorkerCache(WebServiceWorkerCache* webCache)
 {
+    if (Cache* cache = static_cast<Cache*>(webCache->proxyInterface()))
+        return cache;
     return new Cache(webCache);
 }
 
-// FIXME: Implement these methods.
-ScriptPromise Cache::match(ScriptState* scriptState, Request* request, const Dictionary& queryParams)
+ScriptPromise Cache::match(ScriptState* scriptState, Request* originalRequest, const Dictionary& queryParamsDict)
 {
-    return rejectAsNotImplemented(scriptState);
+    TrackExceptionState exceptionState;
+    Request* request = Request::create(scriptState->executionContext(), originalRequest, exceptionState);

[dominicc (has gone to gerrit), 2014/09/17 12:53:58]

Why does this one have this V8 exception stuff here? Why does this exception map
to "not found"? This part is a bit mysterious to me.

[gavinp, 2014/09/17 15:41:52]

These should be rethrown. NotFound is arbitrary; it's sort of unfortunate that
we don't have a good way to extract an exception from TrackExceptionState to
easily reject the promise with it.

The spec is a bit convoluted about how it talks about rethrowing exceptions; in
many cases it's explicitly addressed, in others it's implicit in that code for a
promise that throws is supposed to reject with that promise. I could add, to
each method, a comment from the spec (the Fetch code does that), but it would
get pretty strange on methods like Cache::add() where the rule comes
transitively from the fetch.

We need to figure out how to get exceptions out of our trackers, or in the
alternative, let the promise be an exception tracker of some kind?

I have added a FIXME at each of these sites briefly saying what we should do.

[jsbell, 2014/09/18 21:45:00]

The alternate approach I suggested back in #c15 - let the bindings code
automatically map exceptions to rejections - would take care of this for you.

See https://codereview.chromium.org/521513002 for a VERY old delta CL showing
how that'd look.

Agreed that we can live with the FIXMEs for now.

+    if (exceptionState.hadException())
+        return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
+    return matchImpl(scriptState, request, queryParamsDict);
 }
 
-ScriptPromise Cache::match(ScriptState* scriptState, const String& requestString, const Dictionary& queryParams)
+ScriptPromise Cache::match(ScriptState* scriptState, const String& requestString, const Dictionary& queryParamsDict)
 {
-    return rejectAsNotImplemented(scriptState);
+    TrackExceptionState exceptionState;
+    Request* request = Request::create(scriptState->executionContext(), requestString, exceptionState);
+    if (exceptionState.hadException())
+        return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
+    return matchImpl(scriptState, request, queryParamsDict);
 }
 
-ScriptPromise Cache::matchAll(ScriptState* scriptState, Request* request, const Dictionary& queryParams)
+ScriptPromise Cache::matchAll(ScriptState* scriptState, Request* originalRequest, const Dictionary& queryParamsDict)
 {
-    return rejectAsNotImplemented(scriptState);
+    TrackExceptionState exceptionState;
+    Request* request = Request::create(scriptState->executionContext(), originalRequest, exceptionState);
+    if (exceptionState.hadException())
+        return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
+    return matchAllImpl(scriptState, request, queryParamsDict);
 }
 
-ScriptPromise Cache::matchAll(ScriptState* scriptState, const String& requestString, const Dictionary& queryParams)
+ScriptPromise Cache::matchAll(ScriptState* scriptState, const String& requestString, const Dictionary& queryParamsDict)
 {
-    return rejectAsNotImplemented(scriptState);
+    TrackExceptionState exceptionState;
+    Request* request = Request::create(scriptState->executionContext(), requestString, exceptionState);
+    if (exceptionState.hadException())
+        return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
+    return matchAllImpl(scriptState, request, queryParamsDict);
 }
 
-ScriptPromise Cache::add(ScriptState* scriptState, Request* request)
+ScriptPromise Cache::add(ScriptState* scriptState, Request* originalRequest)
 {
-    return rejectAsNotImplemented(scriptState);
+    TrackExceptionState exceptionState;
+    Request* request = Request::create(scriptState->executionContext(), originalRequest, exceptionState);
+    if (exceptionState.hadException())
+        return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
+    return addImpl(scriptState, request);
 }
 
 ScriptPromise Cache::add(ScriptState* scriptState, const String& requestString)
 {
-    return rejectAsNotImplemented(scriptState);
+    TrackExceptionState exceptionState;
+    Request* request = Request::create(scriptState->executionContext(), requestString, exceptionState);
+    if (exceptionState.hadException())
+        return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
+    return addImpl(scriptState, request);
 }
 
 ScriptPromise Cache::addAll(ScriptState* scriptState, const Vector<ScriptValue>& rawRequests)
 {
+    // FIXME: Implement this.
     return rejectAsNotImplemented(scriptState);
 }
 
-ScriptPromise Cache::deleteFunction(ScriptState* scriptState, Request* request, const Dictionary& queryParams)
+ScriptPromise Cache::deleteFunction(ScriptState* scriptState, Request* originalRequest, const Dictionary& queryParamsDict)
 {
-    return rejectAsNotImplemented(scriptState);
+    TrackExceptionState exceptionState;
+    Request* request = Request::create(scriptState->executionContext(), originalRequest, exceptionState);
+    if (exceptionState.hadException())
+        return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
+    return deleteImpl(scriptState, request, queryParamsDict);
 }
 
-ScriptPromise Cache::deleteFunction(ScriptState* scriptState, const String& requestString, const Dictionary& queryParams)
+ScriptPromise Cache::deleteFunction(ScriptState* scriptState, const String& requestString, const Dictionary& queryParamsDict)
 {
-    return rejectAsNotImplemented(scriptState);
+    TrackExceptionState exceptionState;
+    Request* request = Request::create(scriptState->executionContext(), requestString, exceptionState);
+    if (exceptionState.hadException())
+        return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
+    return deleteImpl(scriptState, request, queryParamsDict);
 }
 
-ScriptPromise Cache::put(ScriptState* scriptState, Request* request, Response*)
+ScriptPromise Cache::put(ScriptState* scriptState, Request* originalRequest, const Response* response)
 {
-    return rejectAsNotImplemented(scriptState);
+    TrackExceptionState exceptionState;
+    Request* request = Request::create(scriptState->executionContext(), originalRequest, exceptionState);
+    if (exceptionState.hadException())
+        return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
+    return putImpl(scriptState, request, response);
 }
 
-ScriptPromise Cache::put(ScriptState* scriptState, const String& requestString, Response*)
+ScriptPromise Cache::put(ScriptState* scriptState, const String& requestString, const Response* response)
 {
-    return rejectAsNotImplemented(scriptState);
+    TrackExceptionState exceptionState;
+    Request* request = Request::create(scriptState->executionContext(), requestString, exceptionState);
+    if (exceptionState.hadException())
+        return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
+    return putImpl(scriptState, request, response);
 }
 
 ScriptPromise Cache::keys(ScriptState* scriptState)
 {
-    return rejectAsNotImplemented(scriptState);
+    return keysImpl(scriptState);
+}
+
+ScriptPromise Cache::keys(ScriptState* scriptState, Request* originalRequest, const Dictionary& queryParamsDict)
+{
+    TrackExceptionState exceptionState;
+    Request* request = Request::create(scriptState->executionContext(), originalRequest, exceptionState);
+    if (exceptionState.hadException())
+        return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
+    return keysImpl(scriptState, request, queryParamsDict);
+}
+
+ScriptPromise Cache::keys(ScriptState* scriptState, const String& requestString, const Dictionary& queryParamsDict)
+{
+    TrackExceptionState exceptionState;
+    Request* request = Request::create(scriptState->executionContext(), requestString, exceptionState);
+    if (exceptionState.hadException())
+        return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
+    return keysImpl(scriptState, request, queryParamsDict);
 }
 
-ScriptPromise Cache::keys(ScriptState* scriptState, Request* request, const Dictionary& queryParams)
+Cache::Cache(WebServiceWorkerCache* webCache)
+    : m_webCache(adoptPtr(webCache))
 {
+    ASSERT(!m_webCache->proxyInterface());
+    m_webCache->setProxyInterface(this);
+}
+
+Cache* Cache::create(WebServiceWorkerCache* webCache)
+{
+    return new Cache(webCache);
+}
+
+ScriptPromise Cache::matchImpl(ScriptState* scriptState, Request* request, const Dictionary& queryParamsDict)
+{
+    WebServiceWorkerRequest webRequest;
+    request->populateWebServiceWorkerRequest(webRequest);
+
+    RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    const ScriptPromise promise = resolver->promise();
+    m_webCache->dispatchMatch(new CacheMatchCallbacks(resolver), webRequest, queryParamsFromDictionary(queryParamsDict));
+    return promise;
+}
+
+ScriptPromise Cache::matchAllImpl(ScriptState* scriptState, Request* request, const Dictionary& queryParamsDict)
+{
+    WebServiceWorkerRequest webRequest;
+    request->populateWebServiceWorkerRequest(webRequest);
+
+    RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    const ScriptPromise promise = resolver->promise();
+    m_webCache->dispatchMatchAll(new CacheWithResponsesCallbacks(resolver), webRequest, queryParamsFromDictionary(queryParamsDict));
+    return promise;
+}
+
+ScriptPromise Cache::addImpl(ScriptState* scriptState, Request*)
+{
+    // FIXME: Implement this.
     return rejectAsNotImplemented(scriptState);
 }
 
-ScriptPromise Cache::keys(ScriptState* scriptState, const String& requestString, const Dictionary& queryParams)
+ScriptPromise Cache::addAllImpl(ScriptState* scriptState, Vector<Request*>)
 {
+    // FIXME: Implement this.
     return rejectAsNotImplemented(scriptState);
 }
 
@@ -113,8 +304,49 @@ PassRefPtrWillBeRawPtr<DOMException> Cache::domExceptionForCacheError(WebService
     }
 }
 
-Cache::Cache(WebServiceWorkerCache* webCache) : m_webCache(webCache)
+ScriptPromise Cache::deleteImpl(ScriptState* scriptState, Request* request, const Dictionary& queryParamsDict)
 {
+    WebVector<WebServiceWorkerCache::BatchOperation> batchOperations(size_t(1));
+    batchOperations[0].operationType = WebServiceWorkerCache::WebServiceWorkerCacheOperationTypeDelete;
+    request->populateWebServiceWorkerRequest(batchOperations[0].request);
+    batchOperations[0].matchParams = queryParamsFromDictionary(queryParamsDict);
+
+    RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    const ScriptPromise promise = resolver->promise();
+    m_webCache->dispatchBatch(new CacheWithResponsesCallbacks(resolver), batchOperations);
+    return promise;
+}
+
+ScriptPromise Cache::putImpl(ScriptState* scriptState, Request* request, const Response* response)
+{
+    WebVector<WebServiceWorkerCache::BatchOperation> batchOperations(size_t(1));
+    batchOperations[0].operationType = WebServiceWorkerCache::WebServiceWorkerCacheOperationTypePut;
+    request->populateWebServiceWorkerRequest(batchOperations[0].request);
+    response->populateWebServiceWorkerResponse(batchOperations[0].response);
+
+    RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    const ScriptPromise promise = resolver->promise();
+    m_webCache->dispatchBatch(new CacheWithResponsesCallbacks(resolver), batchOperations);
+    return promise;
+}
+
+ScriptPromise Cache::keysImpl(ScriptState* scriptState)
+{
+    RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    const ScriptPromise promise = resolver->promise();
+    m_webCache->dispatchKeys(new CacheWithRequestsCallbacks(resolver), 0, WebServiceWorkerCache::QueryParams());
+    return promise;
+}
+
+ScriptPromise Cache::keysImpl(ScriptState* scriptState, Request* request, const Dictionary& queryParamsDict)
+{
+    WebServiceWorkerRequest webRequest;
+    request->populateWebServiceWorkerRequest(webRequest);
+
+    RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    const ScriptPromise promise = resolver->promise();
+    m_webCache->dispatchKeys(new CacheWithRequestsCallbacks(resolver), 0, queryParamsFromDictionary(queryParamsDict));
+    return promise;
 }
 
 } // namespace blink