Oilpan: avoid using WeakPtr<> for heap residing objects.

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 15 matching lines @@
 #include <algorithm>
 #include <gtest/gtest.h>
 #include <string>
 
 namespace blink {
 
 namespace {
 
 const char kNotImplementedString[] = "NotSupportedError: Method is not implemented.";
 
-class ScopedFetcherForTests final : public GlobalFetch::ScopedFetcher {
+class ScopedFetcherForTests final : public NoBaseWillBeGarbageCollectedFinalized<ScopedFetcherForTests>, public GlobalFetch::ScopedFetcher {
+    WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(ScopedFetcherForTests);
 public:
-    ScopedFetcherForTests()
-        : m_fetchCount(0)
-        , m_expectedUrl(nullptr)
-        , m_weakFactory(this)
+    static PassOwnPtrWillBeRawPtr<ScopedFetcherForTests> create()
     {
+        return adoptPtrWillBeNoop(new ScopedFetcherForTests);
     }
 
     ScriptPromise fetch(ScriptState* scriptState, const RequestInfo& requestInfo, const Dictionary&, ExceptionState&) override
     {
         ++m_fetchCount;
         if (m_expectedUrl) {
             String fetchedUrl;
             if (requestInfo.isRequest())
                 EXPECT_EQ(*m_expectedUrl, requestInfo.getAsRequest()->url());
             else
                 EXPECT_EQ(*m_expectedUrl, requestInfo.getAsUSVString());
         }
 
         if (m_response) {
             ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
             const ScriptPromise promise = resolver->promise();
             resolver->resolve(m_response);
             m_response = nullptr;
             return promise;
         }
         return ScriptPromise::reject(scriptState, V8ThrowException::createTypeError(scriptState->isolate(), "Unexpected call to fetch, no response available."));
     }
 
-    WeakPtr<GlobalFetch::ScopedFetcher> weakPtr()
+    WeakPtrWillBeRawPtr<GlobalFetch::ScopedFetcher> weakPtr()
     {
+#if ENABLE(OILPAN)
+        return this;
+#else
         return m_weakFactory.createWeakPtr();
+#endif
     }
 
     // This does not take ownership of its parameter. The provided sample object is used to check the parameter when called.
     void setExpectedFetchUrl(const String* expectedUrl) { m_expectedUrl = expectedUrl; }
     void setResponse(Response* response) { m_response = response; }
 
     int fetchCount() const { return m_fetchCount; }
 
+    DEFINE_INLINE_TRACE()
+    {
+        visitor->trace(m_response);
+        GlobalFetch::ScopedFetcher::trace(visitor);
+    }
+
 private:
+    ScopedFetcherForTests()
+        : m_fetchCount(0)
+        , m_expectedUrl(nullptr)
+#if !ENABLE(OILPAN)
+        , m_weakFactory(this)
+#endif
+    {
+    }
+
     int m_fetchCount;
     const String* m_expectedUrl;
-    Persistent<Response> m_response;
+    PersistentWillBeMember<Response> m_response;
 
+#if !ENABLE(OILPAN)
     WeakPtrFactory<GlobalFetch::ScopedFetcher> m_weakFactory;
+#endif
 };
 
 // A test implementation of the WebServiceWorkerCache interface which returns a (provided) error for every operation, and optionally checks arguments
 // to methods against provided arguments. Also used as a base class for test specific caches.
 class ErrorWebCacheForTests : public WebServiceWorkerCache {
 public:
     ErrorWebCacheForTests(const WebServiceWorkerCacheError error)
         : m_error(error)
         , m_expectedUrl(0)
         , m_expectedQueryParams(0)
@@ skipping 222 matching lines @@
 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());
+    OwnPtrWillBeRawPtr<ScopedFetcherForTests> fetcher = ScopedFetcherForTests::create();
     ErrorWebCacheForTests* testCache;
     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(fetcher.get(), testCache = new ErrorWebCacheForTests(WebServiceWorkerCacheErrorNotFound));
     matchPromise = cache->match(scriptState(), stringToRequestInfo(url), options, exceptionState());
     ScriptValue scriptValue = getResolveValue(matchPromise);
     EXPECT_TRUE(scriptValue.isUndefined());
 
     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());
+    OwnPtrWillBeRawPtr<ScopedFetcherForTests> fetcher = ScopedFetcherForTests::create();
     ErrorWebCacheForTests* testCache;
     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";
@@ skipping 35 matching lines @@
 
     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());
+    OwnPtrWillBeRawPtr<ScopedFetcherForTests> fetcher = ScopedFetcherForTests::create();
     ErrorWebCacheForTests* testCache;
     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);
@@ skipping 59 matching lines @@
         return callbacks->onSuccess(m_response);
     }
 
 private:
     WebServiceWorkerResponse& m_response;
 };
 
 TEST_F(CacheStorageTest, MatchResponseTest)
 {
     ScriptState::Scope scope(scriptState());
-    OwnPtr<ScopedFetcherForTests> fetcher = adoptPtr(new ScopedFetcherForTests());
+    OwnPtrWillBeRawPtr<ScopedFetcherForTests> fetcher = ScopedFetcherForTests::create();
     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(fetcher.get(), new MatchTestCache(webResponse));
     CacheQueryOptions options;
 
@@ skipping 15 matching lines @@
         return callbacks->onSuccess(m_requests);
     }
 
 private:
     WebVector<WebServiceWorkerRequest>& m_requests;
 };
 
 TEST_F(CacheStorageTest, KeysResponseTest)
 {
     ScriptState::Scope scope(scriptState());
-    OwnPtr<ScopedFetcherForTests> fetcher = adoptPtr(new ScopedFetcherForTests());
+    OwnPtrWillBeRawPtr<ScopedFetcherForTests> fetcher = ScopedFetcherForTests::create();
     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));
@@ skipping 30 matching lines @@
         return callbacks->onSuccess();
     }
 
 private:
     WebVector<WebServiceWorkerResponse>& m_responses;
 };
 
 TEST_F(CacheStorageTest, MatchAllAndBatchResponseTest)
 {
     ScriptState::Scope scope(scriptState());
-    OwnPtr<ScopedFetcherForTests> fetcher = adoptPtr(new ScopedFetcherForTests());
+    OwnPtrWillBeRawPtr<ScopedFetcherForTests> fetcher = ScopedFetcherForTests::create();
     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);
@@ 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().As<v8::Boolean>()->Value());
 }
 
 TEST_F(CacheStorageTest, Add)
 {
     ScriptState::Scope scope(scriptState());
-    OwnPtr<ScopedFetcherForTests> fetcher = adoptPtr(new ScopedFetcherForTests());
+    OwnPtrWillBeRawPtr<ScopedFetcherForTests> fetcher = ScopedFetcherForTests::create();
     const String url = "http://www.cacheadd.test/";
     const KURL kurl(ParsedURLString, url);
 
     ErrorWebCacheForTests* testCache;
     Cache* cache = createCache(fetcher.get(), testCache = new NotImplementedErrorCache());
 
     fetcher->setExpectedFetchUrl(&url);
 
     Request* request = newRequestFromUrl(url);
     WebServiceWorkerResponse webResponse;
@@ skipping 13 matching lines @@
 
     ScriptPromise addResult = cache->add(scriptState(), requestToRequestInfo(request), exceptionState());
 
     EXPECT_EQ(kNotImplementedString, getRejectString(addResult));
     EXPECT_EQ(1, fetcher->fetchCount());
     EXPECT_EQ("dispatchBatch", testCache->getAndClearLastErrorWebCacheMethodCalled());
 }
 
 } // namespace
 } // namespace blink