[Web Payment] Make PaymentAppProvider use WebContents*

This patch makes PaymentAppProvider methods take a WebContents* instead
of BrowserContext*. This is a first step toward making WebContents own
PaymentAppProviderImpl rather than it being a singleton.

The payment_handler_windows_ map is changed to a single
payment_handler_window_, but note this is just to remove the
BrowserContext* key dependency, we still enforce one payment request
per browser via PaymentRequestDisplayManager.

PaymentAppProviderImpl's RespondWithCallback and callback repository
still depend on BrowserContext*, since the callback may outlive the
WebContents. This will be cleaned up in step (3) of the bug, where the
callbacks will be owned by PaymentAppProviderImpl instead of a singleton
repository.

Bug: 1075687
Change-Id: Ib4460b82f9938e973f067f45669a6031f7f0da3c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2240064Reviewed-by: Rouslan Solomakhin <rouslan@chromium.org>
Reviewed-by: Avi Drissman <avi@chromium.org>
Reviewed-by: Sahel Sharify <sahel@chromium.org>
Commit-Queue: Nick Burris <nburris@chromium.org>
Cr-Commit-Position: refs/heads/master@{#779343}

chrome/browser/payments/android/service_worker_payment_app_bridge.cc

@@ -123,7 +123,7 @@ static void JNI_ServiceWorkerPaymentAppBridge_OnClosingPaymentAppWindow(
       content::WebContents::FromJavaWebContents(jweb_contents);
 
   content::PaymentAppProvider::GetInstance()->OnClosingOpenedWindow(
-      web_contents->GetBrowserContext(),
+      web_contents,
       static_cast<payments::mojom::PaymentEventResponseType>(reason));
 }
 

components/payments/content/payment_app_unittest.cc

@@ -85,7 +85,7 @@ class PaymentAppTest : public testing::TestWithParam<RequiredPaymentOptions>,
     }
 
     return std::make_unique<ServiceWorkerPaymentApp>(
-        &browser_context_, GURL("https://testmerchant.com"),
+        web_contents_, GURL("https://testmerchant.com"),
         GURL("https://testmerchant.com/bobpay"), spec_.get(),
         std::move(stored_app), /*is_incognito=*/false,
         /*show_processing_spinner=*/base::DoNothing());

components/payments/content/service_worker_payment_app.cc

@@ -18,7 +18,6 @@
 #include "components/payments/content/payment_request_converter.h"
 #include "components/payments/core/features.h"
 #include "components/payments/core/method_strings.h"
-#include "content/public/browser/browser_context.h"
 #include "content/public/browser/payment_app_provider.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_features.h"
@@ -30,7 +29,7 @@ namespace payments {
 // Service worker payment app provides icon through bitmap, so set 0 as invalid
 // resource Id.
 ServiceWorkerPaymentApp::ServiceWorkerPaymentApp(
-    content::BrowserContext* browser_context,
+    content::WebContents* web_contents,
     const GURL& top_origin,
     const GURL& frame_origin,
     const PaymentRequestSpec* spec,
@@ -38,7 +37,7 @@ ServiceWorkerPaymentApp::ServiceWorkerPaymentApp(
     bool is_incognito,
     const base::RepeatingClosure& show_processing_spinner)
     : PaymentApp(0, PaymentApp::Type::SERVICE_WORKER_APP),
-      browser_context_(browser_context),
+      content::WebContentsObserver(web_contents),
       top_origin_(top_origin),
       frame_origin_(frame_origin),
       spec_(spec),
@@ -48,9 +47,8 @@ ServiceWorkerPaymentApp::ServiceWorkerPaymentApp(
       show_processing_spinner_(show_processing_spinner),
       can_make_payment_result_(false),
       has_enrolled_instrument_result_(false),
-      needs_installation_(false),
-      web_contents_(nullptr) {
-  DCHECK(browser_context_);
+      needs_installation_(false) {
+  DCHECK(web_contents);
   DCHECK(top_origin_.is_valid());
   DCHECK(frame_origin_.is_valid());
   DCHECK(spec_);
@@ -71,7 +69,7 @@ ServiceWorkerPaymentApp::ServiceWorkerPaymentApp(
     bool is_incognito,
     const base::RepeatingClosure& show_processing_spinner)
     : PaymentApp(0, PaymentApp::Type::SERVICE_WORKER_APP),
-      browser_context_(web_contents->GetBrowserContext()),
+      content::WebContentsObserver(web_contents),
       top_origin_(top_origin),
       frame_origin_(frame_origin),
       spec_(spec),
@@ -81,11 +79,9 @@ ServiceWorkerPaymentApp::ServiceWorkerPaymentApp(
       can_make_payment_result_(false),
       has_enrolled_instrument_result_(false),
       needs_installation_(true),
-      web_contents_(web_contents),
       installable_web_app_info_(std::move(installable_payment_app_info)),
       installable_enabled_method_(enabled_method) {
-  DCHECK(browser_context_);
-  DCHECK(web_contents_);
+  DCHECK(web_contents);
   DCHECK(top_origin_.is_valid());
   DCHECK(frame_origin_.is_valid());
   DCHECK(spec_);
@@ -135,7 +131,7 @@ void ServiceWorkerPaymentApp::ValidateCanMakePayment(
   }
 
   content::PaymentAppProvider::GetInstance()->CanMakePayment(
-      browser_context_, stored_payment_app_info_->registration_id,
+      web_contents(), 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,
@@ -213,7 +209,7 @@ void ServiceWorkerPaymentApp::InvokePaymentApp(Delegate* delegate) {
 
   if (needs_installation_) {
     content::PaymentAppProvider::GetInstance()->InstallAndInvokePaymentApp(
-        web_contents_, CreatePaymentRequestEventData(),
+        web_contents(), CreatePaymentRequestEventData(),
         installable_web_app_info_->name,
         installable_web_app_info_->icon == nullptr
             ? SkBitmap()
@@ -233,7 +229,7 @@ void ServiceWorkerPaymentApp::InvokePaymentApp(Delegate* delegate) {
         url::Origin::Create(stored_payment_app_info_->scope);
     OnPaymentAppIdentity(sw_origin, stored_payment_app_info_->registration_id);
     content::PaymentAppProvider::GetInstance()->InvokePaymentApp(
-        browser_context_, stored_payment_app_info_->registration_id, sw_origin,
+        web_contents(), stored_payment_app_info_->registration_id, sw_origin,
         CreatePaymentRequestEventData(),
         base::BindOnce(&ServiceWorkerPaymentApp::OnPaymentAppInvoked,
                        weak_ptr_factory_.GetWeakPtr()));
@@ -245,7 +241,7 @@ void ServiceWorkerPaymentApp::InvokePaymentApp(Delegate* delegate) {
 void ServiceWorkerPaymentApp::OnPaymentAppWindowClosed() {
   delegate_ = nullptr;
   content::PaymentAppProvider::GetInstance()->OnClosingOpenedWindow(
-      browser_context_,
+      web_contents(),
       mojom::PaymentEventResponseType::PAYMENT_HANDLER_WINDOW_CLOSING);
 }
 
@@ -597,7 +593,7 @@ void ServiceWorkerPaymentApp::OnPaymentDetailsNotUpdated() {
 void ServiceWorkerPaymentApp::AbortPaymentApp(
     base::OnceCallback<void(bool)> abort_callback) {
   content::PaymentAppProvider::GetInstance()->AbortPayment(
-      browser_context_, registration_id_,
+      web_contents(), registration_id_,
       stored_payment_app_info_
           ? url::Origin::Create(stored_payment_app_info_->scope)
           : url::Origin::Create(GURL(installable_web_app_info_->sw_scope)),

components/payments/content/service_worker_payment_app.h

@@ -13,13 +13,13 @@
 #include "components/payments/content/payment_request_spec.h"
 #include "components/payments/content/web_app_manifest.h"
 #include "content/public/browser/stored_payment_app.h"
+#include "content/public/browser/web_contents_observer.h"
 #include "mojo/public/cpp/bindings/pending_remote.h"
 #include "third_party/blink/public/mojom/payments/payment_app.mojom.h"
 #include "third_party/blink/public/mojom/payments/payment_handler_host.mojom.h"
 #include "third_party/blink/public/mojom/payments/payment_request.mojom.h"
 
 namespace content {
-class BrowserContext;
 class WebContents;
 }  // namespace content
 
@@ -32,12 +32,13 @@ namespace payments {
 class PaymentHandlerHost;
 
 // Represents a service worker based payment app.
-class ServiceWorkerPaymentApp : public PaymentApp {
+class ServiceWorkerPaymentApp : public PaymentApp,
+                                public content::WebContentsObserver {
  public:
   // This constructor is used for a payment app that has been installed in
   // Chrome.
   ServiceWorkerPaymentApp(
-      content::BrowserContext* browser_context,
+      content::WebContents* web_contents,
       const GURL& top_origin,
       const GURL& frame_origin,
       const PaymentRequestSpec* spec,
@@ -128,7 +129,6 @@ class ServiceWorkerPaymentApp : public PaymentApp {
   //    invoked.
   void OnPaymentAppIdentity(const url::Origin& origin, int64_t registration_id);
 
-  content::BrowserContext* browser_context_;
   GURL top_origin_;
   GURL frame_origin_;
   const PaymentRequestSpec* spec_;
@@ -157,7 +157,6 @@ class ServiceWorkerPaymentApp : public PaymentApp {
   // Below variables are used for installable ServiceWorkerPaymentApp
   // specifically.
   bool needs_installation_;
-  content::WebContents* web_contents_;
   std::unique_ptr<WebAppInstallationInfo> installable_web_app_info_;
   std::string installable_enabled_method_;
 

components/payments/content/service_worker_payment_app_factory.cc

@@ -60,10 +60,10 @@ class ServiceWorkerPaymentAppCreator {
 
     for (auto& installed_app : apps) {
       auto app = std::make_unique<ServiceWorkerPaymentApp>(
-          delegate_->GetWebContents()->GetBrowserContext(),
-          delegate_->GetTopOrigin(), delegate_->GetFrameOrigin(),
-          delegate_->GetSpec(), std::move(installed_app.second),
-          delegate_->IsOffTheRecord(), show_processing_spinner);
+          delegate_->GetWebContents(), delegate_->GetTopOrigin(),
+          delegate_->GetFrameOrigin(), delegate_->GetSpec(),
+          std::move(installed_app.second), delegate_->IsOffTheRecord(),
+          show_processing_spinner);
       app->ValidateCanMakePayment(base::BindOnce(
           &ServiceWorkerPaymentAppCreator::OnSWPaymentAppValidated,
           weak_ptr_factory_.GetWeakPtr()));

components/payments/content/service_worker_payment_app_unittest.cc

@@ -11,6 +11,7 @@
 #include "content/public/browser/stored_payment_app.h"
 #include "content/public/test/browser_task_environment.h"
 #include "content/public/test/test_browser_context.h"
+#include "content/public/test/test_web_contents_factory.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/mojom/payments/payment_request.mojom.h"
 
@@ -19,8 +20,11 @@ namespace payments {
 class ServiceWorkerPaymentAppTest : public testing::Test,
                                     public PaymentRequestSpec::Observer {
  public:
-  ServiceWorkerPaymentAppTest() {}
-  ~ServiceWorkerPaymentAppTest() override {}
+  ServiceWorkerPaymentAppTest() {
+    web_contents_ =
+        test_web_contents_factory_.CreateWebContents(&browser_context_);
+  }
+  ~ServiceWorkerPaymentAppTest() override = default;
 
  protected:
   const SkBitmap* icon_bitmap() const { return icon_bitmap_; }
@@ -112,7 +116,7 @@ class ServiceWorkerPaymentAppTest : public testing::Test,
 
     icon_bitmap_ = stored_app->icon.get();
     app_ = std::make_unique<ServiceWorkerPaymentApp>(
-        &browser_context_, GURL("https://testmerchant.com"),
+        web_contents_, GURL("https://testmerchant.com"),
         GURL("https://testmerchant.com/bobpay"), spec_.get(),
         std::move(stored_app), /*is_incognito=*/false,
         /*show_processing_spinner=*/base::DoNothing());
@@ -131,6 +135,8 @@ class ServiceWorkerPaymentAppTest : public testing::Test,
  private:
   content::BrowserTaskEnvironment task_environment_;
   content::TestBrowserContext browser_context_;
+  content::TestWebContentsFactory test_web_contents_factory_;
+  content::WebContents* web_contents_;
 
   std::unique_ptr<PaymentRequestSpec> spec_;
   std::unique_ptr<ServiceWorkerPaymentApp> app_;

content/browser/payments/payment_app_browsertest.cc

@@ -131,8 +131,7 @@ class PaymentAppBrowserTest : public ContentBrowserTest {
     base::RunLoop run_loop;
     bool payment_aborted = false;
     PaymentAppProvider::GetInstance()->AbortPayment(
-        shell()->web_contents()->GetBrowserContext(), registration_id,
-        sw_origin, payment_request_id,
+        shell()->web_contents(), registration_id, sw_origin, payment_request_id,
         base::BindOnce(&CaptureAbortResult, run_loop.QuitClosure(),
                        &payment_aborted));
     run_loop.Run();
@@ -150,8 +149,8 @@ class PaymentAppBrowserTest : public ContentBrowserTest {
     base::RunLoop run_loop;
     bool can_make_payment = false;
     PaymentAppProvider::GetInstance()->CanMakePayment(
-        shell()->web_contents()->GetBrowserContext(), registration_id,
-        sw_origin, payment_request_id, std::move(event_data),
+        shell()->web_contents(), registration_id, sw_origin, payment_request_id,
+        std::move(event_data),
         base::BindOnce(&CaptureCanMakePaymentResult, run_loop.QuitClosure(),
                        &can_make_payment));
     run_loop.Run();
@@ -167,8 +166,7 @@ class PaymentAppBrowserTest : public ContentBrowserTest {
     base::RunLoop run_loop;
     PaymentHandlerResponsePtr response;
     PaymentAppProvider::GetInstance()->InvokePaymentApp(
-        shell()->web_contents()->GetBrowserContext(), registration_id,
-        sw_origin,
+        shell()->web_contents(), registration_id, sw_origin,
         CreatePaymentRequestEventData(supported_method, instrument_key),
         base::BindOnce(&InvokePaymentAppCallback, run_loop.QuitClosure(),
                        &response));

content/browser/payments/payment_app_installer.cc

@@ -208,8 +208,7 @@ class SelfDeleteInstaller
       return;
 
     if (success && web_contents() != nullptr) {
-      std::move(callback_).Run(web_contents()->GetBrowserContext(),
-                               registration_id_);
+      std::move(callback_).Run(web_contents(), registration_id_);
     } else {
       std::move(callback_).Run(nullptr, -1);
     }

content/browser/payments/payment_app_installer.h

@@ -16,7 +16,6 @@ class GURL;
 
 namespace content {
 
-class BrowserContext;
 class WebContents;
 
 // Installs a web payment app with a default payment instrument and returns
@@ -24,7 +23,7 @@ class WebContents;
 class PaymentAppInstaller {
  public:
   using InstallPaymentAppCallback =
-      base::OnceCallback<void(BrowserContext* browser_context,
+      base::OnceCallback<void(WebContents* web_contents,
                               int64_t registration_id)>;
 
   // Installs the payment app.

content/browser/payments/payment_app_provider_impl.cc

@@ -188,15 +188,14 @@ class RespondWithCallback : public PaymentHandlerResponseCallback {
     InvokePaymentAppCallbackRepository::GetInstance()->RemoveCallback(
         browser_context_);
     GetUIThreadTaskRunner({})->PostTask(
-        FROM_HERE,
-        base::BindOnce(&CloseClientWindowOnUIThread, browser_context_));
+        FROM_HERE, base::BindOnce(&CloseClientWindowOnUIThread));
   }
 
  private:
-  static void CloseClientWindowOnUIThread(BrowserContext* browser_context) {
+  static void CloseClientWindowOnUIThread() {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-    PaymentAppProvider::GetInstance()->CloseOpenedWindow(browser_context);
+    PaymentAppProvider::GetInstance()->CloseOpenedWindow();
   }
 
   int request_id_;
@@ -564,14 +563,14 @@ void OnInstallPaymentApp(
     PaymentRequestEventDataPtr event_data,
     PaymentAppProvider::RegistrationIdCallback registration_id_callback,
     PaymentAppProvider::InvokePaymentAppCallback callback,
-    BrowserContext* browser_context,
+    WebContents* web_contents,
     int64_t registration_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  if (registration_id >= 0 && browser_context != nullptr) {
+  if (registration_id >= 0 && web_contents != nullptr) {
     std::move(registration_id_callback).Run(registration_id);
     PaymentAppProvider::GetInstance()->InvokePaymentApp(
-        browser_context, registration_id, sw_origin, std::move(event_data),
+        web_contents, registration_id, sw_origin, std::move(event_data),
         std::move(callback));
   } else {
     std::move(callback).Run(CreateBlankPaymentHandlerResponse(
@@ -639,13 +638,15 @@ class PermissionChecker : public base::SupportsUserData::Data {
   base::WeakPtrFactory<PermissionChecker> weak_ptr_factory_{this};
 };
 
-void AbortInvokePaymentApp(BrowserContext* browser_context,
+void AbortInvokePaymentApp(WebContents* web_contents,
                            PaymentEventResponseType reason) {
   DCHECK_CURRENTLY_ON(ServiceWorkerContext::GetCoreThreadId());
+  if (!web_contents)
+    return;
 
   InvokeRespondWithCallback* callback =
       InvokePaymentAppCallbackRepository::GetInstance()->GetCallback(
-          browser_context);
+          web_contents->GetBrowserContext());
   if (callback)
     callback->AbortPaymentSinceOpennedWindowClosing(reason);
 }
@@ -808,15 +809,17 @@ void PaymentAppProviderImpl::GetAllPaymentApps(
 }
 
 void PaymentAppProviderImpl::InvokePaymentApp(
-    BrowserContext* browser_context,
+    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;
 
   scoped_refptr<DevToolsBackgroundServicesContextImpl> dev_tools =
-      GetDevTools(browser_context, sw_origin);
+      GetDevTools(web_contents->GetBrowserContext(), sw_origin);
   if (dev_tools) {
     std::map<std::string, std::string> data = {
         {"Merchant Top Origin", event_data->top_origin.spec()},
@@ -835,9 +838,10 @@ void PaymentAppProviderImpl::InvokePaymentApp(
   }
 
   StartServiceWorkerForDispatch(
-      browser_context, registration_id,
+      web_contents->GetBrowserContext(), registration_id,
       base::BindOnce(
-          &DispatchPaymentRequestEvent, browser_context, std::move(event_data),
+          &DispatchPaymentRequestEvent, web_contents->GetBrowserContext(),
+          std::move(event_data),
           base::BindOnce(&OnResponseForPaymentRequestOnUiThread, dev_tools,
                          registration_id, sw_origin,
                          event_data->payment_request_id, std::move(callback))));
@@ -856,6 +860,8 @@ void PaymentAppProviderImpl::InstallAndInvokePaymentApp(
     RegistrationIdCallback registration_id_callback,
     InvokePaymentAppCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (!web_contents)
+    return;
 
   if (!sw_js_url.is_valid() || !sw_scope.is_valid() || method.empty()) {
     GetUIThreadTaskRunner({})->PostTask(
@@ -886,16 +892,18 @@ void PaymentAppProviderImpl::InstallAndInvokePaymentApp(
 }
 
 void PaymentAppProviderImpl::CanMakePayment(
-    BrowserContext* browser_context,
+    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;
 
   scoped_refptr<DevToolsBackgroundServicesContextImpl> dev_tools =
-      GetDevTools(browser_context, sw_origin);
+      GetDevTools(web_contents->GetBrowserContext(), sw_origin);
   if (dev_tools) {
     std::map<std::string, std::string> data = {
         {"Merchant Top Origin", event_data->top_origin.spec()},
@@ -914,23 +922,25 @@ void PaymentAppProviderImpl::CanMakePayment(
   }
 
   StartServiceWorkerForDispatch(
-      browser_context, registration_id,
-      base::BindOnce(&DispatchCanMakePaymentEvent, browser_context,
-                     std::move(event_data),
+      web_contents->GetBrowserContext(), registration_id,
+      base::BindOnce(&DispatchCanMakePaymentEvent,
+                     web_contents->GetBrowserContext(), std::move(event_data),
                      base::BindOnce(&OnResponseForCanMakePaymentOnUiThread,
                                     dev_tools, registration_id, sw_origin,
                                     payment_request_id, std::move(callback))));
 }
 
-void PaymentAppProviderImpl::AbortPayment(BrowserContext* browser_context,
+void PaymentAppProviderImpl::AbortPayment(WebContents* web_contents,
                                           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;
 
   scoped_refptr<DevToolsBackgroundServicesContextImpl> dev_tools =
-      GetDevTools(browser_context, sw_origin);
+      GetDevTools(web_contents->GetBrowserContext(), sw_origin);
   if (dev_tools) {
     dev_tools->LogBackgroundServiceEvent(
         registration_id, sw_origin, DevToolsBackgroundService::kPaymentHandler,
@@ -939,8 +949,9 @@ void PaymentAppProviderImpl::AbortPayment(BrowserContext* browser_context,
   }
 
   StartServiceWorkerForDispatch(
-      browser_context, registration_id,
-      base::BindOnce(&DispatchAbortPaymentEvent, browser_context,
+      web_contents->GetBrowserContext(), registration_id,
+      base::BindOnce(&DispatchAbortPaymentEvent,
+                     web_contents->GetBrowserContext(),
                      base::BindOnce(&OnResponseForAbortPaymentOnUiThread,
                                     dev_tools, registration_id, sw_origin,
                                     payment_request_id, std::move(callback))));
@@ -948,34 +959,35 @@ void PaymentAppProviderImpl::AbortPayment(BrowserContext* browser_context,
 
 void PaymentAppProviderImpl::SetOpenedWindow(WebContents* web_contents) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (!web_contents)
+    return;
 
-  CloseOpenedWindow(web_contents->GetBrowserContext());
+  CloseOpenedWindow();
+  DCHECK(!payment_handler_window_);
 
-  payment_handler_windows_[web_contents->GetBrowserContext()] =
+  payment_handler_window_ =
       std::make_unique<PaymentHandlerWindowObserver>(web_contents);
 }
 
-void PaymentAppProviderImpl::CloseOpenedWindow(
-    BrowserContext* browser_context) {
+void PaymentAppProviderImpl::CloseOpenedWindow() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  auto it = payment_handler_windows_.find(browser_context);
-  if (it != payment_handler_windows_.end()) {
-    if (it->second->web_contents() != nullptr) {
-      it->second->web_contents()->Close();
-    }
-    payment_handler_windows_.erase(it);
+  if (payment_handler_window_ && payment_handler_window_->web_contents()) {
+    payment_handler_window_->web_contents()->Close();
+    payment_handler_window_.reset();
   }
 }
 
 void PaymentAppProviderImpl::OnClosingOpenedWindow(
-    BrowserContext* browser_context,
+    WebContents* web_contents,
     PaymentEventResponseType reason) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  if (!web_contents)
+    return;
 
   RunOrPostTaskOnThread(
       FROM_HERE, ServiceWorkerContext::GetCoreThreadId(),
-      base::BindOnce(&AbortInvokePaymentApp, browser_context, reason));
+      base::BindOnce(&AbortInvokePaymentApp, web_contents, reason));
 }
 
 bool PaymentAppProviderImpl::IsValidInstallablePaymentApp(

content/browser/payments/payment_app_provider_impl.h

@@ -25,7 +25,7 @@ class CONTENT_EXPORT PaymentAppProviderImpl : public PaymentAppProvider {
   // Should be accessed only on the UI thread.
   void GetAllPaymentApps(BrowserContext* browser_context,
                          GetAllPaymentAppsCallback callback) override;
-  void InvokePaymentApp(BrowserContext* browser_context,
+  void InvokePaymentApp(WebContents* web_contents,
                         int64_t registration_id,
                         const url::Origin& sw_origin,
                         payments::mojom::PaymentRequestEventDataPtr event_data,
@@ -42,21 +42,21 @@ class CONTENT_EXPORT PaymentAppProviderImpl : public PaymentAppProvider {
       const SupportedDelegations& supported_delegations,
       RegistrationIdCallback registration_id_callback,
       InvokePaymentAppCallback callback) override;
-  void CanMakePayment(BrowserContext* browser_context,
+  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) override;
-  void AbortPayment(BrowserContext* browser_context,
+  void AbortPayment(WebContents* web_contents,
                     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 CloseOpenedWindow(BrowserContext* browser_context) override;
+  void CloseOpenedWindow() override;
   void OnClosingOpenedWindow(
-      BrowserContext* browser_context,
+      WebContents* web_contents,
       payments::mojom::PaymentEventResponseType reason) override;
   bool IsValidInstallablePaymentApp(const GURL& manifest_url,
                                     const GURL& sw_js_url,
@@ -78,9 +78,7 @@ class CONTENT_EXPORT PaymentAppProviderImpl : public PaymentAppProvider {
     ~PaymentHandlerWindowObserver() override;
   };
 
-  // Map to maintain at most one opened window per browser context.
-  std::map<BrowserContext*, std::unique_ptr<PaymentHandlerWindowObserver>>
-      payment_handler_windows_;
+  std::unique_ptr<PaymentHandlerWindowObserver> payment_handler_window_;
 };
 
 }  // namespace content

content/browser/payments/payment_app_provider_impl_unittest.cc

@@ -12,8 +12,10 @@
 #include "content/browser/payments/payment_app_content_unittest_base.h"
 #include "content/browser/payments/payment_app_provider_impl.h"
 #include "content/public/browser/permission_type.h"
+#include "content/public/browser/web_contents.h"
 #include "content/public/test/mock_permission_manager.h"
 #include "content/public/test/test_browser_context.h"
+#include "content/public/test/test_web_contents_factory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/mojom/payments/payment_app.mojom.h"
@@ -75,6 +77,9 @@ class PaymentAppProviderTest : public PaymentAppContentUnitTestBase {
             testing::Return(blink::mojom::PermissionStatus::GRANTED));
     static_cast<TestBrowserContext*>(browser_context())
         ->SetPermissionControllerDelegate(std::move(mock_permission_manager));
+
+    web_contents_ =
+        test_web_contents_factory_.CreateWebContents(browser_context());
   }
   ~PaymentAppProviderTest() override {}
 
@@ -101,7 +106,7 @@ class PaymentAppProviderTest : public PaymentAppContentUnitTestBase {
                         payments::mojom::PaymentRequestEventDataPtr event_data,
                         PaymentAppProvider::InvokePaymentAppCallback callback) {
     PaymentAppProviderImpl::GetInstance()->InvokePaymentApp(
-        browser_context(), registration_id, sw_origin, std::move(event_data),
+        web_contents_, registration_id, sw_origin, std::move(event_data),
         std::move(callback));
     base::RunLoop().RunUntilIdle();
   }
@@ -112,7 +117,7 @@ class PaymentAppProviderTest : public PaymentAppContentUnitTestBase {
                       payments::mojom::CanMakePaymentEventDataPtr event_data,
                       PaymentAppProvider::CanMakePaymentCallback callback) {
     PaymentAppProviderImpl::GetInstance()->CanMakePayment(
-        browser_context(), registration_id, sw_origin, payment_request_id,
+        web_contents_, registration_id, sw_origin, payment_request_id,
         std::move(event_data), std::move(callback));
   }
 
@@ -121,18 +126,21 @@ class PaymentAppProviderTest : public PaymentAppContentUnitTestBase {
                     const std::string& payment_request_id,
                     PaymentAppProvider::AbortCallback callback) {
     PaymentAppProviderImpl::GetInstance()->AbortPayment(
-        browser_context(), registration_id, sw_origin, payment_request_id,
+        web_contents_, registration_id, sw_origin, payment_request_id,
         std::move(callback));
   }
 
   void OnClosingOpenedWindow() {
     PaymentAppProviderImpl::GetInstance()->OnClosingOpenedWindow(
-        browser_context(), payments::mojom::PaymentEventResponseType::
-                               PAYMENT_HANDLER_WINDOW_CLOSING);
+        web_contents_, payments::mojom::PaymentEventResponseType::
+                           PAYMENT_HANDLER_WINDOW_CLOSING);
     base::RunLoop().RunUntilIdle();
   }
 
  private:
+  TestWebContentsFactory test_web_contents_factory_;
+  WebContents* web_contents_;
+
   DISALLOW_COPY_AND_ASSIGN(PaymentAppProviderTest);
 };
 

content/public/browser/payment_app_provider.h

@@ -54,7 +54,7 @@ class CONTENT_EXPORT PaymentAppProvider {
   virtual void GetAllPaymentApps(BrowserContext* browser_context,
                                  GetAllPaymentAppsCallback callback) = 0;
   virtual void InvokePaymentApp(
-      BrowserContext* browser_context,
+      WebContents* web_contents,
       int64_t registration_id,
       const url::Origin& sw_origin,
       payments::mojom::PaymentRequestEventDataPtr event_data,
@@ -72,13 +72,13 @@ class CONTENT_EXPORT PaymentAppProvider {
       RegistrationIdCallback registration_id_callback,
       InvokePaymentAppCallback callback) = 0;
   virtual void CanMakePayment(
-      BrowserContext* browser_context,
+      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(BrowserContext* browser_context,
+  virtual void AbortPayment(WebContents* web_contents,
                             int64_t registration_id,
                             const url::Origin& sw_origin,
                             const std::string& payment_request_id,
@@ -89,12 +89,12 @@ class CONTENT_EXPORT PaymentAppProvider {
   // previously opened window in the same browser context will be closed after
   // calling this interface.
   virtual void SetOpenedWindow(WebContents* web_contents) = 0;
-  virtual void CloseOpenedWindow(BrowserContext* browser_context) = 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(
-      BrowserContext* browser_context,
+      WebContents* web_contents,
       payments::mojom::PaymentEventResponseType reason) = 0;
 
   // Check whether given |sw_js_url| from |manifest_url| is allowed to register