BASELINE: Update Chromium to 85.0.4183.14085-based

Change-Id: Iaa42f4680837c57725b1344f108c0196741f6057
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

7 files changed, 136 insertions, 68 deletions

diff --git a/chromium/content/browser/payments/payment_app_browsertest.cc b/chromium/content/browser/payments/payment_app_browsertest.cc
index 2cd88fe00be..e94d88d74ba 100644
--- a/chromium/content/browser/payments/payment_app_browsertest.cc
+++ b/chromium/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));
diff --git a/chromium/content/browser/payments/payment_app_context_impl.h b/chromium/content/browser/payments/payment_app_context_impl.h
index a8940a5e8ed..271cb1cac95 100644
--- a/chromium/content/browser/payments/payment_app_context_impl.h
+++ b/chromium/content/browser/payments/payment_app_context_impl.h
@@ -8,7 +8,7 @@
 #include <map>
 #include <memory>
 
-#include "base/logging.h"
+#include "base/check_op.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/atomic_flag.h"
diff --git a/chromium/content/browser/payments/payment_app_installer.cc b/chromium/content/browser/payments/payment_app_installer.cc
index 9bcfb5db963..bec80ca6b7b 100644
--- a/chromium/content/browser/payments/payment_app_installer.cc
+++ b/chromium/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);
     }
diff --git a/chromium/content/browser/payments/payment_app_installer.h b/chromium/content/browser/payments/payment_app_installer.h
index bdba077fcb5..9f6dbd092a5 100644
--- a/chromium/content/browser/payments/payment_app_installer.h
+++ b/chromium/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.
diff --git a/chromium/content/browser/payments/payment_app_provider_impl.cc b/chromium/content/browser/payments/payment_app_provider_impl.cc
index 991bbeb8de9..319867089c5 100644
--- a/chromium/content/browser/payments/payment_app_provider_impl.cc
+++ b/chromium/content/browser/payments/payment_app_provider_impl.cc
@@ -17,7 +17,6 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/supports_user_data.h"
-#include "base/task/post_task.h"
 #include "base/token.h"
 #include "components/payments/core/native_error_strings.h"
 #include "components/payments/core/payments_validators.h"
@@ -188,16 +187,15 @@ class RespondWithCallback : public PaymentHandlerResponseCallback {
 
     InvokePaymentAppCallbackRepository::GetInstance()->RemoveCallback(
         browser_context_);
-    base::PostTask(
-        FROM_HERE, {BrowserThread::UI},
-        base::BindOnce(&CloseClientWindowOnUIThread, browser_context_));
+    GetUIThreadTaskRunner({})->PostTask(
+        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_;
@@ -406,8 +404,8 @@ class AbortRespondWithCallback : public RespondWithCallback {
 void DidGetAllPaymentAppsOnCoreThread(
     PaymentAppProvider::GetAllPaymentAppsCallback callback,
     PaymentAppProvider::PaymentApps apps) {
-  base::PostTask(FROM_HERE, {BrowserThread::UI},
-                 base::BindOnce(std::move(callback), std::move(apps)));
+  GetUIThreadTaskRunner({})->PostTask(
+      FROM_HERE, base::BindOnce(std::move(callback), std::move(apps)));
 }
 
 void GetAllPaymentAppsOnCoreThread(
@@ -419,6 +417,31 @@ void GetAllPaymentAppsOnCoreThread(
       base::BindOnce(&DidGetAllPaymentAppsOnCoreThread, std::move(callback)));
 }
 
+void DidUpdatePaymentAppIconOnCoreThread(
+    PaymentAppProvider::UpdatePaymentAppIconCallback callback,
+    payments::mojom::PaymentHandlerStatus status) {
+  GetUIThreadTaskRunner({})->PostTask(
+      FROM_HERE, base::BindOnce(std::move(callback), status));
+}
+
+void UpdatePaymentAppIconOnCoreThread(
+    scoped_refptr<PaymentAppContextImpl> payment_app_context,
+    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,
+    PaymentAppProvider::UpdatePaymentAppIconCallback callback) {
+  DCHECK_CURRENTLY_ON(content::ServiceWorkerContext::GetCoreThreadId());
+  payment_app_context->payment_app_database()
+      ->SetPaymentAppInfoForRegisteredServiceWorker(
+          registration_id, instrument_key, name, string_encoded_icon,
+          method_name, supported_delegations,
+          base::BindOnce(&DidUpdatePaymentAppIconOnCoreThread,
+                         std::move(callback)));
+}
+
 void DispatchAbortPaymentEvent(
     BrowserContext* browser_context,
     PaymentAppProvider::AbortCallback callback,
@@ -427,8 +450,8 @@ void DispatchAbortPaymentEvent(
   DCHECK_CURRENTLY_ON(ServiceWorkerContext::GetCoreThreadId());
 
   if (service_worker_status != blink::ServiceWorkerStatusCode::kOk) {
-    base::PostTask(FROM_HERE, {BrowserThread::UI},
-                   base::BindOnce(std::move(callback), false));
+    GetUIThreadTaskRunner({})->PostTask(
+        FROM_HERE, base::BindOnce(std::move(callback), false));
     return;
   }
 
@@ -456,8 +479,8 @@ void DispatchCanMakePaymentEvent(
   DCHECK_CURRENTLY_ON(ServiceWorkerContext::GetCoreThreadId());
 
   if (service_worker_status != blink::ServiceWorkerStatusCode::kOk) {
-    base::PostTask(
-        FROM_HERE, {BrowserThread::UI},
+    GetUIThreadTaskRunner({})->PostTask(
+        FROM_HERE,
         base::BindOnce(std::move(callback),
                        CreateBlankCanMakePaymentResponse(
                            CanMakePaymentEventResponseType::BROWSER_ERROR)));
@@ -489,8 +512,8 @@ void DispatchPaymentRequestEvent(
   DCHECK_CURRENTLY_ON(ServiceWorkerContext::GetCoreThreadId());
 
   if (service_worker_status != blink::ServiceWorkerStatusCode::kOk) {
-    base::PostTask(
-        FROM_HERE, {BrowserThread::UI},
+    GetUIThreadTaskRunner({})->PostTask(
+        FROM_HERE,
         base::BindOnce(
             std::move(callback),
             CreateBlankPaymentHandlerResponse(
@@ -565,14 +588,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(
@@ -643,6 +666,8 @@ class PermissionChecker : public base::SupportsUserData::Data {
 void AbortInvokePaymentApp(BrowserContext* browser_context,
                            PaymentEventResponseType reason) {
   DCHECK_CURRENTLY_ON(ServiceWorkerContext::GetCoreThreadId());
+  if (!browser_context)
+    return;
 
   InvokeRespondWithCallback* callback =
       InvokePaymentAppCallbackRepository::GetInstance()->GetCallback(
@@ -809,15 +834,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()},
@@ -836,9 +863,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))));
@@ -857,10 +885,12 @@ 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()) {
-    base::PostTask(
-        FROM_HERE, {BrowserThread::UI},
+    GetUIThreadTaskRunner({})->PostTask(
+        FROM_HERE,
         base::BindOnce(
             std::move(callback),
             CreateBlankPaymentHandlerResponse(
@@ -886,17 +916,40 @@ void PaymentAppProviderImpl::InstallAndInvokePaymentApp(
                      std::move(callback)));
 }
 
-void PaymentAppProviderImpl::CanMakePayment(
+void PaymentAppProviderImpl::UpdatePaymentAppIcon(
     BrowserContext* browser_context,
     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,
+    PaymentAppProvider::UpdatePaymentAppIconCallback callback) {
+  StoragePartitionImpl* partition = static_cast<StoragePartitionImpl*>(
+      BrowserContext::GetDefaultStoragePartition(browser_context));
+  scoped_refptr<PaymentAppContextImpl> payment_app_context =
+      partition->GetPaymentAppContext();
+
+  RunOrPostTaskOnThread(
+      FROM_HERE, content::ServiceWorkerContext::GetCoreThreadId(),
+      base::BindOnce(&UpdatePaymentAppIconOnCoreThread, payment_app_context,
+                     registration_id, instrument_key, name, string_encoded_icon,
+                     method_name, supported_delegations, std::move(callback)));
+}
+
+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;
 
   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()},
@@ -915,23 +968,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,
@@ -940,8 +995,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))));
@@ -949,34 +1005,36 @@ 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->GetBrowserContext(),
+                     reason));
 }
 
 bool PaymentAppProviderImpl::IsValidInstallablePaymentApp(
diff --git a/chromium/content/browser/payments/payment_app_provider_impl.h b/chromium/content/browser/payments/payment_app_provider_impl.h
index 89afdb27186..11353c62dc5 100644
--- a/chromium/content/browser/payments/payment_app_provider_impl.h
+++ b/chromium/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,29 @@ class CONTENT_EXPORT PaymentAppProviderImpl : public PaymentAppProvider {
       const SupportedDelegations& supported_delegations,
       RegistrationIdCallback registration_id_callback,
       InvokePaymentAppCallback callback) override;
-  void CanMakePayment(BrowserContext* browser_context,
+  void UpdatePaymentAppIcon(BrowserContext* browser_context,
+                            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,
                       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 +86,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
diff --git a/chromium/content/browser/payments/payment_app_provider_impl_unittest.cc b/chromium/content/browser/payments/payment_app_provider_impl_unittest.cc
index d13d0d4cf65..806b090b277 100644
--- a/chromium/content/browser/payments/payment_app_provider_impl_unittest.cc
+++ b/chromium/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);
 };