PaymentApp: Implement respondWith() in PaymentRequestEvent. (content side)

content/renderer/service_worker/service_worker_context_client.cc

 // Copyright 2015 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 "content/renderer/service_worker/service_worker_context_client.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/lazy_instance.h"
@@ skipping 42 matching lines @@
 #include "ipc/ipc_message_macros.h"
 #include "third_party/WebKit/public/platform/URLConversion.h"
 #include "third_party/WebKit/public/platform/WebMessagePortChannel.h"
 #include "third_party/WebKit/public/platform/WebReferrerPolicy.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURLResponse.h"
 #include "third_party/WebKit/public/platform/modules/background_fetch/WebBackgroundFetchSettledFetch.h"
 #include "third_party/WebKit/public/platform/modules/notifications/WebNotificationData.h"
 #include "third_party/WebKit/public/platform/modules/payments/WebPaymentAppRequest.h"
+#include "third_party/WebKit/public/platform/modules/payments/WebPaymentAppResponse.h"
 #include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerClientQueryOptions.h"
 #include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerError.h"
 #include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerNetworkProvider.h"
 #include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerRequest.h"
 #include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerResponse.h"
 #include "third_party/WebKit/public/web/modules/serviceworker/WebServiceWorkerContextClient.h"
 #include "third_party/WebKit/public/web/modules/serviceworker/WebServiceWorkerContextProxy.h"
 
 namespace content {
 
@@ skipping 186 matching lines @@
       IDMap<std::unique_ptr<const DispatchActivateEventCallback>>;
   using BackgroundFetchAbortEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchBackgroundFetchAbortEventCallback>>;
   using BackgroundFetchClickEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchBackgroundFetchClickEventCallback>>;
   using BackgroundFetchFailEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchBackgroundFetchFailEventCallback>>;
   using BackgroundFetchedEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchBackgroundFetchedEventCallback>>;
   using SyncEventCallbacksMap = IDMap<std::unique_ptr<const SyncCallback>>;
-  using PaymentRequestEventCallbacksMap =
-      IDMap<std::unique_ptr<const PaymentRequestEventCallback>>;
   using NotificationClickEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchNotificationClickEventCallback>>;
   using NotificationCloseEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchNotificationCloseEventCallback>>;
   using PushEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchPushEventCallback>>;
   using FetchEventCallbacksMap = IDMap<std::unique_ptr<const FetchCallback>>;
   using ExtendableMessageEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchExtendableMessageEventCallback>>;
   using NavigationPreloadRequestsMap = IDMap<
@@ skipping 33 matching lines @@
 
   // Pending callbacks for Background Fetch Fail Events.
   BackgroundFetchFailEventCallbacksMap background_fetch_fail_event_callbacks;
 
   // Pending callbacks for Background Fetched Events.
   BackgroundFetchedEventCallbacksMap background_fetched_event_callbacks;
 
   // Pending callbacks for Background Sync Events.
   SyncEventCallbacksMap sync_event_callbacks;
 
+  // Pending callbacks for Payment App Response.
+  std::map<int /* payment_request_id */,
+           payments::mojom::PaymentAppResponseCallbackPtr>
+      payment_response_callbacks;
+
   // Pending callbacks for Payment Request Events.
-  PaymentRequestEventCallbacksMap payment_request_event_callbacks;
+  std::map<int /* payment_request_id */,
+           const DispatchPaymentRequestEventCallback>
+      payment_request_event_callbacks;
 
   // Pending callbacks for Notification Click Events.
   NotificationClickEventCallbacksMap notification_click_event_callbacks;
 
   // Pending callbacks for Notification Close Events.
   NotificationCloseEventCallbacksMap notification_close_event_callbacks;
 
   // Pending callbacks for Push Events.
   PushEventCallbacksMap push_event_callbacks;
 
@@ skipping 572 matching lines @@
     blink::WebServiceWorkerEventResult result,
     double event_dispatch_time) {
   const SyncCallback* callback =
       context_->sync_event_callbacks.Lookup(request_id);
   DCHECK(callback);
   callback->Run(EventResultToStatus(result),
                 base::Time::FromDoubleT(event_dispatch_time));
   context_->sync_event_callbacks.Remove(request_id);
 }
 
+void ServiceWorkerContextClient::respondToPaymentRequestEvent(
+    int payment_request_id,
+    const blink::WebPaymentAppResponse& web_response,
+    double dispatch_event_time) {
+  const payments::mojom::PaymentAppResponseCallbackPtr& response_callback =
+      context_->payment_response_callbacks[payment_request_id];
+  payments::mojom::PaymentAppResponsePtr response =
+      payments::mojom::PaymentAppResponse::New();
+  response->method_name = web_response.methodName.utf8();
+  response_callback->OnPaymentAppResponse(
+      std::move(response), base::Time::FromDoubleT(dispatch_event_time));
+  context_->payment_response_callbacks.erase(payment_request_id);
+}
+
 void ServiceWorkerContextClient::didHandlePaymentRequestEvent(
-    int request_id,
+    int payment_request_id,
     blink::WebServiceWorkerEventResult result,
     double event_dispatch_time) {
-  const PaymentRequestEventCallback* callback =
-      context_->payment_request_event_callbacks.Lookup(request_id);
-  DCHECK(callback);
-  callback->Run(EventResultToStatus(result),
-                base::Time::FromDoubleT(event_dispatch_time));
-  context_->payment_request_event_callbacks.Remove(request_id);
+  const DispatchPaymentRequestEventCallback& callback =
+      context_->payment_request_event_callbacks[payment_request_id];
+  callback.Run(EventResultToStatus(result),
+               base::Time::FromDoubleT(event_dispatch_time));
+  context_->payment_request_event_callbacks.erase(payment_request_id);
 }
 
 blink::WebServiceWorkerNetworkProvider*
 ServiceWorkerContextClient::createServiceWorkerNetworkProvider() {
   DCHECK(main_thread_task_runner_->RunsTasksOnCurrentThread());
 
   // Create a content::ServiceWorkerNetworkProvider for this data source so
   // we can observe its requests.
   std::unique_ptr<ServiceWorkerNetworkProvider> provider =
       base::MakeUnique<ServiceWorkerNetworkProvider>(
@@ skipping 83 matching lines @@
       mojo::ConvertTo<blink::WebServiceWorkerContextProxy::LastChanceOption>(
           last_chance);
 
   // TODO(jkarlin): Make this blink::WebString::FromUTF8Lenient once
   // https://crrev.com/1768063002/ lands.
   proxy_->dispatchSyncEvent(request_id, blink::WebString::fromUTF8(tag),
                             web_last_chance);
 }
 
 void ServiceWorkerContextClient::DispatchPaymentRequestEvent(
+    int payment_request_id,
     payments::mojom::PaymentAppRequestPtr app_request,
+    payments::mojom::PaymentAppResponseCallbackPtr response_callback,
     const DispatchPaymentRequestEventCallback& callback) {
-  int request_id = context_->payment_request_event_callbacks.Add(
-      base::MakeUnique<PaymentRequestEventCallback>(callback));
+  TRACE_EVENT0("ServiceWorker",
+               "ServiceWorkerContextClient::DispatchPaymentRequestEvent");
+  context_->payment_response_callbacks.insert(
+      std::make_pair(payment_request_id, std::move(response_callback)));
+  context_->payment_request_event_callbacks.insert(
+      std::make_pair(payment_request_id, callback));
+
   blink::WebPaymentAppRequest webAppRequest =
       mojo::ConvertTo<blink::WebPaymentAppRequest>(std::move(app_request));
-  proxy_->dispatchPaymentRequestEvent(request_id, webAppRequest);
+  proxy_->dispatchPaymentRequestEvent(payment_request_id, webAppRequest);
 }
 
 void ServiceWorkerContextClient::Send(IPC::Message* message) {
   sender_->Send(message);
 }
 
 void ServiceWorkerContextClient::SendWorkerStarted() {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
                          "ServiceWorkerContextClient::StartingWorkerContext",
@@ skipping 429 matching lines @@
 }
 
 base::WeakPtr<ServiceWorkerContextClient>
 ServiceWorkerContextClient::GetWeakPtr() {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(context_);
   return context_->weak_factory.GetWeakPtr();
 }
 
 }  // namespace content