Move Cache Storage API implementation to modules/cachestorage

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
deleted file mode 100644
index 0bf4c5361d2a24723e93ff39f58177fce918f911..0000000000000000000000000000000000000000
--- a/Source/modules/serviceworkers/Cache.cpp
+++ /dev/null
@@ -1,414 +0,0 @@
-// 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/fetch/BodyStreamBuffer.h"
-#include "modules/fetch/Request.h"
-#include "modules/fetch/Response.h"
-#include "public/platform/WebServiceWorkerCache.h"
-
-namespace blink {
-
-namespace {
-
-// FIXME: Consider using CallbackPromiseAdapter.
-class CacheMatchCallbacks : public WebServiceWorkerCache::CacheMatchCallbacks {
-    WTF_MAKE_NONCOPYABLE(CacheMatchCallbacks);
-public:
-    CacheMatchCallbacks(PassRefPtrWillBeRawPtr<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
-    {
-        if (*reason == WebServiceWorkerCacheErrorNotFound)
-            m_resolver->resolve();
-        else
-            m_resolver->reject(Cache::domExceptionForCacheError(*reason));
-        m_resolver.clear();
-    }
-
-private:
-    RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver;
-};
-
-// FIXME: Consider using CallbackPromiseAdapter.
-class CacheWithResponsesCallbacks : public WebServiceWorkerCache::CacheWithResponsesCallbacks {
-    WTF_MAKE_NONCOPYABLE(CacheWithResponsesCallbacks);
-public:
-    CacheWithResponsesCallbacks(PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver)
-        : m_resolver(resolver) { }
-
-    virtual void onSuccess(WebVector<WebServiceWorkerResponse>* webResponses) override
-    {
-        HeapVector<Member<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();
-    }
-
-protected:
-    RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver;
-};
-
-// FIXME: Consider using CallbackPromiseAdapter.
-class CacheAddOrPutCallbacks : public CacheWithResponsesCallbacks {
-    WTF_MAKE_NONCOPYABLE(CacheAddOrPutCallbacks);
-public:
-    CacheAddOrPutCallbacks(PassRefPtrWillBeRawPtr<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(PassRefPtrWillBeRawPtr<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:
-    RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver;
-};
-
-// FIXME: Consider using CallbackPromiseAdapter.
-class CacheWithRequestsCallbacks : public WebServiceWorkerCache::CacheWithRequestsCallbacks {
-    WTF_MAKE_NONCOPYABLE(CacheWithRequestsCallbacks);
-public:
-    CacheWithRequestsCallbacks(PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver)
-        : m_resolver(resolver) { }
-
-    virtual void onSuccess(WebVector<WebServiceWorkerRequest>* webRequests) override
-    {
-        HeapVector<Member<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:
-    RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver;
-};
-
-ScriptPromise rejectAsNotImplemented(ScriptState* scriptState)
-{
-    return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError, "Cache is not implemented"));
-}
-
-} // namespace
-
-class Cache::AsyncPutBatch final : public BodyStreamBuffer::BlobHandleCreatorClient {
-public:
-    AsyncPutBatch(PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver, Cache* cache, Request* request, Response* response)
-        : m_resolver(resolver)
-        , m_cache(cache)
-    {
-        request->populateWebServiceWorkerRequest(m_webRequest);
-        response->populateWebServiceWorkerResponse(m_webResponse);
-    }
-    ~AsyncPutBatch() override { }
-    void didCreateBlobHandle(PassRefPtr<BlobDataHandle> handle) override
-    {
-        WebVector<WebServiceWorkerCache::BatchOperation> batchOperations(size_t(1));
-        batchOperations[0].operationType = WebServiceWorkerCache::OperationTypePut;
-        batchOperations[0].request = m_webRequest;
-        batchOperations[0].response = m_webResponse;
-        batchOperations[0].response.setBlobDataHandle(handle);
-        m_cache->webCache()->dispatchBatch(new CacheAddOrPutCallbacks(m_resolver.get()), batchOperations);
-        cleanup();
-    }
-    void didFail(PassRefPtrWillBeRawPtr<DOMException> exception) override
-    {
-        ScriptState* state = m_resolver->scriptState();
-        ScriptState::Scope scope(state);
-        m_resolver->reject(V8ThrowException::createTypeError(state->isolate(), exception->toString()));
-        cleanup();
-    }
-
-    DEFINE_INLINE_VIRTUAL_TRACE()
-    {
-        visitor->trace(m_resolver);
-        visitor->trace(m_cache);
-        BlobHandleCreatorClient::trace(visitor);
-    }
-
-private:
-    void cleanup()
-    {
-        m_resolver = nullptr;
-        m_cache = nullptr;
-    }
-    RefPtrWillBeMember<ScriptPromiseResolver> m_resolver;
-    Member<Cache> m_cache;
-    WebServiceWorkerRequest m_webRequest;
-    WebServiceWorkerResponse m_webResponse;
-};
-
-Cache* Cache::create(WebServiceWorkerCache* webCache)
-{
-    return new Cache(webCache);
-}
-
-ScriptPromise Cache::match(ScriptState* scriptState, const RequestInfo& request, const CacheQueryOptions& options, ExceptionState& exceptionState)
-{
-    ASSERT(!request.isNull());
-    if (request.isRequest())
-        return matchImpl(scriptState, request.getAsRequest(), options);
-    Request* newRequest = Request::create(scriptState->executionContext(), request.getAsUSVString(), exceptionState);
-    if (exceptionState.hadException())
-        return ScriptPromise();
-    return matchImpl(scriptState, newRequest, options);
-}
-
-ScriptPromise Cache::matchAll(ScriptState* scriptState, const RequestInfo& request, const CacheQueryOptions& options, ExceptionState& exceptionState)
-{
-    ASSERT(!request.isNull());
-    if (request.isRequest())
-        return matchAllImpl(scriptState, request.getAsRequest(), options);
-    Request* newRequest = Request::create(scriptState->executionContext(), request.getAsUSVString(), exceptionState);
-    if (exceptionState.hadException())
-        return ScriptPromise();
-    return matchAllImpl(scriptState, newRequest, options);
-}
-
-ScriptPromise Cache::add(ScriptState* scriptState, const RequestInfo& request, ExceptionState& exceptionState)
-{
-    ASSERT(!request.isNull());
-    if (request.isRequest())
-        return addImpl(scriptState, request.getAsRequest());
-    Request* newRequest = Request::create(scriptState->executionContext(), request.getAsUSVString(), exceptionState);
-    if (exceptionState.hadException())
-        return ScriptPromise();
-    return addImpl(scriptState, newRequest);
-}
-
-ScriptPromise Cache::addAll(ScriptState* scriptState, const Vector<ScriptValue>& rawRequests)
-{
-    // FIXME: Implement this.
-    return rejectAsNotImplemented(scriptState);
-}
-
-ScriptPromise Cache::deleteFunction(ScriptState* scriptState, const RequestInfo& request, const CacheQueryOptions& options, ExceptionState& exceptionState)
-{
-    ASSERT(!request.isNull());
-    if (request.isRequest())
-        return deleteImpl(scriptState, request.getAsRequest(), options);
-    Request* newRequest = Request::create(scriptState->executionContext(), request.getAsUSVString(), exceptionState);
-    if (exceptionState.hadException())
-        return ScriptPromise();
-    return deleteImpl(scriptState, newRequest, options);
-}
-
-ScriptPromise Cache::put(ScriptState* scriptState, const RequestInfo& request, Response* response, ExceptionState& exceptionState)
-{
-    ASSERT(!request.isNull());
-    if (request.isRequest())
-        return putImpl(scriptState, request.getAsRequest(), response);
-    Request* newRequest = Request::create(scriptState->executionContext(), request.getAsUSVString(), exceptionState);
-    if (exceptionState.hadException())
-        return ScriptPromise();
-    return putImpl(scriptState, newRequest, response);
-}
-
-ScriptPromise Cache::keys(ScriptState* scriptState, ExceptionState&)
-{
-    return keysImpl(scriptState);
-}
-
-ScriptPromise Cache::keys(ScriptState* scriptState, const RequestInfo& request, const CacheQueryOptions& options, ExceptionState& exceptionState)
-{
-    ASSERT(!request.isNull());
-    if (request.isRequest())
-        return keysImpl(scriptState, request.getAsRequest(), options);
-    Request* newRequest = Request::create(scriptState->executionContext(), request.getAsUSVString(), exceptionState);
-    if (exceptionState.hadException())
-        return ScriptPromise();
-    return keysImpl(scriptState, newRequest, options);
-}
-
-// static
-WebServiceWorkerCache::QueryParams Cache::toWebQueryParams(const CacheQueryOptions& options)
-{
-    WebServiceWorkerCache::QueryParams webQueryParams;
-    webQueryParams.ignoreSearch = options.ignoreSearch();
-    webQueryParams.ignoreMethod = options.ignoreMethod();
-    webQueryParams.ignoreVary = options.ignoreVary();
-    webQueryParams.cacheName = options.cacheName();
-    return webQueryParams;
-}
-
-Cache::Cache(WebServiceWorkerCache* webCache)
-    : m_webCache(adoptPtr(webCache)) { }
-
-ScriptPromise Cache::matchImpl(ScriptState* scriptState, const Request* request, const CacheQueryOptions& options)
-{
-    WebServiceWorkerRequest webRequest;
-    request->populateWebServiceWorkerRequest(webRequest);
-
-    RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
-    const ScriptPromise promise = resolver->promise();
-    m_webCache->dispatchMatch(new CacheMatchCallbacks(resolver), webRequest, toWebQueryParams(options));
-    return promise;
-}
-
-ScriptPromise Cache::matchAllImpl(ScriptState* scriptState, const Request* request, const CacheQueryOptions& options)
-{
-    WebServiceWorkerRequest webRequest;
-    request->populateWebServiceWorkerRequest(webRequest);
-
-    RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
-    const ScriptPromise promise = resolver->promise();
-    m_webCache->dispatchMatchAll(new CacheWithResponsesCallbacks(resolver), webRequest, toWebQueryParams(options));
-    return promise;
-}
-
-ScriptPromise Cache::addImpl(ScriptState* scriptState, const Request*)
-{
-    // FIXME: Implement this.
-    return rejectAsNotImplemented(scriptState);
-}
-
-ScriptPromise Cache::addAllImpl(ScriptState* scriptState, const Vector<const Request*>)
-{
-    // FIXME: Implement this.
-    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.");
-    }
-}
-
-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(options);
-
-    RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
-    const ScriptPromise promise = resolver->promise();
-    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->lockBody(Body::PassBody);
-    if (response->hasBody())
-        response->lockBody(Body::PassBody);
-
-    RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
-    const ScriptPromise promise = resolver->promise();
-    if (BodyStreamBuffer* buffer = response->internalBuffer()) {
-        if (buffer == response->buffer() && response->isBodyConsumed())
-            buffer = response->createDrainingStream();
-        // If the response body type is stream, read the all data and create the
-        // blob handle and dispatch the put batch asynchronously.
-        buffer->readAllAndCreateBlobHandle(response->internalMIMEType(), new AsyncPutBatch(resolver, this, request, response));
-        return promise;
-    }
-    WebVector<WebServiceWorkerCache::BatchOperation> batchOperations(size_t(1));
-    batchOperations[0].operationType = WebServiceWorkerCache::OperationTypePut;
-    request->populateWebServiceWorkerRequest(batchOperations[0].request);
-    response->populateWebServiceWorkerResponse(batchOperations[0].response);
-
-    m_webCache->dispatchBatch(new CacheAddOrPutCallbacks(resolver), batchOperations);
-    return promise;
-}
-
-ScriptPromise Cache::keysImpl(ScriptState* scriptState)
-{
-    RefPtrWillBeRawPtr<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, const Request* request, const CacheQueryOptions& options)
-{
-    WebServiceWorkerRequest webRequest;
-    request->populateWebServiceWorkerRequest(webRequest);
-
-    RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
-    const ScriptPromise promise = resolver->promise();
-    m_webCache->dispatchKeys(new CacheWithRequestsCallbacks(resolver), 0, toWebQueryParams(options));
-    return promise;
-}
-
-WebServiceWorkerCache* Cache::webCache() const
-{
-    return m_webCache.get();
-}
-
-} // namespace blink