PaymentApp: Implement invokePaymentApp() in renderer 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 20 matching lines @@
 #include "content/child/thread_safe_sender.h"
 #include "content/child/web_data_consumer_handle_impl.h"
 #include "content/child/web_url_loader_impl.h"
 #include "content/child/webmessageportchannel_impl.h"
 #include "content/common/devtools_messages.h"
 #include "content/common/message_port_messages.h"
 #include "content/common/service_worker/embedded_worker_messages.h"
 #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"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/public/renderer/document_state.h"
 #include "content/renderer/devtools/devtools_agent.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/service_worker/embedded_worker_devtools_agent.h"
 #include "content/renderer/service_worker/embedded_worker_dispatcher.h"
 #include "content/renderer/service_worker/embedded_worker_instance_client_impl.h"
 #include "content/renderer/service_worker/service_worker_type_util.h"
 #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/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"
 #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 126 matching lines @@
 struct ServiceWorkerContextClient::WorkerContextData {
   using ClientsCallbacksMap =
       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 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>>;
   using ExtendableMessageEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchExtendableMessageEventCallback>>;
   using NavigationPreloadRequestsMap = IDMap<
       std::unique_ptr<ServiceWorkerContextClient::NavigationPreloadRequest>>;
 
   explicit WorkerContextData(ServiceWorkerContextClient* owner)
       : event_dispatcher_binding(owner),
@@ skipping 14 matching lines @@
 
   // Pending callbacks for SkipWaiting().
   SkipWaitingCallbacksMap skip_waiting_callbacks;
 
   // Pending callbacks for ClaimClients().
   ClaimClientsCallbacksMap claim_clients_callbacks;
 
   // 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;
 
   // Pending callbacks for Fetch Events.
   FetchEventCallbacksMap fetch_event_callbacks;
 
   // Pending callbacks for Extendable Message Events.
   ExtendableMessageEventCallbacksMap message_event_callbacks;
 
   // Pending navigation preload requests.
@@ skipping 492 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::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) {
   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>(
           MSG_ROUTING_NONE, SERVICE_WORKER_PROVIDER_FOR_CONTROLLER,
@@ skipping 98 matching lines @@
 
   // 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(
     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) {
   sender_->Send(message);
 }
 
 void ServiceWorkerContextClient::SendWorkerStarted() {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
                          "ServiceWorkerContextClient::StartingWorkerContext",
@@ skipping 368 matching lines @@
 }
 
 base::WeakPtr<ServiceWorkerContextClient>
 ServiceWorkerContextClient::GetWeakPtr() {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(context_);
   return context_->weak_factory.GetWeakPtr();
 }
 
 }  // namespace content