Have ScriptPromiseResolver on the Oilpan heap always.

Source/modules/serviceworkers/ServiceWorkerContainer.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 41 matching lines @@
 #include "public/platform/WebServiceWorker.h"
 #include "public/platform/WebServiceWorkerProvider.h"
 #include "public/platform/WebServiceWorkerRegistration.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebURL.h"
 
 namespace blink {
 
 class RegistrationCallback : public WebServiceWorkerProvider::WebServiceWorkerRegistrationCallbacks {
 public:
-    explicit RegistrationCallback(PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver)
+    explicit RegistrationCallback(ScriptPromiseResolver* resolver)
         : m_resolver(resolver) { }
     ~RegistrationCallback() override { }
 
     void onSuccess(WebServiceWorkerRegistration* registration) override
     {
         if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
             return;
         m_resolver->resolve(ServiceWorkerRegistration::take(m_resolver.get(), registration));
     }
 
     // Takes ownership of |errorRaw|.
     void onError(WebServiceWorkerError* errorRaw) override
     {
         OwnPtr<WebServiceWorkerError> error = adoptPtr(errorRaw);
         if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
             return;
         m_resolver->reject(ServiceWorkerError::take(m_resolver.get(), error.release()));
     }
 
 private:
-    RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver;
+    Persistent<ScriptPromiseResolver> m_resolver;
     WTF_MAKE_NONCOPYABLE(RegistrationCallback);
 };
 
 class GetRegistrationCallback : public WebServiceWorkerProvider::WebServiceWorkerGetRegistrationCallbacks {
 public:
-    explicit GetRegistrationCallback(PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver)
+    explicit GetRegistrationCallback(ScriptPromiseResolver* resolver)
         : m_resolver(resolver) { }
     ~GetRegistrationCallback() override { }
 
     void onSuccess(WebServiceWorkerRegistration* registration) override
     {
         if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
             return;
         if (!registration) {
             // Resolve the promise with undefined.
             m_resolver->resolve();
             return;
         }
         m_resolver->resolve(ServiceWorkerRegistration::take(m_resolver.get(), registration));
     }
 
     // Takes ownership of |errorRaw|.
     void onError(WebServiceWorkerError* errorRaw) override
     {
         OwnPtr<WebServiceWorkerError> error = adoptPtr(errorRaw);
         if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
             return;
         m_resolver->reject(ServiceWorkerError::take(m_resolver.get(), error.release()));
     }
 
 private:
-    RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver;
+    Persistent<ScriptPromiseResolver> m_resolver;
     WTF_MAKE_NONCOPYABLE(GetRegistrationCallback);
 };
 
 class GetRegistrationsCallback : public WebServiceWorkerProvider::WebServiceWorkerGetRegistrationsCallbacks {
 public:
-    explicit GetRegistrationsCallback(PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver)
+    explicit GetRegistrationsCallback(ScriptPromiseResolver* resolver)
         : m_resolver(resolver) { }
     ~GetRegistrationsCallback() override { }
 
     // Takes ownership of |registrationsRaw|.
     void onSuccess(WebVector<WebServiceWorkerRegistration*>* registrationsRaw) override
     {
         OwnPtr<WebVector<WebServiceWorkerRegistration*>> registrations = adoptPtr(registrationsRaw);
         if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
             return;
         m_resolver->resolve(ServiceWorkerRegistrationArray::take(m_resolver.get(), registrations.release()));
     }
 
     // Takes ownership of |errorRaw|.
     void onError(WebServiceWorkerError* errorRaw) override
     {
         OwnPtr<WebServiceWorkerError> error = adoptPtr(errorRaw);
         if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped())
             return;
         m_resolver->reject(ServiceWorkerError::take(m_resolver.get(), error.release()));
     }
 
 private:
-    RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver;
+    Persistent<ScriptPromiseResolver> m_resolver;
     WTF_MAKE_NONCOPYABLE(GetRegistrationsCallback);
 };
 
 class ServiceWorkerContainer::GetRegistrationForReadyCallback : public WebServiceWorkerProvider::WebServiceWorkerGetRegistrationForReadyCallbacks {
 public:
     explicit GetRegistrationForReadyCallback(ReadyProperty* ready)
         : m_ready(ready) { }
     ~GetRegistrationForReadyCallback() { }
     void onSuccess(WebServiceWorkerRegistration* registration) override
     {
@@ skipping 28 matching lines @@
 DEFINE_TRACE(ServiceWorkerContainer)
 {
     visitor->trace(m_controller);
     visitor->trace(m_ready);
     RefCountedGarbageCollectedEventTargetWithInlineData<ServiceWorkerContainer>::trace(visitor);
     ContextLifecycleObserver::trace(visitor);
 }
 
 ScriptPromise ServiceWorkerContainer::registerServiceWorker(ScriptState* scriptState, const String& url, const RegistrationOptions& options)
 {
-    RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
 
     if (!m_provider) {
         resolver->reject(DOMException::create(InvalidStateError, "Failed to register a ServiceWorker: The document is in an invalid state."));
         return promise;
     }
 
     ExecutionContext* executionContext = scriptState->executionContext();
     // FIXME: May be null due to worker termination: http://crbug.com/413518.
     if (!executionContext)
@@ skipping 42 matching lines @@
         return promise;
     }
 
     m_provider->registerServiceWorker(patternURL, scriptURL, new RegistrationCallback(resolver));
 
     return promise;
 }
 
 ScriptPromise ServiceWorkerContainer::getRegistration(ScriptState* scriptState, const String& documentURL)
 {
-    RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
 
     if (!m_provider) {
         resolver->reject(DOMException::create(InvalidStateError, "Failed to get a ServiceWorkerRegistration: The document is in an invalid state."));
         return promise;
     }
 
     ExecutionContext* executionContext = scriptState->executionContext();
     // FIXME: May be null due to worker termination: http://crbug.com/413518.
     if (!executionContext)
@@ skipping 19 matching lines @@
         resolver->reject(DOMException::create(SecurityError, "Failed to get a ServiceWorkerRegistration: The origin of the provided documentURL ('" + documentURLOrigin->toString() + "') does not match the current origin ('" + documentOrigin->toString() + "')."));
         return promise;
     }
     m_provider->getRegistration(completedURL, new GetRegistrationCallback(resolver));
 
     return promise;
 }
 
 ScriptPromise ServiceWorkerContainer::getRegistrations(ScriptState* scriptState)
 {
-    RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
 
     if (!m_provider) {
         resolver->reject(DOMException::create(InvalidStateError, "Failed to get ServiceWorkerRegistration objects: The document is in an invalid state."));
         return promise;
     }
 
     ExecutionContext* executionContext = scriptState->executionContext();
     RefPtr<SecurityOrigin> documentOrigin = executionContext->securityOrigin();
     String errorMessage;
@@ skipping 83 matching lines @@
         return;
 
     if (ServiceWorkerContainerClient* client = ServiceWorkerContainerClient::from(executionContext)) {
         m_provider = client->provider();
         if (m_provider)
             m_provider->setClient(this);
     }
 }
 
 } // namespace blink