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 41 matching lines @@
 #include "ipc/ipc_message.h"
 #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/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/WebServiceWorkerRequest.h"
 #include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerResponse.h"
 #include "third_party/WebKit/public/web/WebDataSource.h"
 #include "third_party/WebKit/public/web/modules/serviceworker/WebServiceWorkerContextClient.h"
 #include "third_party/WebKit/public/web/modules/serviceworker/WebServiceWorkerContextProxy.h"
 #include "third_party/WebKit/public/web/modules/serviceworker/WebServiceWorkerNetworkProvider.h"
 
 namespace content {
@@ skipping 117 matching lines @@
       IDMap<std::unique_ptr<blink::WebServiceWorkerClientsCallbacks>>;
   using ClaimClientsCallbacksMap =
       IDMap<std::unique_ptr<blink::WebServiceWorkerClientsClaimCallbacks>>;
   using ClientCallbacksMap =
       IDMap<std::unique_ptr<blink::WebServiceWorkerClientCallbacks>>;
   using SkipWaitingCallbacksMap =
       IDMap<std::unique_ptr<blink::WebServiceWorkerSkipWaitingCallbacks>>;
   using ActivateEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchActivateEventCallback>>;
   using SyncEventCallbacksMap = IDMap<std::unique_ptr<const SyncCallback>>;
+  using PaymentResponseCallbacksMap =
+      IDMap<std::unique_ptr<mojom::PaymentAppResponseCallbackPtr>>;

[shimazu, 2017/03/08 01:39:40]

IDMap was originally used here, but now we can use std::map<somecallback>
instead. I'm now planning to convert IDMaps to std::map. 
Could you also use std::map here if possible?

[zino, 2017/03/19 04:47:23]

Done.

   using PaymentRequestEventCallbacksMap =
-      IDMap<std::unique_ptr<const PaymentRequestEventCallback>>;
+      IDMap<std::unique_ptr<const DispatchPaymentRequestEventCallback>>;
   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 21 matching lines @@
 
   // Pending callbacks for ClaimClients().
   ClaimClientsCallbacksMap claim_clients_callbacks;
 
   // Pending callbacks for Activate Events.
   ActivateEventCallbacksMap activate_event_callbacks;
 
   // Pending callbacks for Background Sync Events.
   SyncEventCallbacksMap sync_event_callbacks;
 
+  // Pending callbacks for Payment App Response.
+  PaymentResponseCallbacksMap payment_response_callbacks;
+
   // Pending callbacks for Payment Request Events.
   PaymentRequestEventCallbacksMap 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.
@@ skipping 523 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 event_id,

[shimazu, 2017/03/08 01:39:40]

|payment_request_id|

[zino, 2017/03/19 04:47:23]

Done.

+    const blink::WebPaymentAppResponse& web_response,
+    double dispatch_event_time) {
+  mojom::PaymentAppResponseCallbackPtr* response_callback =
+      context_->payment_response_callbacks.Lookup(event_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.Remove(event_id);
+}
+
 void ServiceWorkerContextClient::didHandlePaymentRequestEvent(
-    int request_id,
+    int event_id,
     blink::WebServiceWorkerEventResult result,
     double event_dispatch_time) {
-  const PaymentRequestEventCallback* callback =
-      context_->payment_request_event_callbacks.Lookup(request_id);
+  const DispatchPaymentRequestEventCallback* callback =
+      context_->payment_request_event_callbacks.Lookup(event_id);
   DCHECK(callback);
   callback->Run(EventResultToStatus(result),
                 base::Time::FromDoubleT(event_dispatch_time));
-  context_->payment_request_event_callbacks.Remove(request_id);
+  context_->payment_request_event_callbacks.Remove(event_id);
 }
 
 blink::WebServiceWorkerNetworkProvider*
 ServiceWorkerContextClient::createServiceWorkerNetworkProvider(
     blink::WebDataSource* data_source) {
   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 =
@@ skipping 91 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 event_id,

[shimazu, 2017/03/08 01:39:39]

|payment_request_id|

[zino, 2017/03/19 04:47:23]

Done.

     payments::mojom::PaymentAppRequestPtr app_request,
+    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.AddWithID(
+      base::MakeUnique<mojom::PaymentAppResponseCallbackPtr>(
+          std::move(response_callback)),
+      event_id);
+  context_->payment_request_event_callbacks.AddWithID(
+      base::MakeUnique<DispatchPaymentRequestEventCallback>(callback),
+      event_id);
+
   blink::WebPaymentAppRequest webAppRequest =
       mojo::ConvertTo<blink::WebPaymentAppRequest>(std::move(app_request));
-  proxy_->dispatchPaymentRequestEvent(request_id, webAppRequest);
+  proxy_->dispatchPaymentRequestEvent(event_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 382 matching lines @@
 }
 
 base::WeakPtr<ServiceWorkerContextClient>
 ServiceWorkerContextClient::GetWeakPtr() {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(context_);
   return context_->weak_factory.GetWeakPtr();
 }
 
 }  // namespace content