Patch on top of https://codereview.chromium.org/433793002/

Source/modules/serviceworkers/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 "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"
 #include "core/testing/DummyPageHolder.h"
-#include "modules/serviceworkers/Cache.h"
 #include "modules/serviceworkers/Request.h"
 #include "modules/serviceworkers/Response.h"
 #include "public/platform/WebServiceWorkerCache.h"
 #include "wtf/OwnPtr.h"
 
 #include <algorithm>
 #include <gtest/gtest.h>
 
 namespace blink {
 namespace {
@@ skipping 222 matching lines @@
     // Lifetime is that of the text fixture.
     OwnPtr<DummyPageHolder> m_page;
 
     // Lifetime is per test instance.
     OwnPtr<ScriptState::Scope> m_scriptScope;
 };
 
 TEST_F(ServiceWorkerCacheTest, Basics)
 {
     ErrorWebCacheForTests* testCache;
-    RefPtrWillBeRawPtr<Cache> cache = Cache::fromWebServiceWorkerCache(testCache = new NotImplementedErrorCache());
+    Cache* cache = Cache::fromWebServiceWorkerCache(testCache = new NotImplementedErrorCache());
     ASSERT(cache);
 
     const String url = "http://www.cachetest.org/";
 
     ScriptPromise matchPromise = cache->match(scriptState(), url, Dictionary());
     expectNotImplemented(matchPromise);
 
     cache = Cache::fromWebServiceWorkerCache(testCache = new ErrorWebCacheForTests(WebServiceWorkerCacheErrorNotFound));
     matchPromise = cache->match(scriptState(), url, Dictionary());
     EXPECT_EQ("NotFoundError: Entry was not found.", getRejectString(matchPromise));
 
     cache = Cache::fromWebServiceWorkerCache(testCache = new ErrorWebCacheForTests(WebServiceWorkerCacheErrorExists));
     matchPromise = cache->match(scriptState(), url, Dictionary());
     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)
 {
     ErrorWebCacheForTests* testCache;
-    RefPtrWillBeRawPtr<Cache> cache = Cache::fromWebServiceWorkerCache(testCache = new NotImplementedErrorCache());
+    Cache* cache = Cache::fromWebServiceWorkerCache(testCache = new NotImplementedErrorCache());
     ASSERT(cache);
 
     const String url = "http://www.cache.arguments.test/";
     testCache->setExpectedUrl(&url);
 
     WebServiceWorkerCache::QueryParams expectedQueryParams;
     expectedQueryParams.ignoreVary = true;
     expectedQueryParams.cacheName = "this is a cache name";
     testCache->setExpectedQueryParams(&expectedQueryParams);
 
     Dictionary queryParamsDict = Dictionary::createEmpty(isolate());
     queryParamsDict.set("ignoreVary", 1);
     queryParamsDict.set("cacheName", expectedQueryParams.cacheName);
 
     TrackExceptionState exceptionState;
-    const RefPtrWillBeRawPtr<Request> request = Request::create(executionContext(), url, exceptionState);
+    const Request* request = Request::create(executionContext(), url, exceptionState);
     ASSERT(request);
     ASSERT_FALSE(exceptionState.hadException());
 
-    ScriptPromise matchResult = cache->match(scriptState(), request.get(), queryParamsDict);
+    ScriptPromise matchResult = cache->match(scriptState(), request, queryParamsDict);
     EXPECT_EQ("dispatchMatch", testCache->getAndClearLastErrorWebCacheMethodCalled());
     expectNotImplemented(matchResult);
 
     ScriptPromise stringMatchResult = cache->match(scriptState(), url, queryParamsDict);
     EXPECT_EQ("dispatchMatch", testCache->getAndClearLastErrorWebCacheMethodCalled());
     expectNotImplemented(stringMatchResult);
 
-    ScriptPromise matchAllResult = cache->matchAll(scriptState(), request.get(), queryParamsDict);
+    ScriptPromise matchAllResult = cache->matchAll(scriptState(), request, queryParamsDict);
     EXPECT_EQ("dispatchMatchAll", testCache->getAndClearLastErrorWebCacheMethodCalled());
     expectNotImplemented(matchAllResult);
 
     ScriptPromise stringMatchAllResult = cache->matchAll(scriptState(), url, queryParamsDict);
     EXPECT_EQ("dispatchMatchAll", testCache->getAndClearLastErrorWebCacheMethodCalled());
     expectNotImplemented(stringMatchAllResult);
 
     ScriptPromise keysResult1 = cache->keys(scriptState());
     EXPECT_EQ("dispatchKeys", testCache->getAndClearLastErrorWebCacheMethodCalled());
     expectNotImplemented(keysResult1);
 
-    ScriptPromise keysResult2 = cache->keys(scriptState(), request.get(), queryParamsDict);
+    ScriptPromise keysResult2 = cache->keys(scriptState(), request, queryParamsDict);
     EXPECT_EQ("dispatchKeys", testCache->getAndClearLastErrorWebCacheMethodCalled());
     expectNotImplemented(keysResult2);
 
     ScriptPromise stringKeysResult2 = cache->keys(scriptState(), url, queryParamsDict);
     EXPECT_EQ("dispatchKeys", testCache->getAndClearLastErrorWebCacheMethodCalled());
     expectNotImplemented(stringKeysResult2);
 }
 
 // Tests that arguments are faithfully passed to API calls that degrade to batch operations.
 TEST_F(ServiceWorkerCacheTest, BatchOperationArguments)
 {
     ErrorWebCacheForTests* testCache;
-    RefPtrWillBeRawPtr<Cache> cache = Cache::fromWebServiceWorkerCache(testCache = new NotImplementedErrorCache());
+    Cache* cache = Cache::fromWebServiceWorkerCache(testCache = new NotImplementedErrorCache());
     ASSERT(cache);
 
     WebServiceWorkerCache::QueryParams expectedQueryParams;
     expectedQueryParams.prefixMatch = true;
     expectedQueryParams.cacheName = "this is another cache name";
     testCache->setExpectedQueryParams(&expectedQueryParams);
 
     Dictionary queryParamsDict = Dictionary::createEmpty(isolate());
     queryParamsDict.set("prefixMatch", 1);
     queryParamsDict.set("cacheName", expectedQueryParams.cacheName);
 
     const String url = "http://batch.operations.test/";
     TrackExceptionState exceptionState;
-    const RefPtrWillBeRawPtr<Request> request = Request::create(executionContext(), url, exceptionState);
+    const Request* request = Request::create(executionContext(), url, exceptionState);
     ASSERT(request);
     ASSERT_FALSE(exceptionState.hadException());
 
     WebServiceWorkerResponse webResponse;
     webResponse.setURL(KURL(ParsedURLString, url));
-    const RefPtrWillBeRawPtr<Response> response = Response::create(webResponse);
+    const Response* response = Response::create(webResponse);
 
     WebVector<WebServiceWorkerCache::BatchOperation> expectedDeleteOperations(size_t(1));
     {
         WebServiceWorkerCache::BatchOperation deleteOperation;
         deleteOperation.operationType = WebServiceWorkerCache::WebServiceWorkerCacheOperationTypeDelete;
         request->populateWebServiceWorkerRequest(deleteOperation.request);
         deleteOperation.matchParams = expectedQueryParams;
         expectedDeleteOperations[0] = deleteOperation;
     }
     testCache->setExpectedBatchOperations(&expectedDeleteOperations);
 
-    ScriptPromise deleteResult = cache->deleteFunction(scriptState(), request.get(), queryParamsDict);
+    ScriptPromise deleteResult = cache->deleteFunction(scriptState(), request, queryParamsDict);
     EXPECT_EQ("dispatchBatch", testCache->getAndClearLastErrorWebCacheMethodCalled());
     expectNotImplemented(deleteResult);
 
     ScriptPromise stringDeleteResult = cache->deleteFunction(scriptState(), url, queryParamsDict);
     EXPECT_EQ("dispatchBatch", testCache->getAndClearLastErrorWebCacheMethodCalled());
     expectNotImplemented(stringDeleteResult);
 
     WebVector<WebServiceWorkerCache::BatchOperation> expectedPutOperations(size_t(1));
     {
         WebServiceWorkerCache::BatchOperation putOperation;
         putOperation.operationType = WebServiceWorkerCache::WebServiceWorkerCacheOperationTypePut;
         request->populateWebServiceWorkerRequest(putOperation.request);
         response->populateWebServiceWorkerResponse(putOperation.response);
         expectedPutOperations[0] = putOperation;
     }
     testCache->setExpectedBatchOperations(&expectedPutOperations);
 
-    ScriptPromise putResult = cache->put(scriptState(), request.get(), response.get());
+    ScriptPromise putResult = cache->put(scriptState(), request, response);
     EXPECT_EQ("dispatchBatch", testCache->getAndClearLastErrorWebCacheMethodCalled());
     expectNotImplemented(putResult);
 
-    ScriptPromise stringPutResult = cache->put(scriptState(), url, response.get());
+    ScriptPromise stringPutResult = cache->put(scriptState(), url, response);
     EXPECT_EQ("dispatchBatch", testCache->getAndClearLastErrorWebCacheMethodCalled());
     expectNotImplemented(stringPutResult);
 
     // FIXME: test add & addAll.
 }
 
 class MatchTestCache : public NotImplementedErrorCache {
 public:
     MatchTestCache(WebServiceWorkerResponse& response)
         : m_response(response) { }
@@ skipping 10 matching lines @@
 };
 
 TEST_F(ServiceWorkerCacheTest, MatchResponseTest)
 {
     const String requestUrl = "http://request.url/";
     const String responseUrl = "http://match.response.test/";
 
     WebServiceWorkerResponse webResponse;
     webResponse.setURL(KURL(ParsedURLString, responseUrl));
 
-    RefPtrWillBeRawPtr<Cache> cache = Cache::fromWebServiceWorkerCache(new MatchTestCache(webResponse));
+    Cache* cache = Cache::fromWebServiceWorkerCache(new MatchTestCache(webResponse));
 
     ScriptPromise result = cache->match(scriptState(), requestUrl, Dictionary());
     ScriptValue scriptValue = getResolveValue(result);
-    Response* response = V8Response::toNativeWithTypeCheck(isolate(), scriptValue.v8Value());
+    Response* response = V8Response::toImplWithTypeCheck(isolate(), scriptValue.v8Value());
     ASSERT_TRUE(response);
     EXPECT_EQ(responseUrl, response->url());
 }
 
 class KeysTestCache : public NotImplementedErrorCache {
 public:
     KeysTestCache(WebVector<WebServiceWorkerRequest>& requests)
         : m_requests(requests) { }
 
     virtual void dispatchKeys(CacheWithRequestsCallbacks* callbacks, const WebServiceWorkerRequest* webRequest, const QueryParams& queryParams) OVERRIDE
@@ skipping 12 matching lines @@
     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));
     webRequests[1].setURL(KURL(ParsedURLString, url2));
 
-    RefPtrWillBeRawPtr<Cache> cache = Cache::fromWebServiceWorkerCache(new KeysTestCache(webRequests));
+    Cache* cache = Cache::fromWebServiceWorkerCache(new KeysTestCache(webRequests));
 
     ScriptPromise result = cache->keys(scriptState());
     ScriptValue scriptValue = getResolveValue(result);
 
-    Vector<v8::Handle<v8::Value> > requests = toNativeArray<v8::Handle<v8::Value> >(scriptValue.v8Value(), 0, isolate());
+    Vector<v8::Handle<v8::Value> > requests = toImplArray<v8::Handle<v8::Value> >(scriptValue.v8Value(), 0, isolate());
     EXPECT_EQ(expectedUrls.size(), requests.size());
     for (int i = 0, minsize = std::min(expectedUrls.size(), requests.size()); i < minsize; ++i) {
-        Request* request = V8Request::toNativeWithTypeCheck(isolate(), requests[i]);
+        Request* request = V8Request::toImplWithTypeCheck(isolate(), requests[i]);
         EXPECT_TRUE(request);
         if (request)
             EXPECT_EQ(expectedUrls[i], request->url());
     }
 }
 
 class MatchAllAndBatchTestCache : public NotImplementedErrorCache {
 public:
     MatchAllAndBatchTestCache(WebVector<WebServiceWorkerResponse>& responses)
         : m_responses(responses) { }
@@ skipping 20 matching lines @@
     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));
     webResponses[1].setURL(KURL(ParsedURLString, url2));
 
-    RefPtrWillBeRawPtr<Cache> cache = Cache::fromWebServiceWorkerCache(new MatchAllAndBatchTestCache(webResponses));
+    Cache* cache = Cache::fromWebServiceWorkerCache(new MatchAllAndBatchTestCache(webResponses));
 
     ScriptPromise result = cache->matchAll(scriptState(), "http://some.url/", Dictionary());
     ScriptValue scriptValue = getResolveValue(result);
 
-    Vector<v8::Handle<v8::Value> > responses = toNativeArray<v8::Handle<v8::Value> >(scriptValue.v8Value(), 0, isolate());
+    Vector<v8::Handle<v8::Value> > responses = toImplArray<v8::Handle<v8::Value> >(scriptValue.v8Value(), 0, isolate());
     EXPECT_EQ(expectedUrls.size(), responses.size());
     for (int i = 0, minsize = std::min(expectedUrls.size(), responses.size()); i < minsize; ++i) {
-        Response* response = V8Response::toNativeWithTypeCheck(isolate(), responses[i]);
+        Response* response = V8Response::toImplWithTypeCheck(isolate(), responses[i]);
         EXPECT_TRUE(response);
         if (response)
             EXPECT_EQ(expectedUrls[i], response->url());
     }
 
     result = cache->deleteFunction(scriptState(), "http://some.url/", Dictionary());
     scriptValue = getResolveValue(result);
-    responses = toNativeArray<v8::Handle<v8::Value> >(scriptValue.v8Value(), 0, isolate());
+    responses = toImplArray<v8::Handle<v8::Value> >(scriptValue.v8Value(), 0, isolate());
     EXPECT_EQ(expectedUrls.size(), responses.size());
     for (int i = 0, minsize = std::min(expectedUrls.size(), responses.size()); i < minsize; ++i) {
-        Response* response = V8Response::toNativeWithTypeCheck(isolate(), responses[i]);
+        Response* response = V8Response::toImplWithTypeCheck(isolate(), responses[i]);
         EXPECT_TRUE(response);
         if (response)
             EXPECT_EQ(expectedUrls[i], response->url());
     }
 }
 
 } // namespace
 } // namespace blink