PaymentApp: Implement invokePaymentApp() in renderer side.

content/renderer/service_worker/service_worker_context_client.cc

Index: content/renderer/service_worker/service_worker_context_client.cc
diff --git a/content/renderer/service_worker/service_worker_context_client.cc b/content/renderer/service_worker/service_worker_context_client.cc
index 3a0baf07e43286805bf9413ec531e2a913d9274e..57cf7906bdb4efaad94901fd650a93217e0f0c6e 100644
--- a/content/renderer/service_worker/service_worker_context_client.cc
+++ b/content/renderer/service_worker/service_worker_context_client.cc
@@ -38,6 +38,7 @@
 #include "content/common/service_worker/service_worker_event_dispatcher.mojom.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/common/service_worker/service_worker_status_code.h"
+#include "content/common/service_worker/service_worker_type_converters.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/common/push_event_payload.h"
 #include "content/public/common/referrer.h"
@@ -58,6 +59,7 @@
 #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/WebPaymentAppRequestData.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"
@@ -204,6 +206,8 @@ struct ServiceWorkerContextClient::WorkerContextData {
   using SkipWaitingCallbacksMap =
       IDMap<std::unique_ptr<blink::WebServiceWorkerSkipWaitingCallbacks>>;
   using SyncEventCallbacksMap = IDMap<std::unique_ptr<const SyncCallback>>;
+  using PaymentRequestEventCallbacksMap =
+      IDMap<std::unique_ptr<const PaymentRequestEventCallback>>;
   using PushEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchPushEventCallback>>;
   using FetchEventCallbacksMap = IDMap<std::unique_ptr<const FetchCallback>>;
@@ -238,6 +242,9 @@ struct ServiceWorkerContextClient::WorkerContextData {
   // Pending callbacks for Background Sync Events.
   SyncEventCallbacksMap sync_event_callbacks;
 
+  // Pending callbacks for Payment Request Events.
+  PaymentRequestEventCallbacksMap payment_request_event_callbacks;
+
   // Pending callbacks for Push Events.
   PushEventCallbacksMap push_event_callbacks;
 
@@ -750,6 +757,18 @@ void ServiceWorkerContextClient::didHandleSyncEvent(
   context_->sync_event_callbacks.Remove(request_id);
 }
 
+void ServiceWorkerContextClient::didHandlePaymentRequestEvent(
+    int 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);
+}
+
 blink::WebServiceWorkerNetworkProvider*
 ServiceWorkerContextClient::createServiceWorkerNetworkProvider(
     blink::WebDataSource* data_source) {
@@ -868,7 +887,11 @@ void ServiceWorkerContextClient::DispatchSyncEvent(
 void ServiceWorkerContextClient::DispatchPaymentRequestEvent(
     payments::mojom::PaymentAppRequestDataPtr data,
     const DispatchPaymentRequestEventCallback& callback) {
-  NOTIMPLEMENTED();
+  int request_id = context_->payment_request_event_callbacks.Add(

[tommyt, 2017/01/23 12:54:30]

I think it might be better to do the following here:

  context_->payment_request_event_callbacks.AddWithID(
      base::MakeUnique<PaymentRequestEventCallback>(callback), event_id);

(and replace "request_id" with "event_id" below).

The reason is that later on we are going to want to receive a response back from
the service worker's event handler (when the script resolves the promise from
respondWith). This depends, of course, on how you want to implement the response
handling, but in my own experiment, I implemented it as a call to
active_version->RegisterRequestCallback() from
payment_app_provider_impl.cc:DispatchPaymentRequestEvent(). If you want to do it
this way, too, then you'll want to pass the same request_id to
ServiceWorkerVersion::RegisterRequestCallback() as you pass to
ServiceWorkerGlobalScopeProxy::dispatchPaymentRequestEvent().

[zino, 2017/02/01 09:24:48]

Good point. Yes, we might have to do that later.
But I don't want to add it in this patch because the respondWith function is not
implemented yet.

IMHO, the addWithID() is used to explicitly specify the ID generated from
browser side with the same value.
Because the RegisterRequestCallback() will use the request event id to call its
callback.
The RegisterRequestCallback() is using legacy IPC. So, it's not a right way.
Moreover, we should call the startRequest() function two times in browser side
in order to use RegisterRequestCallback().
because we have to consider waitUntil as well as respondWith. It's not goal in
this CL.

When implementing respondWith() function (in follow-up CL), then we can use the
addWithID if we really need it.

[tommyt, 2017/02/01 09:42:00]

I agree. Let's leave this for later.

+      base::MakeUnique<PaymentRequestEventCallback>(callback));
+  blink::WebPaymentAppRequestData webData =
+      mojo::ConvertTo<blink::WebPaymentAppRequestData>(std::move(data));
+  proxy_->dispatchPaymentRequestEvent(request_id, webData);
 }
 
 void ServiceWorkerContextClient::Send(IPC::Message* message) {