Adding allocator annotations to blink classes and structs.

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/cachestorage/Cache.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptFunction.h"
 #include "bindings/core/v8/ScriptPromise.h"
@@ skipping 187 matching lines @@
 class NotImplementedErrorCache : public ErrorWebCacheForTests {
 public:
     NotImplementedErrorCache() : ErrorWebCacheForTests(WebServiceWorkerCacheErrorNotImplemented) { }
 };
 
 class CacheStorageTest : public ::testing::Test {
 public:
     CacheStorageTest()
         : m_page(DummyPageHolder::create(IntSize(1, 1))) { }
 
-    Cache* createCache(WebServiceWorkerCache* webCache)
+    Cache* createCache(ScopedFetcherForTests* fetcher, WebServiceWorkerCache* webCache)
     {
-        return Cache::create(m_scopedFetcherForTests->weakPtr(), adoptPtr(webCache));
+        return Cache::create(fetcher->weakPtr(), adoptPtr(webCache));
     }
 
     ScriptState* scriptState() { return ScriptState::forMainWorld(m_page->document().frame()); }
     ExecutionContext* executionContext() { return scriptState()->executionContext(); }
     v8::Isolate* isolate() { return scriptState()->isolate(); }
     v8::Local<v8::Context> context() { return scriptState()->context(); }
-    ScopedFetcherForTests* fetcher() { return m_scopedFetcherForTests.get(); }
 
     Request* newRequestFromUrl(const String& url)
     {
         TrackExceptionState exceptionState;
         Request* request = Request::create(scriptState(), url, exceptionState);
         EXPECT_FALSE(exceptionState.hadException());
         return exceptionState.hadException() ? 0 : request;
     }
 
     // Convenience methods for testing the returned promises.
@@ skipping 65 matching lines @@
             *m_value = value;
             return value;
         }
 
     private:
         TestFunction(ScriptState* scriptState, ScriptValue* outValue) : ScriptFunction(scriptState), m_value(outValue) { }
 
         ScriptValue* m_value;
     };
 
-    // From ::testing::Test:
-    void SetUp() override
-    {
-        EXPECT_FALSE(m_scopedFetcherForTests);
-        m_scopedFetcherForTests = adoptPtr(new ScopedFetcherForTests());
-        EXPECT_FALSE(m_scriptScope);
-        m_scriptScope = adoptPtr(new ScriptState::Scope(scriptState()));
-    }
-
-    void TearDown() override
-    {
-        m_scopedFetcherForTests = nullptr;
-        m_scriptScope = 0;
-    }
-
-    OwnPtr<ScopedFetcherForTests> m_scopedFetcherForTests;
-
     // Lifetime is that of the text fixture.
     OwnPtr<DummyPageHolder> m_page;
 
-    // Lifetime is per test instance.
-    OwnPtr<ScriptState::Scope> m_scriptScope;
-
     NonThrowableExceptionState m_exceptionState;
 };
 
 RequestInfo stringToRequestInfo(const String& value)
 {
     RequestInfo info;
     info.setUSVString(value);
     return info;
 }
 
 RequestInfo requestToRequestInfo(Request* value)
 {
     RequestInfo info;
     info.setRequest(value);
     return info;
 }
 
 TEST_F(CacheStorageTest, Basics)
 {
+    ScriptState::Scope scope(scriptState());
+    OwnPtr<ScopedFetcherForTests> fetcher = adoptPtr(new ScopedFetcherForTests());
     ErrorWebCacheForTests* testCache;
-    Cache* cache = createCache(testCache = new NotImplementedErrorCache());
+    Cache* cache = createCache(fetcher.get(), 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 = createCache(testCache = new ErrorWebCacheForTests(WebServiceWorkerCacheErrorNotFound));
+    cache = createCache(fetcher.get(), testCache = new ErrorWebCacheForTests(WebServiceWorkerCacheErrorNotFound));
     matchPromise = cache->match(scriptState(), stringToRequestInfo(url), options, exceptionState());
     ScriptValue scriptValue = getResolveValue(matchPromise);
     EXPECT_TRUE(scriptValue.isUndefined());
 
-    cache = createCache(testCache = new ErrorWebCacheForTests(WebServiceWorkerCacheErrorExists));
+    cache = createCache(fetcher.get(), 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(CacheStorageTest, BasicArguments)
 {
+    ScriptState::Scope scope(scriptState());
+    OwnPtr<ScopedFetcherForTests> fetcher = adoptPtr(new ScopedFetcherForTests());
     ErrorWebCacheForTests* testCache;
-    Cache* cache = createCache(testCache = new NotImplementedErrorCache());
+    Cache* cache = createCache(fetcher.get(), 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);
 
@@ skipping 32 matching lines @@
     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(CacheStorageTest, BatchOperationArguments)
 {
+    ScriptState::Scope scope(scriptState());
+    OwnPtr<ScopedFetcherForTests> fetcher = adoptPtr(new ScopedFetcherForTests());
     ErrorWebCacheForTests* testCache;
-    Cache* cache = createCache(testCache = new NotImplementedErrorCache());
+    Cache* cache = createCache(fetcher.get(), testCache = new NotImplementedErrorCache());
     ASSERT(cache);
 
     WebServiceWorkerCache::QueryParams expectedQueryParams;
     expectedQueryParams.cacheName = "this is another cache name";
     testCache->setExpectedQueryParams(&expectedQueryParams);
 
     CacheQueryOptions options;
     options.setCacheName(expectedQueryParams.cacheName);
 
     const String url = "http://batch.operations.test/";
@@ skipping 56 matching lines @@
         OwnPtr<CacheMatchCallbacks> ownedCallbacks(adoptPtr(callbacks));
         return callbacks->onSuccess(&m_response);
     }
 
 private:
     WebServiceWorkerResponse& m_response;
 };
 
 TEST_F(CacheStorageTest, MatchResponseTest)
 {
+    ScriptState::Scope scope(scriptState());
+    OwnPtr<ScopedFetcherForTests> fetcher = adoptPtr(new ScopedFetcherForTests());
     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 = createCache(new MatchTestCache(webResponse));
+    Cache* cache = createCache(fetcher.get(), new MatchTestCache(webResponse));
     CacheQueryOptions options;
 
     ScriptPromise result = cache->match(scriptState(), stringToRequestInfo(requestUrl), options, exceptionState());
     ScriptValue scriptValue = getResolveValue(result);
     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) { }
 
     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(CacheStorageTest, KeysResponseTest)
 {
+    ScriptState::Scope scope(scriptState());
+    OwnPtr<ScopedFetcherForTests> fetcher = adoptPtr(new ScopedFetcherForTests());
     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));
     webRequests[1].setURL(KURL(ParsedURLString, url2));
 
-    Cache* cache = createCache(new KeysTestCache(webRequests));
+    Cache* cache = createCache(fetcher.get(), new KeysTestCache(webRequests));
 
     ScriptPromise result = cache->keys(scriptState(), exceptionState());
     ScriptValue scriptValue = getResolveValue(result);
 
     Vector<v8::Local<v8::Value>> requests = toImplArray<Vector<v8::Local<v8::Value>>>(scriptValue.v8Value(), 0, isolate(), exceptionState());
     EXPECT_EQ(expectedUrls.size(), requests.size());
     for (int i = 0, minsize = std::min(expectedUrls.size(), requests.size()); i < minsize; ++i) {
         Request* request = V8Request::toImplWithTypeCheck(isolate(), requests[i]);
         EXPECT_TRUE(request);
         if (request)
@@ skipping 17 matching lines @@
         OwnPtr<CacheBatchCallbacks> ownedCallbacks(adoptPtr(callbacks));
         return callbacks->onSuccess();
     }
 
 private:
     WebVector<WebServiceWorkerResponse>& m_responses;
 };
 
 TEST_F(CacheStorageTest, MatchAllAndBatchResponseTest)
 {
+    ScriptState::Scope scope(scriptState());
+    OwnPtr<ScopedFetcherForTests> fetcher = adoptPtr(new ScopedFetcherForTests());
     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));
     webResponses[0].setResponseType(WebServiceWorkerResponseTypeDefault);
     webResponses[1].setURL(KURL(ParsedURLString, url2));
     webResponses[1].setResponseType(WebServiceWorkerResponseTypeDefault);
 
-    Cache* cache = createCache(new MatchAllAndBatchTestCache(webResponses));
+    Cache* cache = createCache(fetcher.get(), new MatchAllAndBatchTestCache(webResponses));
 
     CacheQueryOptions options;
     ScriptPromise result = cache->matchAll(scriptState(), stringToRequestInfo("http://some.url/"), options, exceptionState());
     ScriptValue scriptValue = getResolveValue(result);
 
     Vector<v8::Local<v8::Value>> responses = toImplArray<Vector<v8::Local<v8::Value>>>(scriptValue.v8Value(), 0, isolate(), exceptionState());
     EXPECT_EQ(expectedUrls.size(), responses.size());
     for (int i = 0, minsize = std::min(expectedUrls.size(), responses.size()); i < minsize; ++i) {
         Response* response = V8Response::toImplWithTypeCheck(isolate(), responses[i]);
         EXPECT_TRUE(response);
         if (response)
             EXPECT_EQ(expectedUrls[i], response->url());
     }
 
     result = cache->deleteFunction(scriptState(), stringToRequestInfo("http://some.url/"), options, exceptionState());
     scriptValue = getResolveValue(result);
     EXPECT_TRUE(scriptValue.v8Value()->IsBoolean());
     EXPECT_EQ(true, scriptValue.v8Value().As<v8::Boolean>()->Value());
 }
 
 TEST_F(CacheStorageTest, Add)
 {
+    ScriptState::Scope scope(scriptState());
+    OwnPtr<ScopedFetcherForTests> fetcher = adoptPtr(new ScopedFetcherForTests());
     const String url = "http://www.cacheadd.test/";
     const KURL kurl(ParsedURLString, url);
 
     ErrorWebCacheForTests* testCache;
-    Cache* cache = createCache(testCache = new NotImplementedErrorCache());
+    Cache* cache = createCache(fetcher.get(), testCache = new NotImplementedErrorCache());
 
-    fetcher()->setExpectedFetchUrl(&url);
+    fetcher->setExpectedFetchUrl(&url);
 
     Request* request = newRequestFromUrl(url);
     WebServiceWorkerResponse webResponse;
     webResponse.setURL(kurl);
     Response* response = Response::create(executionContext(), webResponse);
-    fetcher()->setResponse(response);
+    fetcher->setResponse(response);
 
     WebVector<WebServiceWorkerCache::BatchOperation> expectedPutOperations(size_t(1));
     {
         WebServiceWorkerCache::BatchOperation putOperation;
         putOperation.operationType = WebServiceWorkerCache::OperationTypePut;
         request->populateWebServiceWorkerRequest(putOperation.request);
         response->populateWebServiceWorkerResponse(putOperation.response);
         expectedPutOperations[0] = putOperation;
     }
     testCache->setExpectedBatchOperations(&expectedPutOperations);
 
     ScriptPromise addResult = cache->add(scriptState(), requestToRequestInfo(request), exceptionState());
 
     EXPECT_EQ(kNotImplementedString, getRejectString(addResult));
-    EXPECT_EQ(1, fetcher()->fetchCount());
+    EXPECT_EQ(1, fetcher->fetchCount());
     EXPECT_EQ("dispatchBatch", testCache->getAndClearLastErrorWebCacheMethodCalled());
 }
 
 } // namespace
 } // namespace blink