[WIP] RespondWithObserver

third_party/WebKit/Source/modules/serviceworkers/PaymentRequestRespondWithObserver.cpp

+// Copyright 2017 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/serviceworkers/PaymentRequestRespondWithObserver.h"
+
+#include <v8.h>
+#include "bindings/core/v8/ScriptValue.h"
+#include "bindings/core/v8/V8Binding.h"
+#include "bindings/modules/v8/V8PaymentAppResponse.h"
+#include "core/dom/ExecutionContext.h"
+#include "core/inspector/ConsoleMessage.h"
+#include "modules/payments/PaymentAppResponse.h"
+#include "modules/serviceworkers/ServiceWorkerGlobalScopeClient.h"
+#include "modules/serviceworkers/WaitUntilObserver.h"
+#include "public/platform/modules/payments/WebPaymentAppResponse.h"
+
+namespace blink {
+namespace {
+
+// Returns the error message to let the developer know about the reason of the
+// unusual failures.
+const String getMessageForResponseError(WebServiceWorkerResponseError error) {
+  String errorMessage =
+      "The PaymentRequestEvent resulted in a network error response: ";
+  switch (error) {
+    case WebServiceWorkerResponseErrorPromiseRejected:
+      errorMessage = errorMessage + "the promise was rejected.";
+      break;
+    case WebServiceWorkerResponseErrorDefaultPrevented:
+      errorMessage =
+          errorMessage +
+          "preventDefault() was called without calling respondWith().";
+      break;
+    case WebServiceWorkerResponseErrorNoV8Instance:
+      errorMessage = errorMessage +
+                     "an object that was not a PaymentResponse was passed to "
+                     "respondWith().";
+      break;
+    case WebServiceWorkerResponseErrorResponseTypeError:
+      errorMessage = errorMessage +
+                     "the promise was resolved with an error response object.";
+      break;
+    case WebServiceWorkerResponseErrorUnknown:
+    default:
+      errorMessage = errorMessage + "an unexpected error occurred.";
+      break;
+  }
+  return errorMessage;
+}
+
+}  // namespace
+
+PaymentRequestRespondWithObserver::~PaymentRequestRespondWithObserver() {}
+
+PaymentRequestRespondWithObserver* PaymentRequestRespondWithObserver::create(
+    ExecutionContext* context,
+    int eventID,
+    WaitUntilObserver* observer) {
+  return new PaymentRequestRespondWithObserver(context, eventID, observer);
+}
+
+void PaymentRequestRespondWithObserver::didDispatchEvent(
+    DispatchEventResult dispatchResult) {
+  DCHECK(getExecutionContext());
+  if (m_state != Initial)
+    return;
+
+  if (dispatchResult != DispatchEventResult::NotCanceled) {
+    m_observer->incrementPendingActivity();
+    responseWasRejected(WebServiceWorkerResponseErrorDefaultPrevented);
+    return;
+  }
+
+  WebPaymentAppResponse webData;
+  ServiceWorkerGlobalScopeClient::from(getExecutionContext())
+      ->respondToPaymentRequestEvent(m_eventID, webData, m_eventDispatchTime);
+  m_state = Done;
+  m_observer.clear();
+}
+
+void PaymentRequestRespondWithObserver::responseWasRejected(
+    WebServiceWorkerResponseError error) {
+  DCHECK(getExecutionContext());
+
+  getExecutionContext()->addConsoleMessage(ConsoleMessage::create(
+      JSMessageSource, WarningMessageLevel, getMessageForResponseError(error)));
+
+  WebPaymentAppResponse webData;
+  ServiceWorkerGlobalScopeClient::from(getExecutionContext())
+      ->respondToPaymentRequestEvent(m_eventID, webData, m_eventDispatchTime);
+  RespondWithObserver::responseWasRejected(error);
+}
+
+void PaymentRequestRespondWithObserver::responseWasFulfilled(
+    const ScriptValue& value) {
+  DCHECK(getExecutionContext());
+
+  PaymentAppResponse response;
+  DummyExceptionStateForTesting exceptionState;
+  V8PaymentAppResponse::toImpl(toIsolate(getExecutionContext()),
+                               value.v8Value(), response, exceptionState);
+
+  if (exceptionState.hadException()) {
+    responseWasRejected(WebServiceWorkerResponseErrorNoV8Instance);
+    return;
+  }
+
+  WebPaymentAppResponse webData;
+  webData.methodName = WebString(AtomicString(response.methodName()));
+
+  v8::Local<v8::String> detailsValue;
+  if (!v8::JSON::Stringify(response.details().context(),
+                           response.details().v8Value().As<v8::Object>())
+           .ToLocal(&detailsValue)) {
+    responseWasRejected(WebServiceWorkerResponseErrorUnknown);
+    return;
+  }
+  webData.stringifiedDetails = WebString(AtomicString(
+      v8StringToWebCoreString<String>(detailsValue, DoNotExternalize)));
+  ServiceWorkerGlobalScopeClient::from(getExecutionContext())
+      ->respondToPaymentRequestEvent(m_eventID, webData, m_eventDispatchTime);
+  RespondWithObserver::responseWasFulfilled(value);
+}
+
+PaymentRequestRespondWithObserver::PaymentRequestRespondWithObserver(
+    ExecutionContext* context,
+    int eventID,
+    WaitUntilObserver* observer)
+    : RespondWithObserver(context, eventID, observer) {}
+
+DEFINE_TRACE(PaymentRequestRespondWithObserver) {
+  RespondWithObserver::trace(visitor);
+}
+
+}  // namespace blink