ServiceWorker: Replace RegistrationCallback and GetRegistrationsCallback with CallbackPromiseAdapter

third_party/WebKit/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 11 matching lines @@
  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #include "modules/serviceworkers/ServiceWorkerContainer.h"
 
+#include "bindings/core/v8/CallbackPromiseAdapter.h"
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/SerializedScriptValue.h"
 #include "bindings/core/v8/SerializedScriptValueFactory.h"
 #include "bindings/core/v8/V8ThrowException.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
@@ skipping 13 matching lines @@
 #include "public/platform/WebURL.h"
 #include "public/platform/modules/serviceworker/WebServiceWorker.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerProvider.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerRegistration.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 #include <utility>
 
 namespace blink {
 
-class RegistrationCallback
-    : public WebServiceWorkerProvider::WebServiceWorkerRegistrationCallbacks {
- public:
-  explicit RegistrationCallback(ScriptPromiseResolver* resolver)
-      : m_resolver(resolver) {}
-  ~RegistrationCallback() override {}
-
-  void onSuccess(
-      std::unique_ptr<WebServiceWorkerRegistration::Handle> handle) override {
-    if (!m_resolver->getExecutionContext() ||
-        m_resolver->getExecutionContext()->isContextDestroyed())
-      return;
-    m_resolver->resolve(ServiceWorkerRegistration::getOrCreate(
-        m_resolver->getExecutionContext(), WTF::wrapUnique(handle.release())));
-  }
-
-  void onError(const WebServiceWorkerError& error) override {
-    if (!m_resolver->getExecutionContext() ||
-        m_resolver->getExecutionContext()->isContextDestroyed())
-      return;
-    ScriptState::Scope scope(m_resolver->getScriptState());
-    if (error.errorType == WebServiceWorkerError::ErrorTypeType) {
-      m_resolver->reject(V8ThrowException::createTypeError(
-          m_resolver->getScriptState()->isolate(), error.message));
-    } else {
-      m_resolver->reject(
-          ServiceWorkerErrorForUpdate::take(m_resolver.get(), error));
-    }
-  }
-
- private:
-  Persistent<ScriptPromiseResolver> m_resolver;
-  WTF_MAKE_NONCOPYABLE(RegistrationCallback);
-};
-
 class GetRegistrationCallback : public WebServiceWorkerProvider::
                                     WebServiceWorkerGetRegistrationCallbacks {
  public:
   explicit GetRegistrationCallback(ScriptPromiseResolver* resolver)
       : m_resolver(resolver) {}
   ~GetRegistrationCallback() override {}
 
   void onSuccess(std::unique_ptr<WebServiceWorkerRegistration::Handle>
                      webPassHandle) override {
     std::unique_ptr<WebServiceWorkerRegistration::Handle> handle =
@@ skipping 15 matching lines @@
         m_resolver->getExecutionContext()->isContextDestroyed())
       return;
     m_resolver->reject(ServiceWorkerError::take(m_resolver.get(), error));
   }
 
  private:
   Persistent<ScriptPromiseResolver> m_resolver;
   WTF_MAKE_NONCOPYABLE(GetRegistrationCallback);
 };
 
-class GetRegistrationsCallback : public WebServiceWorkerProvider::
-                                     WebServiceWorkerGetRegistrationsCallbacks {
- public:
-  explicit GetRegistrationsCallback(ScriptPromiseResolver* resolver)
-      : m_resolver(resolver) {}
-  ~GetRegistrationsCallback() override {}
-
-  void onSuccess(
-      std::unique_ptr<WebVector<WebServiceWorkerRegistration::Handle*>>
-          webPassRegistrations) override {
-    Vector<std::unique_ptr<WebServiceWorkerRegistration::Handle>> handles;
-    std::unique_ptr<WebVector<WebServiceWorkerRegistration::Handle*>>
-        webRegistrations = WTF::wrapUnique(webPassRegistrations.release());
-    for (auto& handle : *webRegistrations) {
-      handles.append(WTF::wrapUnique(handle));
-    }
-
-    if (!m_resolver->getExecutionContext() ||
-        m_resolver->getExecutionContext()->isContextDestroyed())
-      return;
-    m_resolver->resolve(
-        ServiceWorkerRegistrationArray::take(m_resolver.get(), &handles));
-  }
-
-  void onError(const WebServiceWorkerError& error) override {
-    if (!m_resolver->getExecutionContext() ||
-        m_resolver->getExecutionContext()->isContextDestroyed())
-      return;
-    m_resolver->reject(ServiceWorkerError::take(m_resolver.get(), error));
-  }
-
- private:
-  Persistent<ScriptPromiseResolver> m_resolver;
-  WTF_MAKE_NONCOPYABLE(GetRegistrationsCallback);
-};
-
 class ServiceWorkerContainer::GetRegistrationForReadyCallback
     : public WebServiceWorkerProvider::
           WebServiceWorkerGetRegistrationForReadyCallbacks {
  public:
   explicit GetRegistrationForReadyCallback(ReadyProperty* ready)
       : m_ready(ready) {}
   ~GetRegistrationForReadyCallback() override {}
 
   void onSuccess(
       std::unique_ptr<WebServiceWorkerRegistration::Handle> handle) override {
@@ skipping 170 matching lines @@
       enteredExecutionContext(scriptState->isolate())->completeURL(url);
   scriptURL.removeFragmentIdentifier();
 
   KURL patternURL;
   if (options.scope().isNull())
     patternURL = KURL(scriptURL, "./");
   else
     patternURL = enteredExecutionContext(scriptState->isolate())
                      ->completeURL(options.scope());
 
-  registerServiceWorkerImpl(executionContext, scriptURL, patternURL,
-                            WTF::makeUnique<RegistrationCallback>(resolver));
+  registerServiceWorkerImpl(
+      executionContext, scriptURL, patternURL,
+      WTF::makeUnique<CallbackPromiseAdapter<ServiceWorkerRegistration,
+                                             ServiceWorkerErrorForUpdate>>(
+          resolver));
 
   return promise;
 }
 
 ScriptPromise ServiceWorkerContainer::getRegistration(
     ScriptState* scriptState,
     const String& documentURL) {
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
 
@@ skipping 75 matching lines @@
           pageURL.protocol())) {
     resolver->reject(DOMException::create(
         SecurityError,
         "Failed to get ServiceWorkerRegistration objects: The URL protocol of "
         "the current origin ('" +
             documentOrigin->toString() + "') is not supported."));
     return promise;
   }
 
   m_provider->getRegistrations(
-      WTF::makeUnique<GetRegistrationsCallback>(resolver));
+      WTF::makeUnique<CallbackPromiseAdapter<ServiceWorkerRegistrationArray,
+                                             ServiceWorkerError>>(resolver));
 
   return promise;
 }
 
 ServiceWorkerContainer::ReadyProperty*
 ServiceWorkerContainer::createReadyProperty() {
   return new ReadyProperty(getExecutionContext(), this, ReadyProperty::Ready);
 }
 
 ScriptPromise ServiceWorkerContainer::ready(ScriptState* callerState) {
@@ skipping 63 matching lines @@
 
   if (ServiceWorkerContainerClient* client =
           ServiceWorkerContainerClient::from(executionContext)) {
     m_provider = client->provider();
     if (m_provider)
       m_provider->setClient(this);
   }
 }
 
 }  // namespace blink