projects / platform / framework / web / crosswalk.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Update To 11.40.268.0
[platform/framework/web/crosswalk.git] / src / third_party / WebKit / Source / modules / serviceworkers / Cache.cpp
diff --git a/src/third_party/WebKit/Source/modules/serviceworkers/Cache.cpp b/src/third_party/WebKit/Source/modules/serviceworkers/Cache.cpp
index 77595b8..9f63334 100644 (file)
--- a/src/third_party/WebKit/Source/modules/serviceworkers/Cache.cpp
+++ b/src/third_party/WebKit/Source/modules/serviceworkers/Cache.cpp
@@ -5,6 +5,7 @@
 #include "config.h"
 #include "modules/serviceworkers/Cache.h"
 
+#include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8ThrowException.h"
@@ -17,16 +18,14 @@ namespace blink {
 
 namespace {
 
-WebServiceWorkerCache::QueryParams toWebQueryParams(const QueryParams& queryParams)
+WebServiceWorkerCache::QueryParams toWebQueryParams(const CacheQueryOptions& options)
 {
     WebServiceWorkerCache::QueryParams webQueryParams;
-    // FIXME: The queryParams.hasXXXX() calls can be removed if defaults are
-    // added to the IDL. https://github.com/slightlyoff/ServiceWorker/issues/466
-    webQueryParams.ignoreSearch = queryParams.hasIgnoreSearch() && queryParams.ignoreSearch();
-    webQueryParams.ignoreMethod = queryParams.hasIgnoreMethod() && queryParams.ignoreMethod();
-    webQueryParams.ignoreVary = queryParams.hasIgnoreVary() && queryParams.ignoreVary();
-    webQueryParams.prefixMatch = queryParams.hasPrefixMatch() && queryParams.prefixMatch();
-    webQueryParams.cacheName = queryParams.cacheName();
+    webQueryParams.ignoreSearch = options.ignoreSearch();
+    webQueryParams.ignoreMethod = options.ignoreMethod();
+    webQueryParams.ignoreVary = options.ignoreVary();
+    webQueryParams.prefixMatch = options.prefixMatch();
+    webQueryParams.cacheName = options.cacheName();
     return webQueryParams;
 }
 
@@ -37,15 +36,18 @@ public:
     CacheMatchCallbacks(PassRefPtr<ScriptPromiseResolver> resolver)
         : m_resolver(resolver) { }
 
-    virtual void onSuccess(WebServiceWorkerResponse* webResponse) OVERRIDE
+    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
+    virtual void onError(WebServiceWorkerCacheError* reason) override
     {
-        m_resolver->reject(Cache::domExceptionForCacheError(*reason));
+        if (*reason == WebServiceWorkerCacheErrorNotFound)
+            m_resolver->resolve();
+        else
+            m_resolver->reject(Cache::domExceptionForCacheError(*reason));
         m_resolver.clear();
     }
 
@@ -60,7 +62,7 @@ public:
     CacheWithResponsesCallbacks(PassRefPtr<ScriptPromiseResolver> resolver)
         : m_resolver(resolver) { }
 
-    virtual void onSuccess(WebVector<WebServiceWorkerResponse>* webResponses) OVERRIDE
+    virtual void onSuccess(WebVector<WebServiceWorkerResponse>* webResponses) override
     {
         HeapVector<Member<Response> > responses;
         for (size_t i = 0; i < webResponses->size(); ++i)
@@ -69,12 +71,54 @@ public:
         m_resolver.clear();
     }
 
-    virtual void onError(WebServiceWorkerCacheError* reason) OVERRIDE
+    virtual void onError(WebServiceWorkerCacheError* reason) override
     {
         m_resolver->reject(Cache::domExceptionForCacheError(*reason));
         m_resolver.clear();
     }
 
+protected:
+    RefPtr<ScriptPromiseResolver> m_resolver;
+};
+
+// FIXME: Consider using CallbackPromiseAdapter.
+class CacheAddOrPutCallbacks : public CacheWithResponsesCallbacks {
+    WTF_MAKE_NONCOPYABLE(CacheAddOrPutCallbacks);
+public:
+    CacheAddOrPutCallbacks(PassRefPtr<ScriptPromiseResolver> resolver)
+        : CacheWithResponsesCallbacks(resolver) { }
+
+    virtual void onSuccess(WebVector<WebServiceWorkerResponse>* webResponses) override
+    {
+        // FIXME: Since response is ignored, consider simplifying public API.
+        m_resolver->resolve();
+        m_resolver.clear();
+    }
+};
+
+// FIXME: Consider using CallbackPromiseAdapter.
+class CacheDeleteCallback : public WebServiceWorkerCache::CacheWithResponsesCallbacks {
+    WTF_MAKE_NONCOPYABLE(CacheDeleteCallback);
+public:
+    CacheDeleteCallback(PassRefPtr<ScriptPromiseResolver> resolver)
+        : m_resolver(resolver) { }
+
+    virtual void onSuccess(WebVector<WebServiceWorkerResponse>* webResponses) override
+    {
+        // FIXME: Since response is ignored, consider simplifying public API.
+        m_resolver->resolve(true);
+        m_resolver.clear();
+    }
+
+    virtual void onError(WebServiceWorkerCacheError* reason) override
+    {
+        if (*reason == WebServiceWorkerCacheErrorNotFound)
+            m_resolver->resolve(false);
+        else
+            m_resolver->reject(Cache::domExceptionForCacheError(*reason));
+        m_resolver.clear();
+    }
+
 private:
     RefPtr<ScriptPromiseResolver> m_resolver;
 };
@@ -86,7 +130,7 @@ public:
     CacheWithRequestsCallbacks(PassRefPtr<ScriptPromiseResolver> resolver)
         : m_resolver(resolver) { }
 
-    virtual void onSuccess(WebVector<WebServiceWorkerRequest>* webRequests) OVERRIDE
+    virtual void onSuccess(WebVector<WebServiceWorkerRequest>* webRequests) override
     {
         HeapVector<Member<Request> > requests;
         for (size_t i = 0; i < webRequests->size(); ++i)
@@ -95,7 +139,7 @@ public:
         m_resolver.clear();
     }
 
-    virtual void onError(WebServiceWorkerCacheError* reason) OVERRIDE
+    virtual void onError(WebServiceWorkerCacheError* reason) override
     {
         m_resolver->reject(Cache::domExceptionForCacheError(*reason));
         m_resolver.clear();
@@ -105,11 +149,6 @@ 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"));
@@ -122,69 +161,42 @@ Cache* Cache::create(WebServiceWorkerCache* webCache)
     return new Cache(webCache);
 }
 
-ScriptPromise Cache::match(ScriptState* scriptState, Request* originalRequest, const QueryParams& queryParams)
+ScriptPromise Cache::match(ScriptState* scriptState, Request* request, const CacheQueryOptions& options)
 {
-    TrackExceptionState exceptionState;
-    Request* request = Request::create(scriptState->executionContext(), originalRequest, exceptionState);
-    if (exceptionState.hadException()) {
-        // FIXME: We should throw the caught error.
-        return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
-    }
-    return matchImpl(scriptState, request, queryParams);
+    return matchImpl(scriptState, request, options);
 }
 
-ScriptPromise Cache::match(ScriptState* scriptState, const String& requestString, const QueryParams& queryParams)
+ScriptPromise Cache::match(ScriptState* scriptState, const String& requestString, const CacheQueryOptions& options, ExceptionState& exceptionState)
 {
-    TrackExceptionState exceptionState;
     Request* request = Request::create(scriptState->executionContext(), requestString, exceptionState);
-    if (exceptionState.hadException()) {
-        // FIXME: We should throw the caught error.
-        return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
-    }
-    return matchImpl(scriptState, request, queryParams);
+    if (exceptionState.hadException())
+        return ScriptPromise();
+    return matchImpl(scriptState, request, options);
 }
 
-ScriptPromise Cache::matchAll(ScriptState* scriptState, Request* originalRequest, const QueryParams& queryParams)
+ScriptPromise Cache::matchAll(ScriptState* scriptState, Request* request, const CacheQueryOptions& options)
 {
-    TrackExceptionState exceptionState;
-    Request* request = Request::create(scriptState->executionContext(), originalRequest, exceptionState);
-    if (exceptionState.hadException()) {
-        // FIXME: We should throw the caught error.
-        return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
-    }
-    return matchAllImpl(scriptState, request, queryParams);
+    return matchAllImpl(scriptState, request, options);
 }
 
-ScriptPromise Cache::matchAll(ScriptState* scriptState, const String& requestString, const QueryParams& queryParams)
+ScriptPromise Cache::matchAll(ScriptState* scriptState, const String& requestString, const CacheQueryOptions& options, ExceptionState& exceptionState)
 {
-    TrackExceptionState exceptionState;
     Request* request = Request::create(scriptState->executionContext(), requestString, exceptionState);
-    if (exceptionState.hadException()) {
-        // FIXME: We should throw the caught error.
-        return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
-    }
-    return matchAllImpl(scriptState, request, queryParams);
+    if (exceptionState.hadException())
+        return ScriptPromise();
+    return matchAllImpl(scriptState, request, options);
 }
 
-ScriptPromise Cache::add(ScriptState* scriptState, Request* originalRequest)
+ScriptPromise Cache::add(ScriptState* scriptState, Request* request)
 {
-    TrackExceptionState exceptionState;
-    Request* request = Request::create(scriptState->executionContext(), originalRequest, exceptionState);
-    if (exceptionState.hadException()) {
-        // FIXME: We should throw the caught error.
-        return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
-    }
     return addImpl(scriptState, request);
 }
 
-ScriptPromise Cache::add(ScriptState* scriptState, const String& requestString)
+ScriptPromise Cache::add(ScriptState* scriptState, const String& requestString, ExceptionState& exceptionState)
 {
-    TrackExceptionState exceptionState;
     Request* request = Request::create(scriptState->executionContext(), requestString, exceptionState);
-    if (exceptionState.hadException()) {
-        // FIXME: We should throw the caught error.
-        return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
-    }
+    if (exceptionState.hadException())
+        return ScriptPromise();
     return addImpl(scriptState, request);
 }
 
@@ -194,47 +206,29 @@ ScriptPromise Cache::addAll(ScriptState* scriptState, const Vector<ScriptValue>&
     return rejectAsNotImplemented(scriptState);
 }
 
-ScriptPromise Cache::deleteFunction(ScriptState* scriptState, Request* originalRequest, const QueryParams& queryParams)
+ScriptPromise Cache::deleteFunction(ScriptState* scriptState, Request* request, const CacheQueryOptions& options)
 {
-    TrackExceptionState exceptionState;
-    Request* request = Request::create(scriptState->executionContext(), originalRequest, exceptionState);
-    if (exceptionState.hadException()) {
-        // FIXME: We should throw the caught error.
-        return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
-    }
-    return deleteImpl(scriptState, request, queryParams);
+    return deleteImpl(scriptState, request, options);
 }
 
-ScriptPromise Cache::deleteFunction(ScriptState* scriptState, const String& requestString, const QueryParams& queryParams)
+ScriptPromise Cache::deleteFunction(ScriptState* scriptState, const String& requestString, const CacheQueryOptions& options, ExceptionState& exceptionState)
 {
-    TrackExceptionState exceptionState;
     Request* request = Request::create(scriptState->executionContext(), requestString, exceptionState);
-    if (exceptionState.hadException()) {
-        // FIXME: We should throw the caught error.
-        return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
-    }
-    return deleteImpl(scriptState, request, queryParams);
+    if (exceptionState.hadException())
+        return ScriptPromise();
+    return deleteImpl(scriptState, request, options);
 }
 
-ScriptPromise Cache::put(ScriptState* scriptState, Request* originalRequest, Response* response)
+ScriptPromise Cache::put(ScriptState* scriptState, Request* request, Response* response)
 {
-    TrackExceptionState exceptionState;
-    Request* request = Request::create(scriptState->executionContext(), originalRequest, exceptionState);
-    if (exceptionState.hadException()) {
-        // FIXME: We should throw the caught error.
-        return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
-    }
     return putImpl(scriptState, request, response);
 }
 
-ScriptPromise Cache::put(ScriptState* scriptState, const String& requestString, Response* response)
+ScriptPromise Cache::put(ScriptState* scriptState, const String& requestString, Response* response, ExceptionState& exceptionState)
 {
-    TrackExceptionState exceptionState;
     Request* request = Request::create(scriptState->executionContext(), requestString, exceptionState);
-    if (exceptionState.hadException()) {
-        // FIXME: We should throw the caught error.
-        return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
-    }
+    if (exceptionState.hadException())
+        return ScriptPromise();
     return putImpl(scriptState, request, response);
 }
 
@@ -243,60 +237,51 @@ ScriptPromise Cache::keys(ScriptState* scriptState)
     return keysImpl(scriptState);
 }
 
-ScriptPromise Cache::keys(ScriptState* scriptState, Request* originalRequest, const QueryParams& queryParams)
+ScriptPromise Cache::keys(ScriptState* scriptState, Request* request, const CacheQueryOptions& options)
 {
-    TrackExceptionState exceptionState;
-    Request* request = Request::create(scriptState->executionContext(), originalRequest, exceptionState);
-    if (exceptionState.hadException()) {
-        // FIXME: We should throw the caught error.
-        return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
-    }
-    return keysImpl(scriptState, request, queryParams);
+    return keysImpl(scriptState, request, options);
 }
 
-ScriptPromise Cache::keys(ScriptState* scriptState, const String& requestString, const QueryParams& queryParams)
+ScriptPromise Cache::keys(ScriptState* scriptState, const String& requestString, const CacheQueryOptions& options, ExceptionState& exceptionState)
 {
-    TrackExceptionState exceptionState;
     Request* request = Request::create(scriptState->executionContext(), requestString, exceptionState);
-    if (exceptionState.hadException()) {
-        // FIXME: We should throw the caught error.
-        return rejectForCacheError(scriptState, WebServiceWorkerCacheErrorNotFound);
-    }
-    return keysImpl(scriptState, request, queryParams);
+    if (exceptionState.hadException())
+        return ScriptPromise();
+    return keysImpl(scriptState, request, options);
 }
 
 Cache::Cache(WebServiceWorkerCache* webCache)
     : m_webCache(adoptPtr(webCache)) { }
 
-ScriptPromise Cache::matchImpl(ScriptState* scriptState, Request* request, const QueryParams& queryParams)
+ScriptPromise Cache::matchImpl(ScriptState* scriptState, const Request* request, const CacheQueryOptions& options)
 {
     WebServiceWorkerRequest webRequest;
     request->populateWebServiceWorkerRequest(webRequest);
 
     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
-    m_webCache->dispatchMatch(new CacheMatchCallbacks(resolver), webRequest, toWebQueryParams(queryParams));
+    m_webCache->dispatchMatch(new CacheMatchCallbacks(resolver), webRequest, toWebQueryParams(options));
     return promise;
 }
 
-ScriptPromise Cache::matchAllImpl(ScriptState* scriptState, Request* request, const QueryParams& queryParams)
+ScriptPromise Cache::matchAllImpl(ScriptState* scriptState, const Request* request, const CacheQueryOptions& options)
 {
     WebServiceWorkerRequest webRequest;
     request->populateWebServiceWorkerRequest(webRequest);
 
     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
-    m_webCache->dispatchMatchAll(new CacheWithResponsesCallbacks(resolver), webRequest, toWebQueryParams(queryParams));
+    m_webCache->dispatchMatchAll(new CacheWithResponsesCallbacks(resolver), webRequest, toWebQueryParams(options));
     return promise;
 }
 
-ScriptPromise Cache::addImpl(ScriptState* scriptState, Request*)
+ScriptPromise Cache::addImpl(ScriptState* scriptState, const Request*)
 {
     // FIXME: Implement this.
     return rejectAsNotImplemented(scriptState);
 }
 
-ScriptPromise Cache::addAllImpl(ScriptState* scriptState, Vector<Request*>)
+ScriptPromise Cache::addAllImpl(ScriptState* scriptState, const Vector<const Request*>)
 {
     // FIXME: Implement this.
     return rejectAsNotImplemented(scriptState);
@@ -317,21 +302,36 @@ PassRefPtrWillBeRawPtr<DOMException> Cache::domExceptionForCacheError(WebService
     }
 }
 
-ScriptPromise Cache::deleteImpl(ScriptState* scriptState, Request* request, const QueryParams& queryParams)
+ScriptPromise Cache::deleteImpl(ScriptState* scriptState, const Request* request, const CacheQueryOptions& options)
 {
     WebVector<WebServiceWorkerCache::BatchOperation> batchOperations(size_t(1));
     batchOperations[0].operationType = WebServiceWorkerCache::OperationTypeDelete;
     request->populateWebServiceWorkerRequest(batchOperations[0].request);
-    batchOperations[0].matchParams = toWebQueryParams(queryParams);
+    batchOperations[0].matchParams = toWebQueryParams(options);
 
     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
-    m_webCache->dispatchBatch(new CacheWithResponsesCallbacks(resolver), batchOperations);
+    m_webCache->dispatchBatch(new CacheDeleteCallback(resolver), batchOperations);
     return promise;
 }
 
 ScriptPromise Cache::putImpl(ScriptState* scriptState, Request* request, Response* response)
 {
+    KURL url(KURL(), request->url());
+    if (!url.protocolIsInHTTPFamily())
+        return ScriptPromise::reject(scriptState, V8ThrowException::createTypeError(scriptState->isolate(), "Request scheme '" + url.protocol() + "' is unsupported"));
+    if (request->method() != "GET")
+        return ScriptPromise::reject(scriptState, V8ThrowException::createTypeError(scriptState->isolate(), "Request method '" + request->method() + "' is unsupported"));
+    if (request->hasBody() && request->bodyUsed())
+        return ScriptPromise::reject(scriptState, V8ThrowException::createTypeError(scriptState->isolate(), "Request body is already used"));
+    if (response->hasBody() && response->bodyUsed())
+        return ScriptPromise::reject(scriptState, V8ThrowException::createTypeError(scriptState->isolate(), "Response body is already used"));
+
+    if (request->hasBody())
+        request->setBodyUsed();
+    if (response->hasBody())
+        response->setBodyUsed();
+
     WebVector<WebServiceWorkerCache::BatchOperation> batchOperations(size_t(1));
     batchOperations[0].operationType = WebServiceWorkerCache::OperationTypePut;
     request->populateWebServiceWorkerRequest(batchOperations[0].request);
@@ -339,7 +339,7 @@ ScriptPromise Cache::putImpl(ScriptState* scriptState, Request* request, Respons
 
     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
-    m_webCache->dispatchBatch(new CacheWithResponsesCallbacks(resolver), batchOperations);
+    m_webCache->dispatchBatch(new CacheAddOrPutCallbacks(resolver), batchOperations);
     return promise;
 }
 
@@ -351,14 +351,14 @@ ScriptPromise Cache::keysImpl(ScriptState* scriptState)
     return promise;
 }
 
-ScriptPromise Cache::keysImpl(ScriptState* scriptState, Request* request, const QueryParams& queryParams)
+ScriptPromise Cache::keysImpl(ScriptState* scriptState, const Request* request, const CacheQueryOptions& options)
 {
     WebServiceWorkerRequest webRequest;
     request->populateWebServiceWorkerRequest(webRequest);
 
     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
-    m_webCache->dispatchKeys(new CacheWithRequestsCallbacks(resolver), 0, toWebQueryParams(queryParams));
+    m_webCache->dispatchKeys(new CacheWithRequestsCallbacks(resolver), 0, toWebQueryParams(options));
     return promise;
 }
 
Domain: Web Framework / Uncategorized;