Implement WebContentsUserData in PaymentAppProviderImpl

This patch implements WebContentsUserData in PaymentAppProviderImpl
include below changes.

- PaymentAppProviderImpl will be owned WebContents rather than
it being a singleton.

- GetSourceIdForPaymentAppFromScope, IsValidInstallablePaymentApp
are moved out PaymentAppProviderUtil class.
This is a simple helper class that is not related WebContents.

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

chrome/browser/payments/android/service_worker_payment_app_bridge.cc

@@ -26,6 +26,7 @@
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/installed_payment_apps_finder.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 "services/metrics/public/cpp/ukm_recorder.h"
 #include "third_party/blink/public/mojom/payments/payment_app.mojom.h"
@@ -125,9 +126,9 @@ static void JNI_ServiceWorkerPaymentAppBridge_OnClosingPaymentAppWindow(
   content::WebContents* web_contents =
       content::WebContents::FromJavaWebContents(jweb_contents);
   DCHECK(web_contents);  // Verified in Java before invoking this function.
-  content::PaymentAppProvider::GetInstance()->OnClosingOpenedWindow(
-      web_contents,
-      static_cast<payments::mojom::PaymentEventResponseType>(reason));
+  content::PaymentAppProvider::GetOrCreateForWebContents(web_contents)
+      ->OnClosingOpenedWindow(
+          static_cast<payments::mojom::PaymentEventResponseType>(reason));
 }
 
 static jlong
@@ -138,7 +139,6 @@ JNI_ServiceWorkerPaymentAppBridge_GetSourceIdForPaymentAppFromScope(
   // payment app associated with this scope. Since this getter is called inside
   // PaymentApp::getUkmSourceId() function which in turn gets called for the
   // invoked app inside PaymentRequestImpl::openPaymentHandlerWindowInternal.
-  return content::PaymentAppProvider::GetInstance()
-      ->GetSourceIdForPaymentAppFromScope(
-          url::GURLAndroid::ToNativeGURL(env, jscope).get()->GetOrigin());
+  return content::PaymentAppProviderUtil::GetSourceIdForPaymentAppFromScope(
+      url::GURLAndroid::ToNativeGURL(env, jscope).get()->GetOrigin());
 }

components/payments/content/installable_payment_app_crawler.cc

@@ -18,7 +18,7 @@
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/global_routing_id.h"
 #include "content/public/browser/manifest_icon_downloader.h"
-#include "content/public/browser/payment_app_provider.h"
+#include "content/public/browser/payment_app_provider_util.h"
 #include "content/public/browser/permission_controller.h"
 #include "content/public/browser/permission_type.h"
 #include "content/public/browser/render_frame_host.h"
@@ -337,7 +337,7 @@ bool InstallablePaymentAppCrawler::CompleteAndStorePaymentWebAppInfoIfValid(
   }
 
   std::string error_message;
-  if (!content::PaymentAppProvider::GetInstance()->IsValidInstallablePaymentApp(
+  if (!content::PaymentAppProviderUtil::IsValidInstallablePaymentApp(
           web_app_manifest_url, GURL(app_info->sw_js_url),
           GURL(app_info->sw_scope), &error_message)) {
     SetFirstError(error_message);

components/payments/content/service_worker_payment_app.cc

@@ -19,6 +19,7 @@
 #include "components/payments/core/features.h"
 #include "components/payments/core/method_strings.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/common/content_features.h"
 #include "ui/gfx/image/image_skia.h"
@@ -130,8 +131,12 @@ void ServiceWorkerPaymentApp::ValidateCanMakePayment(
     return;
   }
 
-  content::PaymentAppProvider::GetInstance()->CanMakePayment(
-      web_contents(), stored_payment_app_info_->registration_id,
+  auto* payment_app_provider = GetPaymentAppProvider();
+  if (!payment_app_provider)
+    return;
+
+  payment_app_provider->CanMakePayment(
+      stored_payment_app_info_->registration_id,
       url::Origin::Create(stored_payment_app_info_->scope),
       *spec_->details().id, std::move(event_data),
       base::BindOnce(&ServiceWorkerPaymentApp::OnCanMakePaymentEventResponded,
@@ -206,11 +211,13 @@ void ServiceWorkerPaymentApp::OnCanMakePaymentEventResponded(
 
 void ServiceWorkerPaymentApp::InvokePaymentApp(Delegate* delegate) {
   delegate_ = delegate;
+  auto* payment_app_provider = GetPaymentAppProvider();
+  if (!payment_app_provider)
+    return;
 
   if (needs_installation_) {
-    content::PaymentAppProvider::GetInstance()->InstallAndInvokePaymentApp(
-        web_contents(), CreatePaymentRequestEventData(),
-        installable_web_app_info_->name,
+    payment_app_provider->InstallAndInvokePaymentApp(
+        CreatePaymentRequestEventData(), installable_web_app_info_->name,
         installable_web_app_info_->icon == nullptr
             ? SkBitmap()
             : *(installable_web_app_info_->icon),
@@ -228,8 +235,8 @@ void ServiceWorkerPaymentApp::InvokePaymentApp(Delegate* delegate) {
     url::Origin sw_origin =
         url::Origin::Create(stored_payment_app_info_->scope);
     OnPaymentAppIdentity(sw_origin, stored_payment_app_info_->registration_id);
-    content::PaymentAppProvider::GetInstance()->InvokePaymentApp(
-        web_contents(), stored_payment_app_info_->registration_id, sw_origin,
+    payment_app_provider->InvokePaymentApp(
+        stored_payment_app_info_->registration_id, sw_origin,
         CreatePaymentRequestEventData(),
         base::BindOnce(&ServiceWorkerPaymentApp::OnPaymentAppInvoked,
                        weak_ptr_factory_.GetWeakPtr()));
@@ -240,8 +247,10 @@ void ServiceWorkerPaymentApp::InvokePaymentApp(Delegate* delegate) {
 
 void ServiceWorkerPaymentApp::OnPaymentAppWindowClosed() {
   delegate_ = nullptr;
-  content::PaymentAppProvider::GetInstance()->OnClosingOpenedWindow(
-      web_contents(),
+  auto* payment_app_provider = GetPaymentAppProvider();
+  if (!payment_app_provider)
+    return;
+  payment_app_provider->OnClosingOpenedWindow(
       mojom::PaymentEventResponseType::PAYMENT_HANDLER_WINDOW_CLOSING);
 }
 
@@ -562,8 +571,8 @@ ukm::SourceId ServiceWorkerPaymentApp::UkmSourceId() {
     // app since this getter is called for the invoked app inside the
     // PaymentRequest::OnPaymentHandlerOpenWindowCalled function.
     ukm_source_id_ =
-        content::PaymentAppProvider::GetInstance()
-            ->GetSourceIdForPaymentAppFromScope(sw_scope.GetOrigin());
+        content::PaymentAppProviderUtil::GetSourceIdForPaymentAppFromScope(
+            sw_scope.GetOrigin());
   }
   return ukm_source_id_;
 }
@@ -592,12 +601,23 @@ void ServiceWorkerPaymentApp::OnPaymentDetailsNotUpdated() {
 
 void ServiceWorkerPaymentApp::AbortPaymentApp(
     base::OnceCallback<void(bool)> abort_callback) {
-  content::PaymentAppProvider::GetInstance()->AbortPayment(
-      web_contents(), registration_id_,
+  auto* payment_app_provider = GetPaymentAppProvider();
+  if (!payment_app_provider)
+    return;
+
+  payment_app_provider->AbortPayment(
+      registration_id_,
       stored_payment_app_info_
           ? url::Origin::Create(stored_payment_app_info_->scope)
           : url::Origin::Create(GURL(installable_web_app_info_->sw_scope)),
       *spec_->details().id, std::move(abort_callback));
 }
 
+content::PaymentAppProvider* ServiceWorkerPaymentApp::GetPaymentAppProvider() {
+  return (!web_contents())
+             ? nullptr
+             : content::PaymentAppProvider::GetOrCreateForWebContents(
+                   web_contents());
+}
+
 }  // namespace payments

components/payments/content/service_worker_payment_app.h

@@ -20,6 +20,7 @@
 #include "third_party/blink/public/mojom/payments/payment_request.mojom.h"
 
 namespace content {
+class PaymentAppProvider;
 class WebContents;
 }  // namespace content
 
@@ -129,6 +130,8 @@ class ServiceWorkerPaymentApp : public PaymentApp,
   //    invoked.
   void OnPaymentAppIdentity(const url::Origin& origin, int64_t registration_id);
 
+  content::PaymentAppProvider* GetPaymentAppProvider();
+
   GURL top_origin_;
   GURL frame_origin_;
   const PaymentRequestSpec* spec_;

components/payments/content/service_worker_payment_app_finder.cc

@@ -95,7 +95,7 @@ class SelfDeletingServiceWorkerPaymentAppFinder
     : public base::SupportsUserData::Data {
  public:
   static base::WeakPtr<SelfDeletingServiceWorkerPaymentAppFinder>
-  CreateAndSetOwnedBy(base::SupportsUserData* owner) {
+  CreateAndSetOwnedBy(content::WebContents* owner) {
     auto owned =
         std::make_unique<SelfDeletingServiceWorkerPaymentAppFinder>(owner);
     auto* pointer = owned.get();
@@ -104,7 +104,7 @@ class SelfDeletingServiceWorkerPaymentAppFinder
   }
 
   explicit SelfDeletingServiceWorkerPaymentAppFinder(
-      base::SupportsUserData* owner)
+      content::WebContents* owner)
       : owner_(owner) {}
 
   SelfDeletingServiceWorkerPaymentAppFinder(
@@ -314,14 +314,13 @@ class SelfDeletingServiceWorkerPaymentAppFinder
         base::StringPiece(raw_data->front_as<char>(), raw_data->size()),
         &string_encoded_icon);
 
-    auto* browser_context =
-        static_cast<content::WebContents*>(owner_)->GetBrowserContext();
-    content::PaymentAppProvider::GetInstance()->UpdatePaymentAppIcon(
-        browser_context, app->registration_id, app->scope.spec(), app->name,
-        string_encoded_icon, method_name, app->supported_delegations,
-        base::BindOnce(
-            &SelfDeletingServiceWorkerPaymentAppFinder::OnUpdatePaymentAppIcon,
-            weak_ptr_factory_.GetWeakPtr()));
+    content::PaymentAppProvider::GetOrCreateForWebContents(owner_)
+        ->UpdatePaymentAppIcon(
+            app->registration_id, app->scope.spec(), app->name,
+            string_encoded_icon, method_name, app->supported_delegations,
+            base::BindOnce(&SelfDeletingServiceWorkerPaymentAppFinder::
+                               OnUpdatePaymentAppIcon,
+                           weak_ptr_factory_.GetWeakPtr()));
   }
 
   void OnUpdatePaymentAppIcon(payments::mojom::PaymentHandlerStatus status) {
@@ -365,7 +364,7 @@ class SelfDeletingServiceWorkerPaymentAppFinder
 
   // |owner_| owns this SelfDeletingServiceWorkerPaymentAppFinder, so it is
   // always valid.
-  base::SupportsUserData* owner_;
+  content::WebContents* owner_;
 
   std::unique_ptr<PaymentManifestDownloader> downloader_;
   std::unique_ptr<PaymentManifestParser> parser_;

content/browser/BUILD.gn

@@ -1281,6 +1281,7 @@ source_set("browser") {
     "payments/payment_app_installer.h",
     "payments/payment_app_provider_impl.cc",
     "payments/payment_app_provider_impl.h",
+    "payments/payment_app_provider_util.cc",
     "payments/payment_instrument_icon_fetcher.cc",
     "payments/payment_instrument_icon_fetcher.h",
     "payments/payment_manager.cc",

content/browser/payments/payment_app_browsertest.cc

@@ -132,10 +132,11 @@ class PaymentAppBrowserTest : public ContentBrowserTest {
                     const std::string& payment_request_id) {
     base::RunLoop run_loop;
     bool payment_aborted = false;
-    PaymentAppProvider::GetInstance()->AbortPayment(
-        shell()->web_contents(), registration_id, sw_origin, payment_request_id,
-        base::BindOnce(&CaptureAbortResult, run_loop.QuitClosure(),
-                       &payment_aborted));
+    PaymentAppProvider::GetOrCreateForWebContents(shell()->web_contents())
+        ->AbortPayment(
+            registration_id, sw_origin, payment_request_id,
+            base::BindOnce(&CaptureAbortResult, run_loop.QuitClosure(),
+                           &payment_aborted));
     run_loop.Run();
 
     return payment_aborted;
@@ -150,11 +151,12 @@ class PaymentAppBrowserTest : public ContentBrowserTest {
 
     base::RunLoop run_loop;
     bool can_make_payment = false;
-    PaymentAppProvider::GetInstance()->CanMakePayment(
-        shell()->web_contents(), registration_id, sw_origin, payment_request_id,
-        std::move(event_data),
-        base::BindOnce(&CaptureCanMakePaymentResult, run_loop.QuitClosure(),
-                       &can_make_payment));
+    PaymentAppProvider::GetOrCreateForWebContents(shell()->web_contents())
+        ->CanMakePayment(
+            registration_id, sw_origin, payment_request_id,
+            std::move(event_data),
+            base::BindOnce(&CaptureCanMakePaymentResult, run_loop.QuitClosure(),
+                           &can_make_payment));
     run_loop.Run();
 
     return can_make_payment;
@@ -167,11 +169,12 @@ class PaymentAppBrowserTest : public ContentBrowserTest {
       const std::string& instrument_key) {
     base::RunLoop run_loop;
     PaymentHandlerResponsePtr response;
-    PaymentAppProvider::GetInstance()->InvokePaymentApp(
-        shell()->web_contents(), registration_id, sw_origin,
-        CreatePaymentRequestEventData(supported_method, instrument_key),
-        base::BindOnce(&InvokePaymentAppCallback, run_loop.QuitClosure(),
-                       &response));
+    PaymentAppProvider::GetOrCreateForWebContents(shell()->web_contents())
+        ->InvokePaymentApp(
+            registration_id, sw_origin,
+            CreatePaymentRequestEventData(supported_method, instrument_key),
+            base::BindOnce(&InvokePaymentAppCallback, run_loop.QuitClosure(),
+                           &response));
     run_loop.Run();
 
     return response;

content/browser/payments/payment_app_installer.cc

@@ -207,10 +207,10 @@ class SelfDeleteInstaller
     if (callback_.is_null())
       return;
 
-    if (success && web_contents() != nullptr) {
-      std::move(callback_).Run(web_contents(), registration_id_);
+    if (success) {
+      std::move(callback_).Run(registration_id_);
     } else {
-      std::move(callback_).Run(nullptr, -1);
+      std::move(callback_).Run(-1);
     }
 
     service_worker_context_->RemoveObserver(this);

content/browser/payments/payment_app_installer.h

@@ -23,8 +23,7 @@ class WebContents;
 class PaymentAppInstaller {
  public:
   using InstallPaymentAppCallback =
-      base::OnceCallback<void(WebContents* web_contents,
-                              int64_t registration_id)>;
+      base::OnceCallback<void(int64_t registration_id)>;
 
   // Installs the payment app.
   // |app_name| is the name of the payment app.

content/browser/payments/payment_app_provider_impl.cc

@@ -26,7 +26,6 @@
 #include "content/browser/service_worker/service_worker_metrics.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/browser/storage_partition_impl.h"
-#include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_task_traits.h"
 #include "content/public/browser/browser_thread.h"
@@ -54,11 +53,6 @@ using payments::mojom::PaymentHandlerResponse;
 using payments::mojom::PaymentHandlerResponseCallback;
 using payments::mojom::PaymentHandlerResponsePtr;
 using payments::mojom::PaymentMethodDataPtr;
-using payments::mojom::PaymentRequestEventDataPtr;
-
-using ServiceWorkerStartCallback =
-    base::OnceCallback<void(scoped_refptr<ServiceWorkerVersion>,
-                            blink::ServiceWorkerStatusCode)>;
 
 CanMakePaymentResponsePtr CreateBlankCanMakePaymentResponse(
     CanMakePaymentEventResponseType response_type) {
@@ -128,7 +122,8 @@ class InvokePaymentAppCallbackRepository {
 
 // 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 PaymentHandlerResponseCallback {
+class RespondWithCallback : public PaymentHandlerResponseCallback,
+                            public WebContentsObserver {
  public:
   // Disallow copy and assign.
   RespondWithCallback(const RespondWithCallback& other) = delete;
@@ -141,10 +136,10 @@ class RespondWithCallback : public PaymentHandlerResponseCallback {
 
  protected:
   RespondWithCallback(
-      BrowserContext* browser_context,
+      WebContents* web_contents,
       ServiceWorkerMetrics::EventType event_type,
       scoped_refptr<ServiceWorkerVersion> service_worker_version)
-      : browser_context_(browser_context),
+      : WebContentsObserver(web_contents),
         service_worker_version_(service_worker_version) {
     request_id_ = service_worker_version->StartRequest(
         event_type, base::BindOnce(&RespondWithCallback::OnServiceWorkerError,
@@ -180,22 +175,15 @@ class RespondWithCallback : public PaymentHandlerResponseCallback {
 
   void ClearCallbackRepositoryAndCloseWindow() {
     DCHECK_CURRENTLY_ON(ServiceWorkerContext::GetCoreThreadId());
+    if (!web_contents())
+      return;
 
     InvokePaymentAppCallbackRepository::GetInstance()->RemoveCallback(
-        browser_context_);
-    GetUIThreadTaskRunner({})->PostTask(
-        FROM_HERE, base::BindOnce(&CloseClientWindowOnUIThread));
+        web_contents()->GetBrowserContext());
   }
 
  private:
-  static void CloseClientWindowOnUIThread() {
-    DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-    PaymentAppProvider::GetInstance()->CloseOpenedWindow();
-  }
-
   int request_id_;
-  BrowserContext* browser_context_;
   scoped_refptr<ServiceWorkerVersion> service_worker_version_;
   mojo::Receiver<PaymentHandlerResponseCallback> receiver_{this};
 
@@ -208,10 +196,10 @@ class RespondWithCallback : public PaymentHandlerResponseCallback {
 class CanMakePaymentRespondWithCallback : public RespondWithCallback {
  public:
   CanMakePaymentRespondWithCallback(
-      BrowserContext* browser_context,
+      WebContents* web_contents,
       scoped_refptr<ServiceWorkerVersion> service_worker_version,
       PaymentAppProvider::CanMakePaymentCallback callback)
-      : RespondWithCallback(browser_context,
+      : RespondWithCallback(web_contents,
                             ServiceWorkerMetrics::EventType::CAN_MAKE_PAYMENT,
                             service_worker_version),
         callback_(std::move(callback)) {}
@@ -269,15 +257,15 @@ class CanMakePaymentRespondWithCallback : public RespondWithCallback {
 class InvokeRespondWithCallback : public RespondWithCallback {
  public:
   InvokeRespondWithCallback(
-      BrowserContext* browser_context,
+      WebContents* web_contents,
       scoped_refptr<ServiceWorkerVersion> service_worker_version,
       PaymentAppProvider::InvokePaymentAppCallback callback)
-      : RespondWithCallback(browser_context,
+      : RespondWithCallback(web_contents,
                             ServiceWorkerMetrics::EventType::PAYMENT_REQUEST,
                             service_worker_version),
         callback_(std::move(callback)) {
     InvokePaymentAppCallbackRepository::GetInstance()->SetCallback(
-        browser_context, this);
+        web_contents->GetBrowserContext(), this);
   }
 
   // Disallow copy and assign.
@@ -304,7 +292,6 @@ class InvokeRespondWithCallback : public RespondWithCallback {
     RunOrPostTaskOnThread(
         FROM_HERE, BrowserThread::UI,
         base::BindOnce(std::move(callback_), std::move(response)));
-
     ClearCallbackRepositoryAndCloseWindow();
     delete this;
   }
@@ -348,10 +335,10 @@ class InvokeRespondWithCallback : public RespondWithCallback {
 class AbortRespondWithCallback : public RespondWithCallback {
  public:
   AbortRespondWithCallback(
-      BrowserContext* browser_context,
+      WebContents* web_contents,
       scoped_refptr<ServiceWorkerVersion> service_worker_version,
       PaymentAppProvider::AbortCallback callback)
-      : RespondWithCallback(browser_context,
+      : RespondWithCallback(web_contents,
                             ServiceWorkerMetrics::EventType::ABORT_PAYMENT,
                             service_worker_version),
         callback_(std::move(callback)) {}
@@ -423,7 +410,7 @@ void UpdatePaymentAppIconOnCoreThread(
 }
 
 void DispatchAbortPaymentEvent(
-    BrowserContext* browser_context,
+    WebContents* web_contents,
     PaymentAppProvider::AbortCallback callback,
     scoped_refptr<ServiceWorkerVersion> active_version,
     blink::ServiceWorkerStatusCode service_worker_status) {
@@ -443,7 +430,7 @@ void DispatchAbortPaymentEvent(
   // This object self-deletes after either success or error callback is
   // invoked.
   RespondWithCallback* respond_with_callback = new AbortRespondWithCallback(
-      browser_context, active_version, std::move(callback));
+      web_contents, active_version, std::move(callback));
 
   active_version->endpoint()->DispatchAbortPaymentEvent(
       respond_with_callback->BindNewPipeAndPassRemote(),
@@ -451,7 +438,7 @@ void DispatchAbortPaymentEvent(
 }
 
 void DispatchCanMakePaymentEvent(
-    BrowserContext* browser_context,
+    WebContents* web_contents,
     CanMakePaymentEventDataPtr event_data,
     PaymentAppProvider::CanMakePaymentCallback callback,
     scoped_refptr<ServiceWorkerVersion> active_version,
@@ -475,7 +462,7 @@ void DispatchCanMakePaymentEvent(
   // This object self-deletes after either success or error callback is
   // invoked.
   RespondWithCallback* respond_with_callback =
-      new CanMakePaymentRespondWithCallback(browser_context, active_version,
+      new CanMakePaymentRespondWithCallback(web_contents, active_version,
                                             std::move(callback));
 
   active_version->endpoint()->DispatchCanMakePaymentEvent(
@@ -484,7 +471,7 @@ void DispatchCanMakePaymentEvent(
 }
 
 void DispatchPaymentRequestEvent(
-    BrowserContext* browser_context,
+    WebContents* web_contents,
     PaymentRequestEventDataPtr event_data,
     PaymentAppProvider::InvokePaymentAppCallback callback,
     scoped_refptr<ServiceWorkerVersion> active_version,
@@ -509,7 +496,7 @@ void DispatchPaymentRequestEvent(
   // This object self-deletes after either success or error callback is
   // invoked.
   RespondWithCallback* respond_with_callback = new InvokeRespondWithCallback(
-      browser_context, active_version, std::move(callback));
+      web_contents, active_version, std::move(callback));
 
   active_version->endpoint()->DispatchPaymentRequestEvent(
       std::move(event_data), respond_with_callback->BindNewPipeAndPassRemote(),
@@ -547,51 +534,15 @@ void FindRegistrationOnCoreThread(
       base::BindOnce(&DidFindRegistrationOnCoreThread, std::move(callback)));
 }
 
-void StartServiceWorkerForDispatch(BrowserContext* browser_context,
-                                   int64_t registration_id,
-                                   ServiceWorkerStartCallback callback) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-  StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>(
-      BrowserContext::GetDefaultStoragePartition(browser_context));
-  scoped_refptr<ServiceWorkerContextWrapper> service_worker_context =
-      partition->GetServiceWorkerContext();
-
-  RunOrPostTaskOnThread(FROM_HERE, ServiceWorkerContext::GetCoreThreadId(),
-                        base::BindOnce(&FindRegistrationOnCoreThread,
-                                       std::move(service_worker_context),
-                                       registration_id, std::move(callback)));
-}
-
-void OnInstallPaymentApp(
-    const url::Origin& sw_origin,
-    PaymentRequestEventDataPtr event_data,
-    PaymentAppProvider::RegistrationIdCallback registration_id_callback,
-    PaymentAppProvider::InvokePaymentAppCallback callback,
-    WebContents* web_contents,
-    int64_t registration_id) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-  if (registration_id >= 0 && web_contents != nullptr) {
-    std::move(registration_id_callback).Run(registration_id);
-    PaymentAppProvider::GetInstance()->InvokePaymentApp(
-        web_contents, registration_id, sw_origin, std::move(event_data),
-        std::move(callback));
-  } else {
-    std::move(callback).Run(CreateBlankPaymentHandlerResponse(
-        PaymentEventResponseType::PAYMENT_EVENT_BROWSER_ERROR));
-  }
-}
-
-void AbortInvokePaymentApp(BrowserContext* browser_context,
+void AbortInvokePaymentApp(WebContents* web_contents,
                            PaymentEventResponseType reason) {
   DCHECK_CURRENTLY_ON(ServiceWorkerContext::GetCoreThreadId());
-  if (!browser_context)
+  if (!web_contents)
     return;
 
   InvokeRespondWithCallback* callback =
       InvokePaymentAppCallbackRepository::GetInstance()->GetCallback(
-          browser_context);
+          web_contents->GetBrowserContext());
   if (callback)
     callback->AbortPaymentSinceOpennedWindowClosing(reason);
 }
@@ -624,25 +575,6 @@ void AddModifiersToMap(const std::vector<PaymentDetailsModifierPtr>& modifiers,
   }
 }
 
-scoped_refptr<DevToolsBackgroundServicesContextImpl> GetDevTools(
-    BrowserContext* browser_context,
-    const url::Origin& sw_origin) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  DCHECK(browser_context);
-  auto* storage_partition = BrowserContext::GetStoragePartitionForSite(
-      browser_context, sw_origin.GetURL(), /*can_create=*/true);
-  if (!storage_partition)
-    return nullptr;
-
-  scoped_refptr<DevToolsBackgroundServicesContextImpl> dev_tools =
-      static_cast<DevToolsBackgroundServicesContextImpl*>(
-          storage_partition->GetDevToolsBackgroundServicesContext());
-  return dev_tools && dev_tools->IsRecording(
-                          DevToolsBackgroundService::kPaymentHandler)
-             ? dev_tools
-             : nullptr;
-}
-
 void OnResponseForCanMakePaymentOnUiThread(
     scoped_refptr<DevToolsBackgroundServicesContextImpl> dev_tools,
     int64_t registration_id,
@@ -724,28 +656,32 @@ void OnResponseForPaymentRequestOnUiThread(
 }  // namespace
 
 // static
-PaymentAppProvider* PaymentAppProvider::GetInstance() {
-  return PaymentAppProviderImpl::GetInstance();
+PaymentAppProvider* PaymentAppProvider::GetOrCreateForWebContents(
+    WebContents* web_contents) {
+  return PaymentAppProviderImpl::GetOrCreateForWebContents(web_contents);
 }
 
 // static
-PaymentAppProviderImpl* PaymentAppProviderImpl::GetInstance() {
+PaymentAppProviderImpl* PaymentAppProviderImpl::GetOrCreateForWebContents(
+    WebContents* web_contents) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  return base::Singleton<PaymentAppProviderImpl>::get();
+  auto* data = PaymentAppProviderImpl::FromWebContents(web_contents);
+  if (!data)
+    PaymentAppProviderImpl::CreateForWebContents(web_contents);
+
+  return PaymentAppProviderImpl::FromWebContents(web_contents);
 }
 
 void PaymentAppProviderImpl::InvokePaymentApp(
-    WebContents* web_contents,
     int64_t registration_id,
     const url::Origin& sw_origin,
     PaymentRequestEventDataPtr event_data,
     InvokePaymentAppCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (!web_contents)
-    return;
+  DCHECK(web_contents_);
 
   scoped_refptr<DevToolsBackgroundServicesContextImpl> dev_tools =
-      GetDevTools(web_contents->GetBrowserContext(), sw_origin);
+      GetDevTools(sw_origin);
   if (dev_tools) {
     std::map<std::string, std::string> data = {
         {"Merchant Top Origin", event_data->top_origin.spec()},
@@ -764,17 +700,15 @@ void PaymentAppProviderImpl::InvokePaymentApp(
   }
 
   StartServiceWorkerForDispatch(
-      web_contents->GetBrowserContext(), registration_id,
+      registration_id,
       base::BindOnce(
-          &DispatchPaymentRequestEvent, web_contents->GetBrowserContext(),
-          std::move(event_data),
+          &DispatchPaymentRequestEvent, web_contents_, std::move(event_data),
           base::BindOnce(&OnResponseForPaymentRequestOnUiThread, dev_tools,
                          registration_id, sw_origin,
                          event_data->payment_request_id, std::move(callback))));
 }
 
 void PaymentAppProviderImpl::InstallAndInvokePaymentApp(
-    WebContents* web_contents,
     PaymentRequestEventDataPtr event_data,
     const std::string& app_name,
     const SkBitmap& app_icon,
@@ -786,8 +720,7 @@ void PaymentAppProviderImpl::InstallAndInvokePaymentApp(
     RegistrationIdCallback registration_id_callback,
     InvokePaymentAppCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (!web_contents)
-    return;
+  DCHECK(web_contents_);
 
   if (!sw_js_url.is_valid() || !sw_scope.is_valid() || method.empty()) {
     GetUIThreadTaskRunner({})->PostTask(
@@ -810,15 +743,15 @@ void PaymentAppProviderImpl::InstallAndInvokePaymentApp(
   }
 
   PaymentAppInstaller::Install(
-      web_contents, app_name, string_encoded_icon, sw_js_url, sw_scope,
+      web_contents_, app_name, string_encoded_icon, sw_js_url, sw_scope,
       sw_use_cache, method, supported_delegations,
-      base::BindOnce(&OnInstallPaymentApp, url::Origin::Create(sw_scope),
-                     std::move(event_data), std::move(registration_id_callback),
-                     std::move(callback)));
+      base::BindOnce(&PaymentAppProviderImpl::OnInstallPaymentApp,
+                     weak_ptr_factory_.GetWeakPtr(),
+                     url::Origin::Create(sw_scope), std::move(event_data),
+                     std::move(registration_id_callback), std::move(callback)));
 }
 
 void PaymentAppProviderImpl::UpdatePaymentAppIcon(
-    BrowserContext* browser_context,
     int64_t registration_id,
     const std::string& instrument_key,
     const std::string& name,
@@ -827,7 +760,8 @@ void PaymentAppProviderImpl::UpdatePaymentAppIcon(
     const SupportedDelegations& supported_delegations,
     PaymentAppProvider::UpdatePaymentAppIconCallback callback) {
   StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>(
-      BrowserContext::GetDefaultStoragePartition(browser_context));
+      BrowserContext::GetDefaultStoragePartition(
+          web_contents_->GetBrowserContext()));
   scoped_refptr<PaymentAppContextImpl> payment_app_context =
       partition->GetPaymentAppContext();
 
@@ -839,18 +773,16 @@ void PaymentAppProviderImpl::UpdatePaymentAppIcon(
 }
 
 void PaymentAppProviderImpl::CanMakePayment(
-    WebContents* web_contents,
     int64_t registration_id,
     const url::Origin& sw_origin,
     const std::string& payment_request_id,
     CanMakePaymentEventDataPtr event_data,
     CanMakePaymentCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (!web_contents)
-    return;
+  DCHECK(web_contents_);
 
   scoped_refptr<DevToolsBackgroundServicesContextImpl> dev_tools =
-      GetDevTools(web_contents->GetBrowserContext(), sw_origin);
+      GetDevTools(sw_origin);
   if (dev_tools) {
     std::map<std::string, std::string> data = {
         {"Merchant Top Origin", event_data->top_origin.spec()},
@@ -869,25 +801,23 @@ void PaymentAppProviderImpl::CanMakePayment(
   }
 
   StartServiceWorkerForDispatch(
-      web_contents->GetBrowserContext(), registration_id,
-      base::BindOnce(&DispatchCanMakePaymentEvent,
-                     web_contents->GetBrowserContext(), std::move(event_data),
+      registration_id,
+      base::BindOnce(&DispatchCanMakePaymentEvent, web_contents_,
+                     std::move(event_data),
                      base::BindOnce(&OnResponseForCanMakePaymentOnUiThread,
                                     dev_tools, registration_id, sw_origin,
                                     payment_request_id, std::move(callback))));
 }
 
-void PaymentAppProviderImpl::AbortPayment(WebContents* web_contents,
-                                          int64_t registration_id,
+void PaymentAppProviderImpl::AbortPayment(int64_t registration_id,
                                           const url::Origin& sw_origin,
                                           const std::string& payment_request_id,
                                           AbortCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (!web_contents)
-    return;
+  DCHECK(web_contents_);
 
   scoped_refptr<DevToolsBackgroundServicesContextImpl> dev_tools =
-      GetDevTools(web_contents->GetBrowserContext(), sw_origin);
+      GetDevTools(sw_origin);
   if (dev_tools) {
     dev_tools->LogBackgroundServiceEvent(
         registration_id, sw_origin, DevToolsBackgroundService::kPaymentHandler,
@@ -896,24 +826,22 @@ void PaymentAppProviderImpl::AbortPayment(WebContents* web_contents,
   }
 
   StartServiceWorkerForDispatch(
-      web_contents->GetBrowserContext(), registration_id,
-      base::BindOnce(&DispatchAbortPaymentEvent,
-                     web_contents->GetBrowserContext(),
+      registration_id,
+      base::BindOnce(&DispatchAbortPaymentEvent, web_contents_,
                      base::BindOnce(&OnResponseForAbortPaymentOnUiThread,
                                     dev_tools, registration_id, sw_origin,
                                     payment_request_id, std::move(callback))));
 }
 
-void PaymentAppProviderImpl::SetOpenedWindow(WebContents* web_contents) {
+void PaymentAppProviderImpl::SetOpenedWindow() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (!web_contents)
-    return;
+  DCHECK(web_contents_);
 
   CloseOpenedWindow();
   DCHECK(!payment_handler_window_);
 
   payment_handler_window_ =
-      std::make_unique<PaymentHandlerWindowObserver>(web_contents);
+      std::make_unique<PaymentHandlerWindowObserver>(web_contents_);
 }
 
 void PaymentAppProviderImpl::CloseOpenedWindow() {
@@ -930,56 +858,72 @@ void PaymentAppProviderImpl::CloseOpenedWindow() {
 }
 
 void PaymentAppProviderImpl::OnClosingOpenedWindow(
-    WebContents* web_contents,
     PaymentEventResponseType reason) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (!web_contents)
-    return;
+  DCHECK(web_contents_);
 
   RunOrPostTaskOnThread(
       FROM_HERE, ServiceWorkerContext::GetCoreThreadId(),
-      base::BindOnce(&AbortInvokePaymentApp, web_contents->GetBrowserContext(),
-                     reason));
+      base::BindOnce(&AbortInvokePaymentApp, web_contents_, reason));
 }
 
-bool PaymentAppProviderImpl::IsValidInstallablePaymentApp(
-    const GURL& manifest_url,
-    const GURL& sw_js_url,
-    const GURL& sw_scope,
-    std::string* error_message) {
-  DCHECK(manifest_url.is_valid() && sw_js_url.is_valid() &&
-         sw_scope.is_valid());
-
-  // Scope will be checked against service worker js url when registering, but
-  // we check it here earlier to avoid presenting unusable payment handlers.
-  if (!ServiceWorkerUtils::IsPathRestrictionSatisfiedWithoutHeader(
-          sw_scope, sw_js_url, error_message)) {
-    return false;
-  }
-
-  // TODO(crbug.com/855312): Unify duplicated code between here and
-  // ServiceWorkerProviderHost::IsValidRegisterMessage.
-  std::vector<GURL> urls = {manifest_url, sw_js_url, sw_scope};
-  if (!ServiceWorkerUtils::AllOriginsMatchAndCanAccessServiceWorkers(urls)) {
-    *error_message =
-        "Origins are not matching, or some origins cannot access service "
-        "worker "
-        "(manifest:" +
-        manifest_url.spec() + " scope:" + sw_scope.spec() +
-        " sw:" + sw_js_url.spec() + ")";
-    return false;
-  }
-
-  return true;
+scoped_refptr<DevToolsBackgroundServicesContextImpl>
+PaymentAppProviderImpl::GetDevTools(const url::Origin& sw_origin) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK(web_contents_);
+  auto* storage_partition = BrowserContext::GetStoragePartitionForSite(
+      web_contents_->GetBrowserContext(), sw_origin.GetURL(),
+      /*can_create=*/true);
+  if (!storage_partition)
+    return nullptr;
+
+  scoped_refptr<DevToolsBackgroundServicesContextImpl> dev_tools =
+      static_cast<DevToolsBackgroundServicesContextImpl*>(
+          storage_partition->GetDevToolsBackgroundServicesContext());
+  return dev_tools && dev_tools->IsRecording(
+                          DevToolsBackgroundService::kPaymentHandler)
+             ? dev_tools
+             : nullptr;
 }
 
-ukm::SourceId PaymentAppProviderImpl::GetSourceIdForPaymentAppFromScope(
-    const GURL& sw_scope) {
-  return ukm::UkmRecorder::GetSourceIdForPaymentAppFromScope(
-      sw_scope.GetOrigin());
+void PaymentAppProviderImpl::StartServiceWorkerForDispatch(
+    int64_t registration_id,
+    ServiceWorkerStartCallback callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>(
+      BrowserContext::GetDefaultStoragePartition(
+          web_contents_->GetBrowserContext()));
+  scoped_refptr<ServiceWorkerContextWrapper> service_worker_context =
+      partition->GetServiceWorkerContext();
+
+  RunOrPostTaskOnThread(FROM_HERE, ServiceWorkerContext::GetCoreThreadId(),
+                        base::BindOnce(&FindRegistrationOnCoreThread,
+                                       std::move(service_worker_context),
+                                       registration_id, std::move(callback)));
+}
+
+void PaymentAppProviderImpl::OnInstallPaymentApp(
+    const url::Origin& sw_origin,
+    PaymentRequestEventDataPtr event_data,
+    RegistrationIdCallback registration_id_callback,
+    InvokePaymentAppCallback callback,
+    int64_t registration_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK(web_contents_);
+
+  if (registration_id >= 0) {
+    std::move(registration_id_callback).Run(registration_id);
+    InvokePaymentApp(registration_id, sw_origin, std::move(event_data),
+                     std::move(callback));
+  } else {
+    std::move(callback).Run(CreateBlankPaymentHandlerResponse(
+        PaymentEventResponseType::PAYMENT_EVENT_BROWSER_ERROR));
+  }
 }
 
-PaymentAppProviderImpl::PaymentAppProviderImpl() = default;
+PaymentAppProviderImpl::PaymentAppProviderImpl(WebContents* web_contents)
+    : web_contents_(web_contents) {}
 
 PaymentAppProviderImpl::~PaymentAppProviderImpl() = default;
 
@@ -989,4 +933,5 @@ PaymentAppProviderImpl::PaymentHandlerWindowObserver::
 PaymentAppProviderImpl::PaymentHandlerWindowObserver::
     ~PaymentHandlerWindowObserver() = default;
 
+WEB_CONTENTS_USER_DATA_KEY_IMPL(PaymentAppProviderImpl)
 }  // namespace content

content/browser/payments/payment_app_provider_impl.h

@@ -5,16 +5,27 @@
 #ifndef CONTENT_BROWSER_PAYMENTS_PAYMENT_APP_PROVIDER_IMPL_H_
 #define CONTENT_BROWSER_PAYMENTS_PAYMENT_APP_PROVIDER_IMPL_H_
 
-#include "base/memory/singleton.h"
+#include "content/browser/devtools/devtools_background_services_context_impl.h"
+#include "content/browser/payments/payment_app_context_impl.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/payment_app_provider.h"
 #include "content/public/browser/web_contents_observer.h"
+#include "content/public/browser/web_contents_user_data.h"
 
 namespace content {
 
-class CONTENT_EXPORT PaymentAppProviderImpl : public PaymentAppProvider {
+using payments::mojom::PaymentRequestEventDataPtr;
+using ServiceWorkerStartCallback =
+    base::OnceCallback<void(scoped_refptr<ServiceWorkerVersion>,
+                            blink::ServiceWorkerStatusCode)>;
+
+class CONTENT_EXPORT PaymentAppProviderImpl
+    : public PaymentAppProvider,
+      public WebContentsUserData<PaymentAppProviderImpl> {
  public:
-  static PaymentAppProviderImpl* GetInstance();
+  ~PaymentAppProviderImpl() override;
+  static PaymentAppProviderImpl* GetOrCreateForWebContents(
+      WebContents* web_contents);
 
   // Disallow copy and assign.
   PaymentAppProviderImpl(const PaymentAppProviderImpl& other) = delete;
@@ -23,13 +34,11 @@ class CONTENT_EXPORT PaymentAppProviderImpl : public PaymentAppProvider {
 
   // PaymentAppProvider implementation:
   // Should be accessed only on the UI thread.
-  void InvokePaymentApp(WebContents* web_contents,
-                        int64_t registration_id,
+  void InvokePaymentApp(int64_t registration_id,
                         const url::Origin& sw_origin,
                         payments::mojom::PaymentRequestEventDataPtr event_data,
                         InvokePaymentAppCallback callback) override;
   void InstallAndInvokePaymentApp(
-      WebContents* web_contents,
       payments::mojom::PaymentRequestEventDataPtr event_data,
       const std::string& app_name,
       const SkBitmap& app_icon,
@@ -40,42 +49,41 @@ class CONTENT_EXPORT PaymentAppProviderImpl : public PaymentAppProvider {
       const SupportedDelegations& supported_delegations,
       RegistrationIdCallback registration_id_callback,
       InvokePaymentAppCallback callback) override;
-  void UpdatePaymentAppIcon(BrowserContext* browser_context,
-                            int64_t registration_id,
+  void UpdatePaymentAppIcon(int64_t registration_id,
                             const std::string& instrument_key,
                             const std::string& name,
                             const std::string& string_encoded_icon,
                             const std::string& method_name,
                             const SupportedDelegations& supported_delegations,
                             UpdatePaymentAppIconCallback callback) override;
-  void CanMakePayment(WebContents* web_contents,
-                      int64_t registration_id,
+  void CanMakePayment(int64_t registration_id,
                       const url::Origin& sw_origin,
                       const std::string& payment_request_id,
                       payments::mojom::CanMakePaymentEventDataPtr event_data,
                       CanMakePaymentCallback callback) override;
-  void AbortPayment(WebContents* web_contents,
-                    int64_t registration_id,
+  void AbortPayment(int64_t registration_id,
                     const url::Origin& sw_origin,
                     const std::string& payment_request_id,
                     AbortCallback callback) override;
-  void SetOpenedWindow(WebContents* web_contents) override;
+  void SetOpenedWindow() override;
   void CloseOpenedWindow() override;
   void OnClosingOpenedWindow(
-      WebContents* web_contents,
       payments::mojom::PaymentEventResponseType reason) override;
-  bool IsValidInstallablePaymentApp(const GURL& manifest_url,
-                                    const GURL& sw_js_url,
-                                    const GURL& sw_scope,
-                                    std::string* error_message) override;
-  ukm::SourceId GetSourceIdForPaymentAppFromScope(
-      const GURL& sw_scope) override;
 
  private:
-  PaymentAppProviderImpl();
-  ~PaymentAppProviderImpl() override;
+  explicit PaymentAppProviderImpl(WebContents* web_contents);
+  friend class WebContentsUserData<PaymentAppProviderImpl>;
+  WEB_CONTENTS_USER_DATA_KEY_DECL();
 
-  friend struct base::DefaultSingletonTraits<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);
 
   // Note that constructor of WebContentsObserver is protected.
   class PaymentHandlerWindowObserver : public WebContentsObserver {
@@ -85,6 +93,11 @@ class CONTENT_EXPORT PaymentAppProviderImpl : public PaymentAppProvider {
   };
 
   std::unique_ptr<PaymentHandlerWindowObserver> payment_handler_window_;
+
+  // Owns this object.
+  WebContents* web_contents_;
+
+  base::WeakPtrFactory<PaymentAppProviderImpl> weak_ptr_factory_{this};
 };
 
 }  // namespace content

content/browser/payments/payment_app_provider_impl_unittest.cc

@@ -11,7 +11,7 @@
 #include "base/run_loop.h"
 #include "content/browser/payments/installed_payment_apps_finder_impl.h"
 #include "content/browser/payments/payment_app_content_unittest_base.h"
-#include "content/browser/payments/payment_app_provider_impl.h"
+#include "content/public/browser/payment_app_provider.h"
 #include "content/public/browser/permission_type.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/mock_permission_manager.h"
@@ -107,9 +107,9 @@ class PaymentAppProviderTest : public PaymentAppContentUnitTestBase {
                         const url::Origin& sw_origin,
                         payments::mojom::PaymentRequestEventDataPtr event_data,
                         PaymentAppProvider::InvokePaymentAppCallback callback) {
-    PaymentAppProviderImpl::GetInstance()->InvokePaymentApp(
-        web_contents_, registration_id, sw_origin, std::move(event_data),
-        std::move(callback));
+    PaymentAppProvider::GetOrCreateForWebContents(web_contents_)
+        ->InvokePaymentApp(registration_id, sw_origin, std::move(event_data),
+                           std::move(callback));
     base::RunLoop().RunUntilIdle();
   }
 
@@ -118,24 +118,24 @@ class PaymentAppProviderTest : public PaymentAppContentUnitTestBase {
                       const std::string& payment_request_id,
                       payments::mojom::CanMakePaymentEventDataPtr event_data,
                       PaymentAppProvider::CanMakePaymentCallback callback) {
-    PaymentAppProviderImpl::GetInstance()->CanMakePayment(
-        web_contents_, registration_id, sw_origin, payment_request_id,
-        std::move(event_data), std::move(callback));
+    PaymentAppProvider::GetOrCreateForWebContents(web_contents_)
+        ->CanMakePayment(registration_id, sw_origin, payment_request_id,
+                         std::move(event_data), std::move(callback));
   }
 
   void AbortPayment(int64_t registration_id,
                     const url::Origin& sw_origin,
                     const std::string& payment_request_id,
                     PaymentAppProvider::AbortCallback callback) {
-    PaymentAppProviderImpl::GetInstance()->AbortPayment(
-        web_contents_, registration_id, sw_origin, payment_request_id,
-        std::move(callback));
+    PaymentAppProvider::GetOrCreateForWebContents(web_contents_)
+        ->AbortPayment(registration_id, sw_origin, payment_request_id,
+                       std::move(callback));
   }
 
   void OnClosingOpenedWindow() {
-    PaymentAppProviderImpl::GetInstance()->OnClosingOpenedWindow(
-        web_contents_, payments::mojom::PaymentEventResponseType::
-                           PAYMENT_HANDLER_WINDOW_CLOSING);
+    PaymentAppProvider::GetOrCreateForWebContents(web_contents_)
+        ->OnClosingOpenedWindow(payments::mojom::PaymentEventResponseType::
+                                    PAYMENT_HANDLER_WINDOW_CLOSING);
     base::RunLoop().RunUntilIdle();
   }
 

content/browser/payments/payment_app_provider_util.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/public/browser/payment_app_provider_util.h"
+
+#include "content/common/service_worker/service_worker_utils.h"
+#include "content/public/browser/browser_thread.h"
+
+namespace content {
+
+// static
+ukm::SourceId PaymentAppProviderUtil::GetSourceIdForPaymentAppFromScope(
+    const GURL& sw_scope) {
+  return ukm::UkmRecorder::GetSourceIdForPaymentAppFromScope(
+      sw_scope.GetOrigin());
+}
+
+// static
+bool PaymentAppProviderUtil::IsValidInstallablePaymentApp(
+    const GURL& manifest_url,
+    const GURL& sw_js_url,
+    const GURL& sw_scope,
+    std::string* error_message) {
+  DCHECK(manifest_url.is_valid() && sw_js_url.is_valid() &&
+         sw_scope.is_valid());
+
+  // Scope will be checked against service worker js url when registering, but
+  // we check it here earlier to avoid presenting unusable payment handlers.
+  if (!ServiceWorkerUtils::IsPathRestrictionSatisfiedWithoutHeader(
+          sw_scope, sw_js_url, error_message)) {
+    return false;
+  }
+
+  // TODO(crbug.com/855312): Unify duplicated code between here and
+  // ServiceWorkerProviderHost::IsValidRegisterMessage.
+  std::vector<GURL> urls = {manifest_url, sw_js_url, sw_scope};
+  if (!ServiceWorkerUtils::AllOriginsMatchAndCanAccessServiceWorkers(urls)) {
+    *error_message =
+        "Origins are not matching, or some origins cannot access service "
+        "worker (manifest:" +
+        manifest_url.spec() + " scope:" + sw_scope.spec() +
+        " sw:" + sw_js_url.spec() + ")";
+    return false;
+  }
+
+  return true;
+}
+
+}  // namespace content

content/browser/service_worker/service_worker_client_utils.cc

@@ -213,7 +213,8 @@ void DidOpenURLOnUI(WindowType type,
   if (type == WindowType::PAYMENT_HANDLER_WINDOW) {
     // Set the opened web_contents to payment app provider to manage its life
     // cycle.
-    PaymentAppProvider::GetInstance()->SetOpenedWindow(web_contents);
+    PaymentAppProvider::GetOrCreateForWebContents(web_contents)
+        ->SetOpenedWindow();
   }
 }
 

content/public/browser/BUILD.gn

@@ -270,6 +270,7 @@ source_set("browser_sources") {
     "page_navigator.cc",
     "page_navigator.h",
     "payment_app_provider.h",
+    "payment_app_provider_util.h",
     "peak_gpu_memory_tracker.h",
     "pepper_flash_settings_helper.h",
     "pepper_vpn_provider_resource_host_proxy.h",

content/public/browser/payment_app_provider.h

@@ -7,7 +7,6 @@
 
 #include "base/callback_forward.h"
 #include "content/common/content_export.h"
-#include "services/metrics/public/cpp/ukm_recorder.h"
 #include "third_party/blink/public/mojom/payments/payment_app.mojom.h"
 
 class SkBitmap;
@@ -18,7 +17,6 @@ class Origin;
 
 namespace content {
 
-class BrowserContext;
 class WebContents;
 struct SupportedDelegations;
 
@@ -33,7 +31,8 @@ class CONTENT_EXPORT PaymentAppProvider {
  public:
   // This static function is actually implemented in PaymentAppProviderImpl.cc.
   // Please see: content/browser/payments/payment_app_provider_impl.cc
-  static PaymentAppProvider* GetInstance();
+  static PaymentAppProvider* GetOrCreateForWebContents(
+      WebContents* web_contents);
 
   using RegistrationIdCallback =
       base::OnceCallback<void(int64_t registration_id)>;
@@ -47,13 +46,11 @@ class CONTENT_EXPORT PaymentAppProvider {
 
   // Should be accessed only on the UI thread.
   virtual void InvokePaymentApp(
-      WebContents* web_contents,
       int64_t registration_id,
       const url::Origin& sw_origin,
       payments::mojom::PaymentRequestEventDataPtr event_data,
       InvokePaymentAppCallback callback) = 0;
   virtual void InstallAndInvokePaymentApp(
-      WebContents* web_contents,
       payments::mojom::PaymentRequestEventDataPtr event_data,
       const std::string& app_name,
       const SkBitmap& app_icon,
@@ -65,7 +62,6 @@ class CONTENT_EXPORT PaymentAppProvider {
       RegistrationIdCallback registration_id_callback,
       InvokePaymentAppCallback callback) = 0;
   virtual void UpdatePaymentAppIcon(
-      BrowserContext* browser_context,
       int64_t registration_id,
       const std::string& instrument_key,
       const std::string& name,
@@ -74,14 +70,12 @@ class CONTENT_EXPORT PaymentAppProvider {
       const SupportedDelegations& supported_delegations,
       UpdatePaymentAppIconCallback callback) = 0;
   virtual void CanMakePayment(
-      WebContents* web_contents,
       int64_t registration_id,
       const url::Origin& sw_origin,
       const std::string& payment_request_id,
       payments::mojom::CanMakePaymentEventDataPtr event_data,
       CanMakePaymentCallback callback) = 0;
-  virtual void AbortPayment(WebContents* web_contents,
-                            int64_t registration_id,
+  virtual void AbortPayment(int64_t registration_id,
                             const url::Origin& sw_origin,
                             const std::string& payment_request_id,
                             AbortCallback callback) = 0;
@@ -90,27 +84,14 @@ class CONTENT_EXPORT PaymentAppProvider {
   // opened window for payment handler at any moment in a browser context. The
   // previously opened window in the same browser context will be closed after
   // calling this interface.
-  virtual void SetOpenedWindow(WebContents* web_contents) = 0;
+  virtual void SetOpenedWindow() = 0;
   virtual void CloseOpenedWindow() = 0;
 
   // Notify the opened payment handler window is closing or closed by user so as
   // to abort payment request.
   virtual void OnClosingOpenedWindow(
-      WebContents* web_contents,
       payments::mojom::PaymentEventResponseType reason) = 0;
 
-  // Check whether given |sw_js_url| from |manifest_url| is allowed to register
-  // with |sw_scope|.
-  virtual bool IsValidInstallablePaymentApp(const GURL& manifest_url,
-                                            const GURL& sw_js_url,
-                                            const GURL& sw_scope,
-                                            std::string* error_message) = 0;
-
-  // Gets the ukm source id for a payment app with |sw_scope|.
-  // This must ONLY be called when payment app window has been opened.
-  virtual ukm::SourceId GetSourceIdForPaymentAppFromScope(
-      const GURL& sw_scope) = 0;
-
  protected:
   virtual ~PaymentAppProvider() = default;
 };

content/public/browser/payment_app_provider_util.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_PUBLIC_BROWSER_PAYMENT_APP_PROVIDER_UTIL_H_
+#define CONTENT_PUBLIC_BROWSER_PAYMENT_APP_PROVIDER_UTIL_H_
+
+#include "content/common/content_export.h"
+#include "services/metrics/public/cpp/ukm_recorder.h"
+#include "third_party/blink/public/mojom/payments/payment_app.mojom.h"
+
+namespace content {
+
+class CONTENT_EXPORT PaymentAppProviderUtil {
+ public:
+  // Gets the ukm source id for a payment app with |sw_scope|.
+  // This must ONLY be called when payment app window has been opened.
+  static ukm::SourceId GetSourceIdForPaymentAppFromScope(const GURL& sw_scope);
+
+  // Check whether given |sw_js_url| from |manifest_url| is allowed to register
+  // with |sw_scope|.
+  static bool IsValidInstallablePaymentApp(const GURL& manifest_url,
+                                           const GURL& sw_js_url,
+                                           const GURL& sw_scope,
+                                           std::string* error_message);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_PUBLIC_BROWSER_PAYMENT_APP_PROVIDER_UTIL_H_

services/metrics/public/cpp/ukm_recorder.h

@@ -29,7 +29,7 @@ class UkmRecorderInterface;
 }  // namespace metrics
 
 namespace content {
-class PaymentAppProviderImpl;
+class PaymentAppProviderUtil;
 }  // namespace content
 
 namespace web_app {
@@ -94,7 +94,7 @@ class METRICS_EXPORT UkmRecorder {
 
   // Gets new source Id for PAYMENT_APP_ID type and updates the source url to
   // the scope of the app. This method should only be called by
-  // PaymentAppProviderImpl class when the payment app window is opened.
+  // PaymentAppProviderUtil class when the payment app window is opened.
   static SourceId GetSourceIdForPaymentAppFromScope(
       const GURL& service_worker_scope);
 
@@ -105,7 +105,7 @@ class METRICS_EXPORT UkmRecorder {
   friend blink::Document;
   friend metrics::UkmRecorderInterface;
   friend PermissionUmaUtil;
-  friend content::PaymentAppProviderImpl;
+  friend content::PaymentAppProviderUtil;
 
   // WebApkUkmRecorder and DesktopWebAppUkmRecorder record metrics about
   // installed web apps. Instead of using