Refactoring RespondWithCallback class

This patch is for refactoring RespondWithCallback class
and include below changes.

- Expose RespondWithCallback from PaymentAppProviderImpl.

- Adds helper class like as "ServiceWorkerCoreThreadEventDispatcher"
it appears that all of the functions that access WebContents on the
service worker core thread are for dispatching some type of event.

- Remove InvokeRespondWithcallbacksRepository then
ServiceWorkerCoreThreadEventDispatcher owns an instance of
InvokeRespondWithCallback instead and manage its lifetime.

Bug: 1075687
Change-Id: I34ee154600a137ef47a03f797f15da689d205a79
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2368660
Commit-Queue: DongJun Kim <djmix.kim@samsung.com>
Reviewed-by: Jochen Eisinger <jochen@chromium.org>
Reviewed-by: Rouslan Solomakhin <rouslan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#809926}

content/browser/BUILD.gn

@@ -1286,6 +1286,10 @@ source_set("browser") {
     "payments/payment_instrument_icon_fetcher.h",
     "payments/payment_manager.cc",
     "payments/payment_manager.h",
+    "payments/respond_with_callback.cc",
+    "payments/respond_with_callback.h",
+    "payments/service_worker_core_thread_event_dispatcher.cc",
+    "payments/service_worker_core_thread_event_dispatcher.h",
     "permissions/permission_controller_impl.cc",
     "permissions/permission_controller_impl.h",
     "permissions/permission_service_context.cc",

content/browser/payments/payment_app_provider_impl.h

@@ -5,8 +5,8 @@
 #ifndef CONTENT_BROWSER_PAYMENTS_PAYMENT_APP_PROVIDER_IMPL_H_
 #define CONTENT_BROWSER_PAYMENTS_PAYMENT_APP_PROVIDER_IMPL_H_
 
-#include "content/browser/devtools/devtools_background_services_context_impl.h"
 #include "content/browser/payments/payment_app_context_impl.h"
+#include "content/browser/payments/service_worker_core_thread_event_dispatcher.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/payment_app_provider.h"
 #include "content/public/browser/web_contents_observer.h"
@@ -14,11 +14,6 @@
 
 namespace content {
 
-using payments::mojom::PaymentRequestEventDataPtr;
-using ServiceWorkerStartCallback =
-    base::OnceCallback<void(scoped_refptr<ServiceWorkerVersion>,
-                            blink::ServiceWorkerStatusCode)>;
-
 class CONTENT_EXPORT PaymentAppProviderImpl
     : public PaymentAppProvider,
       public WebContentsUserData<PaymentAppProviderImpl> {
@@ -77,13 +72,16 @@ class CONTENT_EXPORT PaymentAppProviderImpl
 
   scoped_refptr<DevToolsBackgroundServicesContextImpl> GetDevTools(
       const url::Origin& sw_origin);
-  void StartServiceWorkerForDispatch(int64_t registration_id,
-                                     ServiceWorkerStartCallback callback);
-  void OnInstallPaymentApp(const url::Origin& sw_origin,
-                           PaymentRequestEventDataPtr event_data,
-                           RegistrationIdCallback registration_id_callback,
-                           InvokePaymentAppCallback callback,
-                           int64_t registration_id);
+  void StartServiceWorkerForDispatch(
+      int64_t registration_id,
+      ServiceWorkerCoreThreadEventDispatcher::ServiceWorkerStartCallback
+          callback);
+  void OnInstallPaymentApp(
+      const url::Origin& sw_origin,
+      payments::mojom::PaymentRequestEventDataPtr event_data,
+      RegistrationIdCallback registration_id_callback,
+      InvokePaymentAppCallback callback,
+      int64_t registration_id);
 
   // Note that constructor of WebContentsObserver is protected.
   class PaymentHandlerWindowObserver : public WebContentsObserver {
@@ -97,6 +95,9 @@ class CONTENT_EXPORT PaymentAppProviderImpl
   // Owns this object.
   WebContents* web_contents_;
 
+  // It should be accessed only on the service worker core thread.
+  std::unique_ptr<ServiceWorkerCoreThreadEventDispatcher> event_dispatcher_;
+
   base::WeakPtrFactory<PaymentAppProviderImpl> weak_ptr_factory_{this};
 };
 

content/browser/payments/payment_app_provider_util.cc

@@ -47,4 +47,25 @@ bool PaymentAppProviderUtil::IsValidInstallablePaymentApp(
   return true;
 }
 
+// static
+payments::mojom::CanMakePaymentResponsePtr
+PaymentAppProviderUtil::CreateBlankCanMakePaymentResponse(
+    payments::mojom::CanMakePaymentEventResponseType response_type) {
+  return payments::mojom::CanMakePaymentResponse::New(
+      response_type, /*can_make_payment=*/false,
+      /*ready_for_minimal_ui=*/false,
+      /*account_balance=*/base::nullopt);
+}
+
+// static
+payments::mojom::PaymentHandlerResponsePtr
+PaymentAppProviderUtil::CreateBlankPaymentHandlerResponse(
+    payments::mojom::PaymentEventResponseType response_type) {
+  return payments::mojom::PaymentHandlerResponse::New(
+      /*method_name=*/"", /*stringified_details=*/"", response_type,
+      /*payer_name=*/base::nullopt, /*payer_email=*/base::nullopt,
+      /*payer_phone=*/base::nullopt, /*shipping_address=*/nullptr,
+      /*shipping_option=*/base::nullopt);
+}
+
 }  // namespace content

content/browser/payments/respond_with_callback.cc

+// Copyright 2020 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/browser/payments/respond_with_callback.h"
+
+#include "content/browser/payments/payment_app_provider_impl.h"
+#include "content/browser/payments/service_worker_core_thread_event_dispatcher.h"
+
+namespace content {
+
+namespace {
+
+using payments::mojom::CanMakePaymentEventResponseType;
+using payments::mojom::CanMakePaymentResponsePtr;
+using payments::mojom::PaymentEventResponseType;
+using payments::mojom::PaymentHandlerResponseCallback;
+using payments::mojom::PaymentHandlerResponsePtr;
+
+void CloseOpenedWindowUiThread(
+    base::WeakPtr<PaymentAppProviderImpl> payment_app_provider) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  if (payment_app_provider)
+    payment_app_provider->CloseOpenedWindow();
+}
+
+}  // namespace
+
+mojo::PendingRemote<PaymentHandlerResponseCallback>
+RespondWithCallback::BindNewPipeAndPassRemote() {
+  return receiver_.BindNewPipeAndPassRemote();
+}
+
+RespondWithCallback::RespondWithCallback(
+    WebContents* web_contents,
+    ServiceWorkerMetrics::EventType event_type,
+    scoped_refptr<ServiceWorkerVersion> service_worker_version,
+    base::WeakPtr<ServiceWorkerCoreThreadEventDispatcher> event_dispatcher)
+    : WebContentsObserver(web_contents),
+      service_worker_version_(service_worker_version),
+      event_dispatcher_(event_dispatcher) {
+  request_id_ = service_worker_version->StartRequest(
+      event_type, base::BindOnce(&RespondWithCallback::OnServiceWorkerError,
+                                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+RespondWithCallback::~RespondWithCallback() = default;
+
+void RespondWithCallback::FinishServiceWorkerRequest() {
+  service_worker_version_->FinishRequest(request_id_, false);
+}
+
+void RespondWithCallback::MaybeRecordTimeoutMetric(
+    blink::ServiceWorkerStatusCode status) {
+  if (status == blink::ServiceWorkerStatusCode::kErrorTimeout) {
+    UMA_HISTOGRAM_BOOLEAN("PaymentRequest.ServiceWorkerStatusCodeTimeout",
+                          true);
+  }
+}
+
+void RespondWithCallback::ClearRespondWithCallbackAndCloseWindow() {
+  DCHECK_CURRENTLY_ON(ServiceWorkerContext::GetCoreThreadId());
+  if (!web_contents())
+    return;
+
+  if (!event_dispatcher_)
+    return;
+
+  RunOrPostTaskOnThread(
+      FROM_HERE, BrowserThread::UI,
+      base::BindOnce(&CloseOpenedWindowUiThread,
+                     event_dispatcher_->payment_app_provider()));
+
+  event_dispatcher_->ResetRespondWithCallback();
+}
+
+CanMakePaymentRespondWithCallback::CanMakePaymentRespondWithCallback(
+    WebContents* web_contents,
+    scoped_refptr<ServiceWorkerVersion> service_worker_version,
+    base::WeakPtr<ServiceWorkerCoreThreadEventDispatcher> event_dispatcher,
+    PaymentAppProvider::CanMakePaymentCallback callback)
+    : RespondWithCallback(web_contents,
+                          ServiceWorkerMetrics::EventType::CAN_MAKE_PAYMENT,
+                          service_worker_version,
+                          event_dispatcher),
+      callback_(std::move(callback)) {}
+
+CanMakePaymentRespondWithCallback::~CanMakePaymentRespondWithCallback() =
+    default;
+
+void CanMakePaymentRespondWithCallback::OnResponseForCanMakePayment(
+    CanMakePaymentResponsePtr response) {
+  DCHECK_CURRENTLY_ON(ServiceWorkerContext::GetCoreThreadId());
+  FinishServiceWorkerRequest();
+  RunOrPostTaskOnThread(
+      FROM_HERE, BrowserThread::UI,
+      base::BindOnce(std::move(callback_), std::move(response)));
+  delete this;
+}
+
+void CanMakePaymentRespondWithCallback::OnServiceWorkerError(
+    blink::ServiceWorkerStatusCode service_worker_status) {
+  DCHECK_CURRENTLY_ON(ServiceWorkerContext::GetCoreThreadId());
+  DCHECK_NE(service_worker_status, blink::ServiceWorkerStatusCode::kOk);
+  MaybeRecordTimeoutMetric(service_worker_status);
+
+  CanMakePaymentEventResponseType response_type =
+      CanMakePaymentEventResponseType::BROWSER_ERROR;
+  if (service_worker_status ==
+      blink::ServiceWorkerStatusCode::kErrorEventWaitUntilRejected) {
+    response_type = CanMakePaymentEventResponseType::REJECT;
+  } else if (service_worker_status ==
+             blink::ServiceWorkerStatusCode::kErrorTimeout) {
+    response_type = CanMakePaymentEventResponseType::TIMEOUT;
+  }
+
+  RunOrPostTaskOnThread(
+      FROM_HERE, BrowserThread::UI,
+      base::BindOnce(
+          std::move(callback_),
+          content::PaymentAppProviderUtil::CreateBlankCanMakePaymentResponse(
+              response_type)));
+  delete this;
+}
+
+InvokeRespondWithCallback::InvokeRespondWithCallback(
+    WebContents* web_contents,
+    scoped_refptr<ServiceWorkerVersion> service_worker_version,
+    base::WeakPtr<ServiceWorkerCoreThreadEventDispatcher> event_dispatcher,
+    PaymentAppProvider::InvokePaymentAppCallback callback)
+    : RespondWithCallback(web_contents,
+                          ServiceWorkerMetrics::EventType::PAYMENT_REQUEST,
+                          service_worker_version,
+                          event_dispatcher),
+      callback_(std::move(callback)) {}
+
+void InvokeRespondWithCallback::AbortPaymentSinceOpennedWindowClosing(
+    PaymentEventResponseType reason) {
+  DCHECK_CURRENTLY_ON(ServiceWorkerContext::GetCoreThreadId());
+
+  FinishServiceWorkerRequest();
+  RespondToPaymentRequestWithErrorAndDeleteSelf(reason);
+}
+
+InvokeRespondWithCallback::~InvokeRespondWithCallback() = default;
+
+void InvokeRespondWithCallback::OnResponseForPaymentRequest(
+    PaymentHandlerResponsePtr response) {
+  DCHECK_CURRENTLY_ON(ServiceWorkerContext::GetCoreThreadId());
+  FinishServiceWorkerRequest();
+  RunOrPostTaskOnThread(
+      FROM_HERE, BrowserThread::UI,
+      base::BindOnce(std::move(callback_), std::move(response)));
+  ClearRespondWithCallbackAndCloseWindow();
+}
+
+void InvokeRespondWithCallback::OnServiceWorkerError(
+    blink::ServiceWorkerStatusCode service_worker_status) {
+  DCHECK_CURRENTLY_ON(ServiceWorkerContext::GetCoreThreadId());
+  DCHECK_NE(service_worker_status, blink::ServiceWorkerStatusCode::kOk);
+  MaybeRecordTimeoutMetric(service_worker_status);
+
+  PaymentEventResponseType response_type =
+      PaymentEventResponseType::PAYMENT_EVENT_BROWSER_ERROR;
+  if (service_worker_status ==
+      blink::ServiceWorkerStatusCode::kErrorEventWaitUntilRejected) {
+    response_type = PaymentEventResponseType::PAYMENT_EVENT_REJECT;
+  } else if (service_worker_status ==
+             blink::ServiceWorkerStatusCode::kErrorTimeout) {
+    response_type = PaymentEventResponseType::PAYMENT_EVENT_TIMEOUT;
+  }
+
+  RespondToPaymentRequestWithErrorAndDeleteSelf(response_type);
+}
+
+void InvokeRespondWithCallback::RespondToPaymentRequestWithErrorAndDeleteSelf(
+    PaymentEventResponseType response_type) {
+  DCHECK_CURRENTLY_ON(ServiceWorkerContext::GetCoreThreadId());
+  RunOrPostTaskOnThread(
+      FROM_HERE, BrowserThread::UI,
+      base::BindOnce(
+          std::move(callback_),
+          content::PaymentAppProviderUtil::CreateBlankPaymentHandlerResponse(
+              response_type)));
+  ClearRespondWithCallbackAndCloseWindow();
+}
+
+AbortRespondWithCallback::AbortRespondWithCallback(
+    WebContents* web_contents,
+    scoped_refptr<ServiceWorkerVersion> service_worker_version,
+    base::WeakPtr<ServiceWorkerCoreThreadEventDispatcher> event_dispatcher,
+    PaymentAppProvider::AbortCallback callback)
+    : RespondWithCallback(web_contents,
+                          ServiceWorkerMetrics::EventType::ABORT_PAYMENT,
+                          service_worker_version,
+                          event_dispatcher),
+      callback_(std::move(callback)) {}
+
+AbortRespondWithCallback::~AbortRespondWithCallback() = default;
+
+// PaymentHandlerResponseCallback implementation.
+void AbortRespondWithCallback::OnResponseForAbortPayment(bool payment_aborted) {
+  DCHECK_CURRENTLY_ON(ServiceWorkerContext::GetCoreThreadId());
+  FinishServiceWorkerRequest();
+  RunOrPostTaskOnThread(FROM_HERE, BrowserThread::UI,
+                        base::BindOnce(std::move(callback_), payment_aborted));
+
+  if (payment_aborted)
+    ClearRespondWithCallbackAndCloseWindow();
+
+  delete this;
+}
+
+void AbortRespondWithCallback::OnServiceWorkerError(
+    blink::ServiceWorkerStatusCode service_worker_status) {
+  DCHECK_CURRENTLY_ON(ServiceWorkerContext::GetCoreThreadId());
+  DCHECK_NE(service_worker_status, blink::ServiceWorkerStatusCode::kOk);
+  MaybeRecordTimeoutMetric(service_worker_status);
+  RunOrPostTaskOnThread(
+      FROM_HERE, BrowserThread::UI,
+      base::BindOnce(std::move(callback_), /*payment_aborted=*/false));
+  // Do not call ClearRespondWithCallbackAndCloseWindow() here, because payment
+  // has not been aborted. The service worker either rejected, timed out, or
+  // threw a JavaScript exception in the "abortpayment" event, but that does
+  // not affect the ongoing "paymentrequest" event.
+  delete this;
+}
+
+}  // namespace content.

content/browser/payments/respond_with_callback.h

+// Copyright 2020 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.
+
+#ifndef CONTENT_BROWSER_PAYMENTS_RESPOND_WITH_CALLBACK_H_
+#define CONTENT_BROWSER_PAYMENTS_RESPOND_WITH_CALLBACK_H_
+
+#include "base/callback_forward.h"
+#include "base/memory/singleton.h"
+#include "base/metrics/histogram_macros.h"
+#include "content/browser/service_worker/service_worker_context_wrapper.h"
+#include "content/common/content_export.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/payment_app_provider.h"
+#include "content/public/browser/payment_app_provider_util.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/browser/web_contents_observer.h"
+#include "third_party/blink/public/mojom/payments/payment_app.mojom.h"
+
+namespace content {
+
+class ServiceWorkerCoreThreadEventDispatcher;
+enum class RespondWithCallbackType { kInvoke, kAbort, kCanMakePayment };
+
+// Abstract base class for event callbacks that are invoked when the payment
+// handler resolves the promise passed in to TheEvent.respondWith() method.
+class RespondWithCallback
+    : public payments::mojom::PaymentHandlerResponseCallback,
+      public WebContentsObserver {
+ public:
+  // Disallow copy and assign.
+  RespondWithCallback(const RespondWithCallback& other) = delete;
+  RespondWithCallback& operator=(const RespondWithCallback& other) = delete;
+
+  mojo::PendingRemote<payments::mojom::PaymentHandlerResponseCallback>
+  BindNewPipeAndPassRemote();
+
+ protected:
+  RespondWithCallback(
+      WebContents* web_contents,
+      ServiceWorkerMetrics::EventType event_type,
+      scoped_refptr<ServiceWorkerVersion> service_worker_version,
+      base::WeakPtr<ServiceWorkerCoreThreadEventDispatcher> event_dispatcher);
+
+  ~RespondWithCallback() override;
+
+  // payments::mojom::PaymentHandlerResponseCallback implementation.
+  void OnResponseForCanMakePayment(
+      payments::mojom::CanMakePaymentResponsePtr response) override {}
+
+  // payments::mojom::PaymentHandlerResponseCallback implementation.
+  void OnResponseForPaymentRequest(
+      payments::mojom::PaymentHandlerResponsePtr response) override {}
+
+  // payments::mojom::PaymentHandlerResponseCallback implementation.
+  void OnResponseForAbortPayment(bool payment_aborted) override {}
+
+  virtual void OnServiceWorkerError(
+      blink::ServiceWorkerStatusCode service_worker_status) = 0;
+
+  void FinishServiceWorkerRequest();
+  void MaybeRecordTimeoutMetric(blink::ServiceWorkerStatusCode status);
+  void ClearRespondWithCallbackAndCloseWindow();
+
+ private:
+  int request_id_;
+  scoped_refptr<ServiceWorkerVersion> service_worker_version_;
+  base::WeakPtr<ServiceWorkerCoreThreadEventDispatcher> event_dispatcher_;
+  mojo::Receiver<payments::mojom::PaymentHandlerResponseCallback> receiver_{
+      this};
+
+  base::WeakPtrFactory<RespondWithCallback> weak_ptr_factory_{this};
+};
+
+// Self-deleting callback for "canmakepayment" event. Invoked when the payment
+// handler resolves the promise passed into CanMakePaymentEvent.respondWith()
+// method.
+class CanMakePaymentRespondWithCallback : public RespondWithCallback {
+ public:
+  CanMakePaymentRespondWithCallback(
+      WebContents* web_contents,
+      scoped_refptr<ServiceWorkerVersion> service_worker_version,
+      base::WeakPtr<ServiceWorkerCoreThreadEventDispatcher> event_dispatcher,
+      PaymentAppProvider::CanMakePaymentCallback callback);
+  ~CanMakePaymentRespondWithCallback() override;
+
+  // Disallow copy and assign.
+  CanMakePaymentRespondWithCallback(
+      const CanMakePaymentRespondWithCallback& other) = delete;
+  CanMakePaymentRespondWithCallback& operator=(
+      const CanMakePaymentRespondWithCallback& other) = delete;
+
+ private:
+  // payments::mojom::PaymentHandlerResponseCallback implementation.
+  void OnResponseForCanMakePayment(
+      payments::mojom::CanMakePaymentResponsePtr response) override;
+
+  // RespondWithCallback implementation.
+  void OnServiceWorkerError(
+      blink::ServiceWorkerStatusCode service_worker_status) override;
+
+  PaymentAppProvider::CanMakePaymentCallback callback_;
+};
+
+// Self-deleting callback for "paymentrequest" event. Invoked when the payment
+// handler resolves the promise passed into PaymentRequestEvent.respondWith()
+// method.
+class InvokeRespondWithCallback : public RespondWithCallback {
+ public:
+  InvokeRespondWithCallback(
+      WebContents* web_contents,
+      scoped_refptr<ServiceWorkerVersion> service_worker_version,
+      base::WeakPtr<ServiceWorkerCoreThreadEventDispatcher> event_dispatcher,
+      PaymentAppProvider::InvokePaymentAppCallback callback);
+  ~InvokeRespondWithCallback() override;
+
+  // Disallow copy and assign.
+  InvokeRespondWithCallback(const InvokeRespondWithCallback& other) = delete;
+  InvokeRespondWithCallback& operator=(const InvokeRespondWithCallback& other) =
+      delete;
+
+  // Called only for "paymentrequest" event.
+  void AbortPaymentSinceOpennedWindowClosing(
+      payments::mojom::PaymentEventResponseType reason);
+
+ private:
+  // payments::mojom::PaymentHandlerResponseCallback implementation.
+  void OnResponseForPaymentRequest(
+      payments::mojom::PaymentHandlerResponsePtr response) override;
+
+  // RespondWithCallback implementation.
+  void OnServiceWorkerError(
+      blink::ServiceWorkerStatusCode service_worker_status) override;
+
+  void RespondToPaymentRequestWithErrorAndDeleteSelf(
+      payments::mojom::PaymentEventResponseType response_type);
+
+  PaymentAppProvider::InvokePaymentAppCallback callback_;
+};
+
+// Self-deleting callback for "abortpayment" event. Invoked when the payment
+// handler resolves the promise passed into AbortPayment.respondWith() method.
+class AbortRespondWithCallback : public RespondWithCallback {
+ public:
+  AbortRespondWithCallback(
+      WebContents* web_contents,
+      scoped_refptr<ServiceWorkerVersion> service_worker_version,
+      base::WeakPtr<ServiceWorkerCoreThreadEventDispatcher> event_dispatcher,
+      PaymentAppProvider::AbortCallback callback);
+  ~AbortRespondWithCallback() override;
+
+  // Disallow copy and assign.
+  AbortRespondWithCallback(const AbortRespondWithCallback& other) = delete;
+  AbortRespondWithCallback& operator=(const AbortRespondWithCallback& other) =
+      delete;
+
+ private:
+  // payments::mojom::PaymentHandlerResponseCallback implementation.
+  void OnResponseForAbortPayment(bool payment_aborted) override;
+
+  // RespondWithCallback implementation.
+  void OnServiceWorkerError(
+      blink::ServiceWorkerStatusCode service_worker_status) override;
+
+  PaymentAppProvider::AbortCallback callback_;
+};
+
+}  // namespace content.
+
+#endif  // CONTENT_BROWSER_PAYMENTS_RESPOND_WITH_CALLBACK_H_

content/browser/payments/service_worker_core_thread_event_dispatcher.h

+// Copyright 2020 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.
+
+#ifndef CONTENT_BROWSER_PAYMENTS_SERVICE_WORKER_CORE_THREAD_EVENT_DISPATCHER_H_
+#define CONTENT_BROWSER_PAYMENTS_SERVICE_WORKER_CORE_THREAD_EVENT_DISPATCHER_H_
+
+#include <memory>
+
+#include "base/memory/weak_ptr.h"
+#include "content/browser/devtools/devtools_background_services_context_impl.h"
+#include "content/browser/payments/respond_with_callback.h"
+#include "content/browser/service_worker/service_worker_version.h"
+#include "content/public/browser/web_contents_observer.h"
+#include "third_party/blink/public/common/service_worker/service_worker_status_code.h"
+
+namespace content {
+
+class WebContents;
+class PaymentAppProviderImpl;
+
+// All of the methods and the destructor should be running on the
+// service worker core thread.
+class ServiceWorkerCoreThreadEventDispatcher : public WebContentsObserver {
+ public:
+  explicit ServiceWorkerCoreThreadEventDispatcher(WebContents* web_contents);
+
+  ~ServiceWorkerCoreThreadEventDispatcher() override;
+
+  using ServiceWorkerStartCallback =
+      base::OnceCallback<void(scoped_refptr<ServiceWorkerVersion>,
+                              blink::ServiceWorkerStatusCode)>;
+
+  void set_payment_app_provider(
+      base::WeakPtr<PaymentAppProviderImpl> payment_app_provider) {
+    payment_app_provider_ = payment_app_provider;
+  }
+
+  base::WeakPtr<PaymentAppProviderImpl> payment_app_provider() const {
+    return payment_app_provider_;
+  }
+
+  void AbortPaymentOnCoreThread(
+      int64_t registration_id,
+      const url::Origin& sw_origin,
+      const std::string& payment_request_id,
+      scoped_refptr<DevToolsBackgroundServicesContextImpl> dev_tools,
+      scoped_refptr<ServiceWorkerContextWrapper> service_worker_context,
+      PaymentAppProvider::AbortCallback callback);
+
+  void CanMakePaymentOnCoreThread(
+      int64_t registration_id,
+      const url::Origin& sw_origin,
+      const std::string& payment_request_id,
+      scoped_refptr<DevToolsBackgroundServicesContextImpl> dev_tools,
+      scoped_refptr<ServiceWorkerContextWrapper> service_worker_context,
+      payments::mojom::CanMakePaymentEventDataPtr event_data,
+      PaymentAppProvider::CanMakePaymentCallback callback);
+
+  void InvokePaymentOnCoreThread(
+      int64_t registration_id,
+      const url::Origin& sw_origin,
+      scoped_refptr<DevToolsBackgroundServicesContextImpl> dev_tools,
+      scoped_refptr<ServiceWorkerContextWrapper> service_worker_context,
+      payments::mojom::PaymentRequestEventDataPtr event_data,
+      PaymentAppProvider::InvokePaymentAppCallback callback);
+
+  void FindRegistrationOnCoreThread(
+      scoped_refptr<ServiceWorkerContextWrapper> service_worker_context,
+      int64_t registration_id,
+      ServiceWorkerCoreThreadEventDispatcher::ServiceWorkerStartCallback
+          callback);
+
+  void OnClosingOpenedWindowOnCoreThread(
+      payments::mojom::PaymentEventResponseType reason);
+
+  void ResetRespondWithCallback();
+
+  base::WeakPtr<ServiceWorkerCoreThreadEventDispatcher> GetWeakPtr();
+
+ private:
+  // AbortCallback require to be run on the UI thread.
+  void DispatchAbortPaymentEvent(
+      PaymentAppProvider::AbortCallback callback,
+      scoped_refptr<ServiceWorkerVersion> active_version,
+      blink::ServiceWorkerStatusCode service_worker_status);
+
+  // CanMakePaymentCallback require to be run on the UI thread.
+  void DispatchCanMakePaymentEvent(
+      payments::mojom::CanMakePaymentEventDataPtr event_data,
+      PaymentAppProvider::CanMakePaymentCallback callback,
+      scoped_refptr<ServiceWorkerVersion> active_version,
+      blink::ServiceWorkerStatusCode service_worker_status);
+
+  // InvokePaymentAppCallback require to be run on the UI thread.
+  void DispatchPaymentRequestEvent(
+      payments::mojom::PaymentRequestEventDataPtr event_data,
+      PaymentAppProvider::InvokePaymentAppCallback callback,
+      scoped_refptr<ServiceWorkerVersion> active_version,
+      blink::ServiceWorkerStatusCode service_worker_status);
+
+  void ResetRespondWithCallbackCoreThread();
+
+  std::unique_ptr<InvokeRespondWithCallback> invoke_respond_with_callback_;
+
+  // payment_app_provider_ require to be run on the UI thread.
+  base::WeakPtr<PaymentAppProviderImpl> payment_app_provider_;
+
+  base::WeakPtrFactory<ServiceWorkerCoreThreadEventDispatcher>
+      weak_ptr_factory_{this};
+};
+
+}  // namespace content.
+
+#endif  // CONTENT_BROWSER_PAYMENTS_SERVICE_WORKER_CORE_THREAD_EVENT_DISPATCHER_H_

content/public/browser/payment_app_provider_util.h

@@ -23,6 +23,16 @@ class CONTENT_EXPORT PaymentAppProviderUtil {
                                            const GURL& sw_js_url,
                                            const GURL& sw_scope,
                                            std::string* error_message);
+
+  // Create blank struct for response to "can make payment".
+  static payments::mojom::CanMakePaymentResponsePtr
+  CreateBlankCanMakePaymentResponse(
+      payments::mojom::CanMakePaymentEventResponseType response_type);
+
+  // Create blank struct for receipt payment app response from render side.
+  static payments::mojom::PaymentHandlerResponsePtr
+  CreateBlankPaymentHandlerResponse(
+      payments::mojom::PaymentEventResponseType response_type);
 };
 
 }  // namespace content