Service Worker Cache: Simplify exception/rejection processing

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/ExceptionState.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 {
 
@@ skipping 123 matching lines @@
     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::create(WebServiceWorkerCache* webCache)
 {
     return new Cache(webCache);
 }
 
 ScriptPromise Cache::match(ScriptState* scriptState, Request* request, const CacheQueryOptions& options)
 {
     return matchImpl(scriptState, request, options);
 }
 
-ScriptPromise Cache::match(ScriptState* scriptState, const String& requestString, const CacheQueryOptions& options)
+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);
-    }
+    if (exceptionState.hadException())
+        return ScriptPromise();
     return matchImpl(scriptState, request, options);
 }
 
 ScriptPromise Cache::matchAll(ScriptState* scriptState, Request* request, const CacheQueryOptions& options)
 {
     return matchAllImpl(scriptState, request, options);
 }
 
-ScriptPromise Cache::matchAll(ScriptState* scriptState, const String& requestString, const CacheQueryOptions& options)
+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);
-    }
+    if (exceptionState.hadException())
+        return ScriptPromise();
     return matchAllImpl(scriptState, request, options);
 }
 
 ScriptPromise Cache::add(ScriptState* scriptState, Request* request)
 {
     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);
 }
 
 ScriptPromise Cache::addAll(ScriptState* scriptState, const Vector<ScriptValue>& rawRequests)
 {
     // FIXME: Implement this.
     return rejectAsNotImplemented(scriptState);
 }
 
 ScriptPromise Cache::deleteFunction(ScriptState* scriptState, Request* request, const CacheQueryOptions& options)
 {
     return deleteImpl(scriptState, request, options);
 }
 
-ScriptPromise Cache::deleteFunction(ScriptState* scriptState, const String& requestString, const CacheQueryOptions& options)
+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);
-    }
+    if (exceptionState.hadException())
+        return ScriptPromise();
     return deleteImpl(scriptState, request, options);
 }
 
 ScriptPromise Cache::put(ScriptState* scriptState, Request* request, Response* response)
 {
     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);
 }
 
 ScriptPromise Cache::keys(ScriptState* scriptState)
 {
     return keysImpl(scriptState);
 }
 
 ScriptPromise Cache::keys(ScriptState* scriptState, Request* request, const CacheQueryOptions& options)
 {
     return keysImpl(scriptState, request, options);
 }
 
-ScriptPromise Cache::keys(ScriptState* scriptState, const String& requestString, const CacheQueryOptions& options)
+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);
-    }
+    if (exceptionState.hadException())
+        return ScriptPromise();
     return keysImpl(scriptState, request, options);
 }
 
 Cache::Cache(WebServiceWorkerCache* webCache)
     : m_webCache(adoptPtr(webCache)) { }
 
 ScriptPromise Cache::matchImpl(ScriptState* scriptState, const Request* request, const CacheQueryOptions& options)
 {
     WebServiceWorkerRequest webRequest;
     request->populateWebServiceWorkerRequest(webRequest);
@@ skipping 87 matching lines @@
     WebServiceWorkerRequest webRequest;
     request->populateWebServiceWorkerRequest(webRequest);
 
     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
     m_webCache->dispatchKeys(new CacheWithRequestsCallbacks(resolver), 0, toWebQueryParams(options));
     return promise;
 }
 
 } // namespace blink