Have ScriptPromiseResolver on the Oilpan heap always.

Source/modules/cachestorage/Cache.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/CallbackPromiseAdapter.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
@@ skipping 12 matching lines @@
 #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)
+    CacheMatchCallbacks(ScriptPromiseResolver* resolver)
         : m_resolver(resolver) { }
 
     void onSuccess(WebServiceWorkerResponse* webResponse) override
     {
         m_resolver->resolve(Response::create(m_resolver->scriptState()->executionContext(), *webResponse));
         m_resolver.clear();
     }
 
     // Ownership of |rawReason| must be passed.
     void onError(WebServiceWorkerCacheError* rawReason) override
     {
         OwnPtr<WebServiceWorkerCacheError> reason = adoptPtr(rawReason);
         if (*reason == WebServiceWorkerCacheErrorNotFound)
             m_resolver->resolve();
         else
             m_resolver->reject(CacheStorageError::createException(*reason));
         m_resolver.clear();
     }
 
 private:
-    RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver;
+    Persistent<ScriptPromiseResolver> m_resolver;
 };
 
 // FIXME: Consider using CallbackPromiseAdapter.
 class CacheWithResponsesCallbacks : public WebServiceWorkerCache::CacheWithResponsesCallbacks {
     WTF_MAKE_NONCOPYABLE(CacheWithResponsesCallbacks);
 public:
-    CacheWithResponsesCallbacks(PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver)
+    CacheWithResponsesCallbacks(ScriptPromiseResolver* resolver)
         : m_resolver(resolver) { }
 
     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();
     }
 
     // Ownership of |rawReason| must be passed.
     void onError(WebServiceWorkerCacheError* rawReason) override
     {
         OwnPtr<WebServiceWorkerCacheError> reason = adoptPtr(rawReason);
         m_resolver->reject(CacheStorageError::createException(*reason));
         m_resolver.clear();
     }
 
 protected:
-    RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver;
+    Persistent<ScriptPromiseResolver> m_resolver;
 };
 
 // FIXME: Consider using CallbackPromiseAdapter.
 class CacheDeleteCallback : public WebServiceWorkerCache::CacheBatchCallbacks {
     WTF_MAKE_NONCOPYABLE(CacheDeleteCallback);
 public:
-    CacheDeleteCallback(PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver)
+    CacheDeleteCallback(ScriptPromiseResolver* resolver)
         : m_resolver(resolver) { }
 
     void onSuccess() override
     {
         m_resolver->resolve(true);
         m_resolver.clear();
     }
 
     // Ownership of |rawReason| must be passed.
     void onError(WebServiceWorkerCacheError* rawReason) override
     {
         OwnPtr<WebServiceWorkerCacheError> reason = adoptPtr(rawReason);
         if (*reason == WebServiceWorkerCacheErrorNotFound)
             m_resolver->resolve(false);
         else
             m_resolver->reject(CacheStorageError::createException(*reason));
         m_resolver.clear();
     }
 
 private:
-    RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver;
+    Persistent<ScriptPromiseResolver> m_resolver;
 };
 
 // FIXME: Consider using CallbackPromiseAdapter.
 class CacheWithRequestsCallbacks : public WebServiceWorkerCache::CacheWithRequestsCallbacks {
     WTF_MAKE_NONCOPYABLE(CacheWithRequestsCallbacks);
 public:
-    CacheWithRequestsCallbacks(PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver)
+    CacheWithRequestsCallbacks(ScriptPromiseResolver* resolver)
         : m_resolver(resolver) { }
 
     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();
     }
 
     // Ownership of |rawReason| must be passed.
     void onError(WebServiceWorkerCacheError* rawReason) override
     {
         OwnPtr<WebServiceWorkerCacheError> reason = adoptPtr(rawReason);
         m_resolver->reject(CacheStorageError::createException(*reason));
         m_resolver.clear();
     }
 
 private:
-    RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver;
+    Persistent<ScriptPromiseResolver> m_resolver;
 };
 
 // This class provides Promise.all() for ScriptPromise.
 // TODO(nhiroki): Move this somewhere else so that other components can reuse.
 // TODO(nhiroki): Unfortunately, we have to go through V8 to wait for the fetch
 // promise. It should be better to achieve this only within C++ world.
 class CacheStoragePromiseAll final : public GarbageCollectedFinalized<CacheStoragePromiseAll> {
 public:
-    CacheStoragePromiseAll(Vector<ScriptPromise> promises, PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver)
+    CacheStoragePromiseAll(Vector<ScriptPromise> promises, ScriptPromiseResolver* resolver)
         : m_numberOfPendingPromises(promises.size())
         , m_resolver(resolver)
     {
         m_values.resize(promises.size());
         for (size_t i = 0; i < promises.size(); ++i)
             promises[i].then(createFulfillFunction(i), createRejectFunction());
     }
 
     void onFulfilled(size_t index, const ScriptValue& value)
     {
@@ skipping 67 matching lines @@
     {
         return AdapterFunction::create(m_resolver->scriptState(), AdapterFunction::Fulfilled, index, this);
     }
 
     v8::Local<v8::Function> createRejectFunction()
     {
         return AdapterFunction::create(m_resolver->scriptState(), AdapterFunction::Rejected, 0, this);
     }
 
     size_t m_numberOfPendingPromises;
-    RefPtrWillBeMember<ScriptPromiseResolver> m_resolver;
+    Member<ScriptPromiseResolver> m_resolver;
     bool m_isSettled = false;
     Vector<ScriptValue> m_values;
 };
 
 } // namespace
 
 class Cache::FetchResolvedForAdd final : public ScriptFunction {
 public:
     static v8::Local<v8::Function> create(ScriptState* scriptState, Cache* cache, const HeapVector<Member<Request>>& requests)
     {
@@ skipping 23 matching lines @@
         , m_requests(requests)
     {
     }
 
     Member<Cache> m_cache;
     HeapVector<Member<Request>> m_requests;
 };
 
 class Cache::BarrierCallbackForPut final : public GarbageCollectedFinalized<BarrierCallbackForPut> {
 public:
-    BarrierCallbackForPut(int numberOfOperations, Cache* cache, PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver)
+    BarrierCallbackForPut(int numberOfOperations, Cache* cache, ScriptPromiseResolver* resolver)
         : m_numberOfRemainingOperations(numberOfOperations)
         , m_cache(cache)
         , m_resolver(resolver)
     {
         ASSERT(0 < m_numberOfRemainingOperations);
         m_batchOperations.resize(numberOfOperations);
     }
 
     void onSuccess(size_t index, const WebServiceWorkerCache::BatchOperation& batchOperation)
     {
@@ skipping 19 matching lines @@
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_cache);
         visitor->trace(m_resolver);
     }
 
 private:
     bool m_completed = false;
     int m_numberOfRemainingOperations;
     Member<Cache> m_cache;
-    RefPtrWillBeMember<ScriptPromiseResolver> m_resolver;
+    Member<ScriptPromiseResolver> m_resolver;
     Vector<WebServiceWorkerCache::BatchOperation> m_batchOperations;
 };
 
 class Cache::BlobHandleCallbackForPut final : public GarbageCollectedFinalized<BlobHandleCallbackForPut>, public FetchDataLoader::Client {
     USING_GARBAGE_COLLECTED_MIXIN(BlobHandleCallbackForPut);
 public:
     BlobHandleCallbackForPut(size_t index, BarrierCallbackForPut* barrierCallback, Request* request, Response* response)
         : m_index(index)
         , m_barrierCallback(barrierCallback)
     {
@@ skipping 140 matching lines @@
 
 Cache::Cache(WeakPtr<GlobalFetch::ScopedFetcher> fetcher, WebServiceWorkerCache* webCache)
     : m_scopedFetcher(fetcher)
     , 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);
+    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);
+    ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
     m_webCache->dispatchMatchAll(new CacheWithResponsesCallbacks(resolver), webRequest, toWebQueryParams(options));
     return promise;
 }
 
 ScriptPromise Cache::addAllImpl(ScriptState* scriptState, const HeapVector<Member<Request>>& requests, ExceptionState& exceptionState)
 {
     Vector<RequestInfo> requestInfos;
     requestInfos.resize(requests.size());
     Vector<ScriptPromise> promises;
     promises.resize(requests.size());
     for (size_t i = 0; i < requests.size(); ++i) {
         if (!requests[i]->url().protocolIsInHTTPFamily())
             return ScriptPromise::reject(scriptState, V8ThrowException::createTypeError(scriptState->isolate(), "Add/AddAll does not support schemes other than \"http\" or \"https\""));
         if (requests[i]->method() != "GET")
             return ScriptPromise::reject(scriptState, V8ThrowException::createTypeError(scriptState->isolate(), "Add/AddAll only supports the GET request method."));
         requestInfos[i].setRequest(requests[i]);
 
         promises[i] = m_scopedFetcher->fetch(scriptState, requestInfos[i], Dictionary(), exceptionState);
     }
 
-    RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
-    CacheStoragePromiseAll* promiseAll = new CacheStoragePromiseAll(promises, resolver.get());
+    ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
+    CacheStoragePromiseAll* promiseAll = new CacheStoragePromiseAll(promises, resolver);
     return promiseAll->promise().then(FetchResolvedForAdd::create(scriptState, this, requests));
 }
 
 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);
+    ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
     m_webCache->dispatchBatch(new CacheDeleteCallback(resolver), batchOperations);
     return promise;
 }
 
 ScriptPromise Cache::putImpl(ScriptState* scriptState, const HeapVector<Member<Request>>& requests, const HeapVector<Member<Response>>& responses)
 {
-    RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     const ScriptPromise promise = resolver->promise();
-    BarrierCallbackForPut* barrierCallback = new BarrierCallbackForPut(requests.size(), this, resolver.get());
+    BarrierCallbackForPut* barrierCallback = new BarrierCallbackForPut(requests.size(), this, resolver);
 
     for (size_t i = 0; i < requests.size(); ++i) {
         KURL url(KURL(), requests[i]->url());
         if (!url.protocolIsInHTTPFamily()) {
             barrierCallback->onError("Request scheme '" + url.protocol() + "' is unsupported");
             return promise;
         }
         if (requests[i]->method() != "GET") {
             barrierCallback->onError("Request method '" + requests[i]->method() + "' is unsupported");
             return promise;
@@ skipping 25 matching lines @@
         requests[i]->populateWebServiceWorkerRequest(batchOperation.request);
         responses[i]->populateWebServiceWorkerResponse(batchOperation.response);
         barrierCallback->onSuccess(i, batchOperation);
     }
 
     return promise;
 }
 
 ScriptPromise Cache::keysImpl(ScriptState* scriptState)
 {
-    RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    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);
+    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