Move Cache Storage API implementation to modules/cachestorage

Source/modules/cachestorage/CacheTest.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 "modules/cachestorage/Cache.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptFunction.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/modules/v8/V8Request.h"
 #include "bindings/modules/v8/V8Response.h"
 #include "core/dom/Document.h"
 #include "core/frame/Frame.h"
@@ skipping 128 matching lines @@
     const WebVector<BatchOperation>* m_expectedBatchOperations;
 
     std::string m_lastErrorWebCacheMethodCalled;
 };
 
 class NotImplementedErrorCache : public ErrorWebCacheForTests {
 public:
     NotImplementedErrorCache() : ErrorWebCacheForTests(WebServiceWorkerCacheErrorNotImplemented) { }
 };
 
-class ServiceWorkerCacheTest : public ::testing::Test {
+class CacheStorageTest : public ::testing::Test {
 public:
-    ServiceWorkerCacheTest()
+    CacheStorageTest()
         : m_page(DummyPageHolder::create(IntSize(1, 1))) { }
 
     ScriptState* scriptState() { return ScriptState::forMainWorld(m_page->document().frame()); }
     ExecutionContext* executionContext() { return scriptState()->executionContext(); }
     v8::Isolate* isolate() { return scriptState()->isolate(); }
 
     Request* newRequestFromUrl(const String& url)
     {
         TrackExceptionState exceptionState;
         Request* request = Request::create(executionContext(), url, exceptionState);
@@ skipping 105 matching lines @@
     return info;
 }
 
 RequestInfo requestToRequestInfo(Request* value)
 {
     RequestInfo info;
     info.setRequest(value);
     return info;
 }
 
-TEST_F(ServiceWorkerCacheTest, Basics)
+TEST_F(CacheStorageTest, Basics)
 {
     ErrorWebCacheForTests* testCache;
     Cache* cache = Cache::create(testCache = new NotImplementedErrorCache());
     ASSERT(cache);
 
     const String url = "http://www.cachetest.org/";
 
     CacheQueryOptions options;
     ScriptPromise matchPromise = cache->match(scriptState(), stringToRequestInfo(url), options, exceptionState());
     EXPECT_EQ(kNotImplementedString, getRejectString(matchPromise));
 
     cache = Cache::create(testCache = new ErrorWebCacheForTests(WebServiceWorkerCacheErrorNotFound));
     matchPromise = cache->match(scriptState(), stringToRequestInfo(url), options, exceptionState());
     ScriptValue scriptValue = getResolveValue(matchPromise);
     EXPECT_TRUE(scriptValue.isUndefined());
 
     cache = Cache::create(testCache = new ErrorWebCacheForTests(WebServiceWorkerCacheErrorExists));
     matchPromise = cache->match(scriptState(), stringToRequestInfo(url), options, exceptionState());
     EXPECT_EQ("InvalidAccessError: Entry already exists.", getRejectString(matchPromise));
 }
 
 // Tests that arguments are faithfully passed on calls to Cache methods, except for methods which use batch operations,
 // which are tested later.
-TEST_F(ServiceWorkerCacheTest, BasicArguments)
+TEST_F(CacheStorageTest, BasicArguments)
 {
     ErrorWebCacheForTests* testCache;
     Cache* cache = Cache::create(testCache = new NotImplementedErrorCache());
     ASSERT(cache);
 
     const String url = "http://www.cache.arguments.test/";
     testCache->setExpectedUrl(&url);
 
     WebServiceWorkerCache::QueryParams expectedQueryParams;
     expectedQueryParams.ignoreVary = true;
@@ skipping 33 matching lines @@
     ScriptPromise keysResult2 = cache->keys(scriptState(), requestToRequestInfo(request), options, exceptionState());
     EXPECT_EQ("dispatchKeys", testCache->getAndClearLastErrorWebCacheMethodCalled());
     EXPECT_EQ(kNotImplementedString, getRejectString(keysResult2));
 
     ScriptPromise stringKeysResult2 = cache->keys(scriptState(), stringToRequestInfo(url), options, exceptionState());
     EXPECT_EQ("dispatchKeys", testCache->getAndClearLastErrorWebCacheMethodCalled());
     EXPECT_EQ(kNotImplementedString, getRejectString(stringKeysResult2));
 }
 
 // Tests that arguments are faithfully passed to API calls that degrade to batch operations.
-TEST_F(ServiceWorkerCacheTest, BatchOperationArguments)
+TEST_F(CacheStorageTest, BatchOperationArguments)
 {
     ErrorWebCacheForTests* testCache;
     Cache* cache = Cache::create(testCache = new NotImplementedErrorCache());
     ASSERT(cache);
 
     WebServiceWorkerCache::QueryParams expectedQueryParams;
     expectedQueryParams.cacheName = "this is another cache name";
     testCache->setExpectedQueryParams(&expectedQueryParams);
 
     CacheQueryOptions options;
@@ skipping 57 matching lines @@
     virtual void dispatchMatch(CacheMatchCallbacks* callbacks, const WebServiceWorkerRequest& webRequest, const QueryParams& queryParams) override
     {
         OwnPtr<CacheMatchCallbacks> ownedCallbacks(adoptPtr(callbacks));
         return callbacks->onSuccess(&m_response);
     }
 
 private:
     WebServiceWorkerResponse& m_response;
 };
 
-TEST_F(ServiceWorkerCacheTest, MatchResponseTest)
+TEST_F(CacheStorageTest, MatchResponseTest)
 {
     const String requestUrl = "http://request.url/";
     const String responseUrl = "http://match.response.test/";
 
     WebServiceWorkerResponse webResponse;
     webResponse.setURL(KURL(ParsedURLString, responseUrl));
     webResponse.setResponseType(WebServiceWorkerResponseTypeDefault);
 
     Cache* cache = Cache::create(new MatchTestCache(webResponse));
     CacheQueryOptions options;
@@ skipping 13 matching lines @@
     virtual void dispatchKeys(CacheWithRequestsCallbacks* callbacks, const WebServiceWorkerRequest* webRequest, const QueryParams& queryParams) override
     {
         OwnPtr<CacheWithRequestsCallbacks> ownedCallbacks(adoptPtr(callbacks));
         return callbacks->onSuccess(&m_requests);
     }
 
 private:
     WebVector<WebServiceWorkerRequest>& m_requests;
 };
 
-TEST_F(ServiceWorkerCacheTest, KeysResponseTest)
+TEST_F(CacheStorageTest, KeysResponseTest)
 {
     const String url1 = "http://first.request/";
     const String url2 = "http://second.request/";
 
     Vector<String> expectedUrls(size_t(2));
     expectedUrls[0] = url1;
     expectedUrls[1] = url2;
 
     WebVector<WebServiceWorkerRequest> webRequests(size_t(2));
     webRequests[0].setURL(KURL(ParsedURLString, url1));
@@ skipping 28 matching lines @@
     virtual void dispatchBatch(CacheWithResponsesCallbacks* callbacks, const WebVector<BatchOperation>& batchOperations) override
     {
         OwnPtr<CacheWithResponsesCallbacks> ownedCallbacks(adoptPtr(callbacks));
         return callbacks->onSuccess(&m_responses);
     }
 
 private:
     WebVector<WebServiceWorkerResponse>& m_responses;
 };
 
-TEST_F(ServiceWorkerCacheTest, MatchAllAndBatchResponseTest)
+TEST_F(CacheStorageTest, MatchAllAndBatchResponseTest)
 {
     const String url1 = "http://first.response/";
     const String url2 = "http://second.response/";
 
     Vector<String> expectedUrls(size_t(2));
     expectedUrls[0] = url1;
     expectedUrls[1] = url2;
 
     WebVector<WebServiceWorkerResponse> webResponses(size_t(2));
     webResponses[0].setURL(KURL(ParsedURLString, url1));
@@ skipping 17 matching lines @@
     }
 
     result = cache->deleteFunction(scriptState(), stringToRequestInfo("http://some.url/"), options, exceptionState());
     scriptValue = getResolveValue(result);
     EXPECT_TRUE(scriptValue.v8Value()->IsBoolean());
     EXPECT_EQ(true, scriptValue.v8Value()->BooleanValue());
 }
 
 } // namespace
 } // namespace blink