PaymentApp: Implement PaymentAppManager.getManifest().

third_party/WebKit/Source/modules/payments/PaymentAppManager.cpp

 // Copyright 2016 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 "modules/payments/PaymentAppManager.h"
 
 #include "bindings/core/v8/ScriptPromise.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "core/dom/DOMException.h"
 #include "modules/payments/PaymentAppManifest.h"
@@ skipping 30 matching lines @@
     output->icon = input.hasIcon() ? input.icon() : WTF::String();
     if (input.hasOptions()) {
       for (size_t i = 0; i < input.options().size(); ++i) {
         output->options.append(PaymentAppOption::From(input.options()[i]));
       }
     }
     return output;
   }
 };
 
+template <>
+struct TypeConverter<blink::PaymentAppManifest, PaymentAppManifestPtr> {
+  static blink::PaymentAppManifest Convert(const PaymentAppManifestPtr& input) {
+    blink::PaymentAppManifest output;
+    output.setLabel(input->label);
+    output.setIcon(input->icon);
+    blink::HeapVector<blink::PaymentAppOption> options;
+    for (const auto& option : input->options) {
+      options.append(mojo::ConvertTo<blink::PaymentAppOption>(option));
+    }
+    output.setOptions(options);
+    return output;
+  }
+};
+
+template <>
+struct TypeConverter<blink::PaymentAppOption, PaymentAppOptionPtr> {
+  static blink::PaymentAppOption Convert(const PaymentAppOptionPtr& input) {
+    blink::PaymentAppOption output;
+    output.setLabel(input->label);
+    output.setIcon(input->icon);
+    output.setId(input->id);
+    Vector<WTF::String> enabledMethods;
+    for (const auto& method : input->enabled_methods) {
+      enabledMethods.append(method);
+    }
+    output.setEnabledMethods(enabledMethods);
+    return output;
+  }
+};
+
 }  // namespace mojo
 
 namespace blink {
 
 PaymentAppManager* PaymentAppManager::create(
     ScriptState* scriptState,
     ServiceWorkerRegistration* registration) {
   return new PaymentAppManager(scriptState, registration);
 }
 
-ScriptPromise PaymentAppManager::getManifest(ScriptState* scriptState) {
-  NOTIMPLEMENTED();
-  return ScriptPromise();
+void PaymentAppManager::contextDestroyed() {
+  m_manager.reset();
 }
 
 ScriptPromise PaymentAppManager::setManifest(
     ScriptState* scriptState,
     const PaymentAppManifest& manifest) {
   if (!m_manager) {
     return ScriptPromise::rejectWithDOMException(
         scriptState, DOMException::create(InvalidStateError,
                                           "Payment app manager unavailable."));
   }
 
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
   ScriptPromise promise = resolver->promise();
 
   m_manager->SetManifest(
       m_registration->scope(),
       payments::mojom::blink::PaymentAppManifest::From(manifest),
       convertToBaseCallback(WTF::bind(&PaymentAppManager::onSetManifest,
                                       wrapPersistent(this),
                                       wrapPersistent(resolver))));
 
   return promise;
 }
 
+ScriptPromise PaymentAppManager::getManifest(ScriptState* scriptState) {
+  if (!m_manager) {
+    return ScriptPromise::rejectWithDOMException(
+        scriptState, DOMException::create(InvalidStateError,
+                                          "Payment app manager unavailable."));
+  }
+
+  ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
+  ScriptPromise promise = resolver->promise();
+
+  m_manager->GetManifest(m_registration->scope(),
+                         convertToBaseCallback(WTF::bind(
+                             &PaymentAppManager::onGetManifest,
+                             wrapPersistent(this), wrapPersistent(resolver))));
+
+  return promise;
+}
+
+DEFINE_TRACE(PaymentAppManager) {
+  visitor->trace(m_registration);
+  ContextLifecycleObserver::trace(visitor);
+}
+
+PaymentAppManager::PaymentAppManager(ScriptState* scriptState,
+                                     ServiceWorkerRegistration* registration)
+    : ContextLifecycleObserver(scriptState->getExecutionContext()),
+      m_registration(registration) {
+  DCHECK(registration);
+  Platform::current()->interfaceProvider()->getInterface(
+      mojo::GetProxy(&m_manager));
+
+  m_manager.set_connection_error_handler(convertToBaseCallback(WTF::bind(
+      &PaymentAppManager::onServiceConnectionError, wrapWeakPersistent(this))));
+}
+
 void PaymentAppManager::onSetManifest(
     ScriptPromiseResolver* resolver,
     payments::mojom::blink::PaymentAppManifestError error) {
   DCHECK(resolver);
   switch (error) {
     case payments::mojom::blink::PaymentAppManifestError::NONE:
       resolver->resolve();
       break;
     case payments::mojom::blink::PaymentAppManifestError::NOT_IMPLEMENTED:
       resolver->reject(
           DOMException::create(NotSupportedError, "Not implemented yet."));
       break;
     case payments::mojom::blink::PaymentAppManifestError::NO_ACTIVE_WORKER:
       resolver->reject(
           DOMException::create(InvalidStateError, "No active service worker."));
       break;
-    case payments::mojom::blink::PaymentAppManifestError::STORE_MANIFEST_FAILED:
+    case payments::mojom::blink::PaymentAppManifestError::
+        MANIFEST_STORAGE_OPERATION_FAILED:
       resolver->reject(DOMException::create(
           InvalidStateError, "Storing manifest data is failed."));
       break;
   }
 }
 
-DEFINE_TRACE(PaymentAppManager) {
-  visitor->trace(m_registration);
-  ContextLifecycleObserver::trace(visitor);
-}
-
-PaymentAppManager::PaymentAppManager(ScriptState* scriptState,
-                                     ServiceWorkerRegistration* registration)
-    : ContextLifecycleObserver(scriptState->getExecutionContext()),
-      m_registration(registration) {
-  DCHECK(registration);
-  Platform::current()->interfaceProvider()->getInterface(
-      mojo::GetProxy(&m_manager));
-
-  m_manager.set_connection_error_handler(convertToBaseCallback(WTF::bind(
-      &PaymentAppManager::onServiceConnectionError, wrapWeakPersistent(this))));
+void PaymentAppManager::onGetManifest(
+    ScriptPromiseResolver* resolver,
+    payments::mojom::blink::PaymentAppManifestPtr manifest,
+    payments::mojom::blink::PaymentAppManifestError error) {
+  DCHECK(resolver);
+  switch (error) {
+    case payments::mojom::blink::PaymentAppManifestError::NONE:
+      resolver->resolve(
+          mojo::ConvertTo<PaymentAppManifest>(std::move(manifest)));
+      break;
+    case payments::mojom::blink::PaymentAppManifestError::NOT_IMPLEMENTED:
+      resolver->reject(
+          DOMException::create(NotSupportedError, "Not implemented yet."));
+      break;
+    case payments::mojom::blink::PaymentAppManifestError::NO_ACTIVE_WORKER:
+    case payments::mojom::blink::PaymentAppManifestError::
+        MANIFEST_STORAGE_OPERATION_FAILED:
+      resolver->reject(DOMException::create(
+          AbortError,
+          "No payment app manifest associated with the service worker."));
+      break;
+  }
 }
 
 void PaymentAppManager::onServiceConnectionError() {
   if (!Platform::current()) {
     return;
   }
 
   m_manager.reset();
 }
 
-void PaymentAppManager::contextDestroyed() {
-  m_manager.reset();
-}
-
 }  // namespace blink