Introducing the WebServiceWorkerCache.

Source/modules/serviceworkers/Cache.cpp

 // 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 "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 {
 
+WebServiceWorkerCache::QueryParams queryParamsFromDictionary(const Dictionary& dictionary)
+{
+    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);
+}
+
+ScriptPromise Cache::match(ScriptState* scriptState, Request* originalRequest, const Dictionary& queryParamsDict)
+{
+    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& queryParamsDict)
+{
+    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* originalRequest, const Dictionary& queryParamsDict)
+{
+    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& queryParamsDict)
+{
+    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* originalRequest)
+{
+    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)
+{
+    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* originalRequest, const Dictionary& queryParamsDict)
+{
+    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& queryParamsDict)
+{
+    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* originalRequest, const Response* response)
+{
+    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, const Response* response)
+{
+    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 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);
+}
+
+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();
-    resolver->reject(DOMException::create(NotSupportedError, "Cache is not implemented"));
+    m_webCache->dispatchMatch(new CacheMatchCallbacks(resolver), webRequest, queryParamsFromDictionary(queryParamsDict));
     return promise;
 }
 
-}
-
-Cache* Cache::fromWebServiceWorkerCache(WebServiceWorkerCache* webCache)
-{
-    return new Cache(webCache);
-}
-
-// FIXME: Implement these methods.
-ScriptPromise Cache::match(ScriptState* scriptState, Request* request, const Dictionary& queryParams)
-{
+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::match(ScriptState* scriptState, const String& requestString, const Dictionary& queryParams)
-{
+ScriptPromise Cache::addAllImpl(ScriptState* scriptState, Vector<Request*>)
+{
+    // FIXME: Implement this.
     return rejectAsNotImplemented(scriptState);
 }
 
-ScriptPromise Cache::matchAll(ScriptState* scriptState, Request* request, const Dictionary& queryParams)
-{
-    return rejectAsNotImplemented(scriptState);
-}
-
-ScriptPromise Cache::matchAll(ScriptState* scriptState, const String& requestString, const Dictionary& queryParams)
-{
-    return rejectAsNotImplemented(scriptState);
-}
-
-ScriptPromise Cache::add(ScriptState* scriptState, Request* request)
-{
-    return rejectAsNotImplemented(scriptState);
-}
-
-ScriptPromise Cache::add(ScriptState* scriptState, const String& requestString)
-{
-    return rejectAsNotImplemented(scriptState);
-}
-
-ScriptPromise Cache::addAll(ScriptState* scriptState, const Vector<ScriptValue>& rawRequests)
-{
-    return rejectAsNotImplemented(scriptState);
-}
-
-ScriptPromise Cache::deleteFunction(ScriptState* scriptState, Request* request, const Dictionary& queryParams)
-{
-    return rejectAsNotImplemented(scriptState);
-}
-
-ScriptPromise Cache::deleteFunction(ScriptState* scriptState, const String& requestString, const Dictionary& queryParams)
-{
-    return rejectAsNotImplemented(scriptState);
-}
-
-ScriptPromise Cache::put(ScriptState* scriptState, Request* request, Response*)
-{
-    return rejectAsNotImplemented(scriptState);
-}
-
-ScriptPromise Cache::put(ScriptState* scriptState, const String& requestString, Response*)
-{
-    return rejectAsNotImplemented(scriptState);
-}
-
-ScriptPromise Cache::keys(ScriptState* scriptState)
-{
-    return rejectAsNotImplemented(scriptState);
-}
-
-ScriptPromise Cache::keys(ScriptState* scriptState, Request* request, const Dictionary& queryParams)
-{
-    return rejectAsNotImplemented(scriptState);
-}
-
-ScriptPromise Cache::keys(ScriptState* scriptState, const String& requestString, const Dictionary& queryParams)
-{
-    return rejectAsNotImplemented(scriptState);
-}
-
 PassRefPtrWillBeRawPtr<DOMException> Cache::domExceptionForCacheError(WebServiceWorkerCacheError reason)
 {
     switch (reason) {
     case WebServiceWorkerCacheErrorNotImplemented:
         return DOMException::create(NotSupportedError, "Method is not implemented.");
     case WebServiceWorkerCacheErrorNotFound:
         return DOMException::create(NotFoundError, "Entry was not found.");
     case WebServiceWorkerCacheErrorExists:
         return DOMException::create(InvalidAccessError, "Entry already exists.");
     default:
         ASSERT_NOT_REACHED();
         return DOMException::create(NotSupportedError, "Unknown error.");
     }
 }
 
-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