chore: bump chromium to 106.0.5249.30 (21-x-y) (#35423)

2026-04-10 03:01:51 -04:00 · 2022-09-13 09:36:58 -07:00
parent f9b2608f2c
commit aaf560817b
102 changed files with 945 additions and 805 deletions
--- a/shell/browser/api/electron_api_web_contents.cc
+++ b/shell/browser/api/electron_api_web_contents.cc
@@ -1286,6 +1286,7 @@ void WebContents::UpdateExclusiveAccessExitBubbleContent(
    const GURL& url,
    ExclusiveAccessBubbleType bubble_type,
    ExclusiveAccessBubbleHideCallback bubble_first_hide_callback,
+    bool notify_download,
    bool force_update) {}

 void WebContents::OnExclusiveAccessUserInput() {}
--- a/shell/browser/api/electron_api_web_contents.h
+++ b/shell/browser/api/electron_api_web_contents.h
@@ -664,6 +664,7 @@ class WebContents : public ExclusiveAccessContext,
      const GURL& url,
      ExclusiveAccessBubbleType bubble_type,
      ExclusiveAccessBubbleHideCallback bubble_first_hide_callback,
+      bool notify_download,
      bool force_update) override;
  void OnExclusiveAccessUserInput() override;
  content::WebContents* GetActiveWebContents() override;
--- a/shell/browser/electron_browser_client.cc
+++ b/shell/browser/electron_browser_client.cc
@@ -1572,56 +1572,61 @@ void ElectronBrowserClient::
    if (render_frame_host.GetFrameTreeNodeId() ==
            contents->GetPrimaryMainFrame()->GetFrameTreeNodeId() ||
        (prefs && prefs->AllowsNodeIntegrationInSubFrames())) {
-      associated_registry.AddInterface(base::BindRepeating(
-          [](content::RenderFrameHost* render_frame_host,
-             mojo::PendingAssociatedReceiver<electron::mojom::ElectronApiIPC>
-                 receiver) {
-            ElectronApiIPCHandlerImpl::Create(render_frame_host,
-                                              std::move(receiver));
-          },
-          &render_frame_host));
+      associated_registry.AddInterface<mojom::ElectronApiIPC>(
+          base::BindRepeating(
+              [](content::RenderFrameHost* render_frame_host,
+                 mojo::PendingAssociatedReceiver<mojom::ElectronApiIPC>
+                     receiver) {
+                ElectronApiIPCHandlerImpl::Create(render_frame_host,
+                                                  std::move(receiver));
+              },
+              &render_frame_host));
    }
  }

-  associated_registry.AddInterface(base::BindRepeating(
-      [](content::RenderFrameHost* render_frame_host,
-         mojo::PendingAssociatedReceiver<
-             electron::mojom::ElectronWebContentsUtility> receiver) {
-        ElectronWebContentsUtilityHandlerImpl::Create(render_frame_host,
-                                                      std::move(receiver));
-      },
-      &render_frame_host));
+  associated_registry.AddInterface<mojom::ElectronWebContentsUtility>(
+      base::BindRepeating(
+          [](content::RenderFrameHost* render_frame_host,
+             mojo::PendingAssociatedReceiver<mojom::ElectronWebContentsUtility>
+                 receiver) {
+            ElectronWebContentsUtilityHandlerImpl::Create(render_frame_host,
+                                                          std::move(receiver));
+          },
+          &render_frame_host));

-  associated_registry.AddInterface(base::BindRepeating(
-      [](content::RenderFrameHost* render_frame_host,
-         mojo::PendingAssociatedReceiver<mojom::ElectronAutofillDriver>
-             receiver) {
-        AutofillDriverFactory::BindAutofillDriver(std::move(receiver),
-                                                  render_frame_host);
-      },
-      &render_frame_host));
+  associated_registry.AddInterface<mojom::ElectronAutofillDriver>(
+      base::BindRepeating(
+          [](content::RenderFrameHost* render_frame_host,
+             mojo::PendingAssociatedReceiver<mojom::ElectronAutofillDriver>
+                 receiver) {
+            AutofillDriverFactory::BindAutofillDriver(std::move(receiver),
+                                                      render_frame_host);
+          },
+          &render_frame_host));
 #if BUILDFLAG(ENABLE_PRINTING)
-  associated_registry.AddInterface(base::BindRepeating(
-      [](content::RenderFrameHost* render_frame_host,
-         mojo::PendingAssociatedReceiver<printing::mojom::PrintManagerHost>
-             receiver) {
-        PrintViewManagerElectron::BindPrintManagerHost(std::move(receiver),
-                                                       render_frame_host);
-      },
-      &render_frame_host));
+  associated_registry.AddInterface<printing::mojom::PrintManagerHost>(
+      base::BindRepeating(
+          [](content::RenderFrameHost* render_frame_host,
+             mojo::PendingAssociatedReceiver<printing::mojom::PrintManagerHost>
+                 receiver) {
+            PrintViewManagerElectron::BindPrintManagerHost(std::move(receiver),
+                                                           render_frame_host);
+          },
+          &render_frame_host));
 #endif
 #if BUILDFLAG(ENABLE_EXTENSIONS)
-  associated_registry.AddInterface(base::BindRepeating(
-      [](content::RenderFrameHost* render_frame_host,
-         mojo::PendingAssociatedReceiver<extensions::mojom::LocalFrameHost>
-             receiver) {
-        extensions::ExtensionWebContentsObserver::BindLocalFrameHost(
-            std::move(receiver), render_frame_host);
-      },
-      &render_frame_host));
+  associated_registry.AddInterface<extensions::mojom::LocalFrameHost>(
+      base::BindRepeating(
+          [](content::RenderFrameHost* render_frame_host,
+             mojo::PendingAssociatedReceiver<extensions::mojom::LocalFrameHost>
+                 receiver) {
+            extensions::ExtensionWebContentsObserver::BindLocalFrameHost(
+                std::move(receiver), render_frame_host);
+          },
+          &render_frame_host));
 #endif
 #if BUILDFLAG(ENABLE_PDF_VIEWER)
-  associated_registry.AddInterface(base::BindRepeating(
+  associated_registry.AddInterface<pdf::mojom::PdfService>(base::BindRepeating(
      [](content::RenderFrameHost* render_frame_host,
         mojo::PendingAssociatedReceiver<pdf::mojom::PdfService> receiver) {
        pdf::PDFWebContentsHelper::BindPdfService(std::move(receiver),
@@ -1697,9 +1702,10 @@ void ElectronBrowserClient::ExposeInterfacesToRenderer(
    blink::AssociatedInterfaceRegistry* associated_registry,
    content::RenderProcessHost* render_process_host) {
 #if BUILDFLAG(ENABLE_ELECTRON_EXTENSIONS)
-  associated_registry->AddInterface(base::BindRepeating(
-      &extensions::EventRouter::BindForRenderer, render_process_host->GetID()));
-  associated_registry->AddInterface(
+  associated_registry->AddInterface<extensions::mojom::EventRouter>(
+      base::BindRepeating(&extensions::EventRouter::BindForRenderer,
+                          render_process_host->GetID()));
+  associated_registry->AddInterface<extensions::mojom::GuestView>(
      base::BindRepeating(&extensions::ExtensionsGuestView::CreateForExtensions,
                          render_process_host->GetID()));
 #endif
--- a/shell/browser/electron_browser_context.cc
+++ b/shell/browser/electron_browser_context.cc
@@ -389,6 +389,13 @@ ElectronBrowserContext::GetStorageNotificationService() {
  return nullptr;
 }

+content::ReduceAcceptLanguageControllerDelegate*
+ElectronBrowserContext::GetReduceAcceptLanguageControllerDelegate() {
+  // Needs implementation
+  // Refs https://chromium-review.googlesource.com/c/chromium/src/+/3687391
+  return nullptr;
+}
+
 ResolveProxyHelper* ElectronBrowserContext::GetResolveProxyHelper() {
  if (!resolve_proxy_helper_) {
    resolve_proxy_helper_ = base::MakeRefCounted<ResolveProxyHelper>(this);
--- a/shell/browser/electron_browser_context.h
+++ b/shell/browser/electron_browser_context.h
@@ -118,6 +118,8 @@ class ElectronBrowserContext : public content::BrowserContext {
  content::ClientHintsControllerDelegate* GetClientHintsControllerDelegate()
      override;
  content::StorageNotificationService* GetStorageNotificationService() override;
+  content::ReduceAcceptLanguageControllerDelegate*
+  GetReduceAcceptLanguageControllerDelegate() override;

  CookieChangeNotifier* cookie_change_notifier() const {
    return cookie_change_notifier_.get();
--- a/shell/browser/electron_permission_manager.cc
+++ b/shell/browser/electron_permission_manager.cc
@@ -253,6 +253,16 @@ blink::mojom::PermissionStatus ElectronPermissionManager::GetPermissionStatus(
                 : blink::mojom::PermissionStatus::DENIED;
 }

+content::PermissionResult
+ElectronPermissionManager::GetPermissionResultForOriginWithoutContext(
+    blink::PermissionType permission,
+    const url::Origin& origin) {
+  blink::mojom::PermissionStatus status =
+      GetPermissionStatus(permission, origin.GetURL(), origin.GetURL());
+  return content::PermissionResult(
+      status, content::PermissionStatusSource::UNSPECIFIED);
+}
+
 ElectronPermissionManager::SubscriptionId
 ElectronPermissionManager::SubscribePermissionStatusChange(
    blink::PermissionType permission,
--- a/shell/browser/electron_permission_manager.h
+++ b/shell/browser/electron_permission_manager.h
@@ -73,6 +73,7 @@ class ElectronPermissionManager : public content::PermissionControllerDelegate {
                          const GURL& requesting_origin,
                          bool user_gesture,
                          StatusesCallback callback) override;
+
  void RequestPermissionsWithDetails(
      const std::vector<blink::PermissionType>& permissions,
      content::RenderFrameHost* render_frame_host,
@@ -80,10 +81,6 @@ class ElectronPermissionManager : public content::PermissionControllerDelegate {
      base::Value::Dict details,
      StatusesCallback callback);

-  blink::mojom::PermissionStatus GetPermissionStatusForCurrentDocument(
-      blink::PermissionType permission,
-      content::RenderFrameHost* render_frame_host) override;
-
  bool CheckPermissionWithDetails(blink::PermissionType permission,
                                  content::RenderFrameHost* render_frame_host,
                                  const GURL& requesting_origin,
@@ -124,6 +121,12 @@ class ElectronPermissionManager : public content::PermissionControllerDelegate {
      base::OnceCallback<
          void(const std::vector<blink::mojom::PermissionStatus>&)> callback)
      override;
+  content::PermissionResult GetPermissionResultForOriginWithoutContext(
+      blink::PermissionType permission,
+      const url::Origin& origin) override;
+  blink::mojom::PermissionStatus GetPermissionStatusForCurrentDocument(
+      blink::PermissionType permission,
+      content::RenderFrameHost* render_frame_host) override;
  blink::mojom::PermissionStatus GetPermissionStatusForWorker(
      blink::PermissionType permission,
      content::RenderProcessHost* render_process_host,
--- a/shell/browser/notifications/win/win32_desktop_notifications/desktop_notification_controller.cc
+++ b/shell/browser/notifications/win/win32_desktop_notifications/desktop_notification_controller.cc
@@ -246,7 +246,7 @@ void DesktopNotificationController::AnimateAll() {
        break;
      }

-      it = move(it2);
+      it = std::move(it2);
    }
  }

@@ -280,12 +280,12 @@ DesktopNotificationController::AddNotification(std::u16string caption,
                                               HBITMAP image) {
  auto data = std::make_shared<NotificationData>();
  data->controller = this;
-  data->caption = move(caption);
-  data->body_text = move(body_text);
+  data->caption = std::move(caption);
+  data->body_text = std::move(body_text);
  data->image = CopyBitmap(image);

  // Enqueue new notification
-  Notification ret{*queue_.insert(queue_.end(), move(data))};
+  Notification ret{*queue_.insert(queue_.end(), std::move(data))};
  CheckQueue();
  return ret;
 }
@@ -311,7 +311,7 @@ void DesktopNotificationController::CloseNotification(

 void DesktopNotificationController::CheckQueue() {
  while (instances_.size() < instances_.capacity() && !queue_.empty()) {
-    CreateToast(move(queue_.front()));
+    CreateToast(std::move(queue_.front()));
    queue_.pop_front();
  }
 }
@@ -409,8 +409,8 @@ void DesktopNotificationController::Notification::Set(std::u16string caption,
  if (data_->image)
    DeleteBitmap(data_->image);

-  data_->caption = move(caption);
-  data_->body_text = move(body_text);
+  data_->caption = std::move(caption);
+  data_->body_text = std::move(body_text);
  data_->image = CopyBitmap(image);

  auto* hwnd = data_->controller->GetToast(data_.get());
--- a/shell/browser/ui/devtools_ui.cc
+++ b/shell/browser/ui/devtools_ui.cc
@@ -31,8 +31,8 @@ std::string PathWithoutParams(const std::string& path) {
      .substr(1);
 }

-std::string GetMimeTypeForPath(const std::string& path) {
-  std::string filename = PathWithoutParams(path);
+std::string GetMimeTypeForUrl(const GURL& url) {
+  std::string filename = url.ExtractFileName();
  if (base::EndsWith(filename, ".html", base::CompareCase::INSENSITIVE_ASCII)) {
    return "text/html";
  } else if (base::EndsWith(filename, ".css",
@@ -95,8 +95,8 @@ class BundledDataSource : public content::URLDataSource {
    std::move(callback).Run(nullptr);
  }

-  std::string GetMimeType(const std::string& path) override {
-    return GetMimeTypeForPath(path);
+  std::string GetMimeType(const GURL& url) override {
+    return GetMimeTypeForUrl(url);
  }

  bool ShouldAddContentSecurityPolicy() override { return false; }
--- a/shell/browser/zoom_level_delegate.cc
+++ b/shell/browser/zoom_level_delegate.cc
@@ -6,12 +6,12 @@

 #include <functional>
 #include <memory>
+#include <utility>
 #include <vector>

 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/strings/string_number_conversions.h"
-#include "base/values.h"
 #include "components/prefs/json_pref_store.h"
 #include "components/prefs/pref_filter.h"
 #include "components/prefs/pref_registry_simple.h"
@@ -63,18 +63,11 @@ void ZoomLevelDelegate::SetDefaultZoomLevelPref(double level) {
 }

 double ZoomLevelDelegate::GetDefaultZoomLevelPref() const {
-  double default_zoom_level = 0.0;
-
-  const base::Value* default_zoom_level_dictionary =
-      pref_service_->GetDictionary(kPartitionDefaultZoomLevel);
+  const base::Value::Dict& default_zoom_level_dictionary =
+      pref_service_->GetValueDict(kPartitionDefaultZoomLevel);
  // If no default has been previously set, the default returned is the
  // value used to initialize default_zoom_level in this function.
-  absl::optional<double> maybe_default_zoom_level =
-      default_zoom_level_dictionary->FindDoubleKey(partition_key_);
-  if (maybe_default_zoom_level.has_value())
-    default_zoom_level = maybe_default_zoom_level.value();
-
-  return default_zoom_level;
+  return default_zoom_level_dictionary.FindDouble(partition_key_).value_or(0.0);
 }

 void ZoomLevelDelegate::OnZoomLevelChanged(
@@ -84,35 +77,33 @@ void ZoomLevelDelegate::OnZoomLevelChanged(

  double level = change.zoom_level;
  DictionaryPrefUpdate update(pref_service_, kPartitionPerHostZoomLevels);
-  base::Value* host_zoom_dictionaries = update.Get();
-  DCHECK(host_zoom_dictionaries);
+  base::Value* host_zoom_update = update.Get();
+  DCHECK(host_zoom_update);
+  base::Value::Dict& host_zoom_dictionaries = host_zoom_update->GetDict();

  bool modification_is_removal =
      blink::PageZoomValuesEqual(level, host_zoom_map_->GetDefaultZoomLevel());

-  base::Value* host_zoom_dictionary =
-      host_zoom_dictionaries->FindDictKey(partition_key_);
+  base::Value::Dict* host_zoom_dictionary =
+      host_zoom_dictionaries.FindDict(partition_key_);
  if (!host_zoom_dictionary) {
-    host_zoom_dictionaries->SetKey(partition_key_,
-                                   base::Value(base::Value::Type::DICTIONARY));
-    host_zoom_dictionary = host_zoom_dictionaries->FindDictKey(partition_key_);
+    base::Value::Dict dict;
+    host_zoom_dictionaries.Set(partition_key_, std::move(dict));
+    host_zoom_dictionary = host_zoom_dictionaries.FindDict(partition_key_);
  }

  if (modification_is_removal)
-    host_zoom_dictionary->RemoveKey(change.host);
+    host_zoom_dictionary->Remove(change.host);
  else
-    host_zoom_dictionary->SetKey(change.host, base::Value(level));
+    host_zoom_dictionary->Set(change.host, base::Value(level));
 }

 void ZoomLevelDelegate::ExtractPerHostZoomLevels(
-    const base::DictionaryValue* host_zoom_dictionary) {
+    const base::Value::Dict& host_zoom_dictionary) {
  std::vector<std::string> keys_to_remove;
-  std::unique_ptr<base::DictionaryValue> host_zoom_dictionary_copy =
-      host_zoom_dictionary->DeepCopyWithoutEmptyChildren();
-  for (base::DictionaryValue::Iterator i(*host_zoom_dictionary_copy);
-       !i.IsAtEnd(); i.Advance()) {
-    const std::string& host(i.key());
-    const absl::optional<double> zoom_level = i.value().GetIfDouble();
+  base::Value::Dict host_zoom_dictionary_copy = host_zoom_dictionary.Clone();
+  for (auto [host, value] : host_zoom_dictionary_copy) {
+    const absl::optional<double> zoom_level = value.GetIfDouble();

    // Filter out A) the empty host, B) zoom levels equal to the default; and
    // remember them, so that we can later erase them from Prefs.
@@ -120,14 +111,14 @@ void ZoomLevelDelegate::ExtractPerHostZoomLevels(
    // level was set to its current value. In either case, SetZoomLevelForHost
    // will ignore type B values, thus, to have consistency with HostZoomMap's
    // internal state, these values must also be removed from Prefs.
-    if (host.empty() || !zoom_level ||
-        blink::PageZoomValuesEqual(*zoom_level,
+    if (host.empty() || !zoom_level.has_value() ||
+        blink::PageZoomValuesEqual(zoom_level.value(),
                                   host_zoom_map_->GetDefaultZoomLevel())) {
      keys_to_remove.push_back(host);
      continue;
    }

-    host_zoom_map_->SetZoomLevelForHost(host, *zoom_level);
+    host_zoom_map_->SetZoomLevelForHost(host, zoom_level.value());
  }

  // Sanitize prefs to remove entries that match the default zoom level and/or
@@ -155,16 +146,15 @@ void ZoomLevelDelegate::InitHostZoomMap(content::HostZoomMap* host_zoom_map) {

  // Initialize the HostZoomMap with per-host zoom levels from the persisted
  // zoom-level preference values.
-  const base::Value* host_zoom_dictionaries =
-      pref_service_->GetDictionary(kPartitionPerHostZoomLevels);
-  const base::Value* host_zoom_dictionary =
-      host_zoom_dictionaries->FindDictKey(partition_key_);
+  const base::Value::Dict& host_zoom_dictionaries =
+      pref_service_->GetValueDict(kPartitionPerHostZoomLevels);
+  const base::Value::Dict* host_zoom_dictionary =
+      host_zoom_dictionaries.FindDict(partition_key_);
  if (host_zoom_dictionary) {
    // Since we're calling this before setting up zoom_subscription_ below we
    // don't need to worry that host_zoom_dictionary is indirectly affected
    // by calls to HostZoomMap::SExtractPerHostZoomLevelsetZoomLevelForHost().
-    ExtractPerHostZoomLevels(
-        &base::Value::AsDictionaryValue(*host_zoom_dictionary));
+    ExtractPerHostZoomLevels(*host_zoom_dictionary);
  }
  zoom_subscription_ =
      host_zoom_map_->AddZoomLevelChangedCallback(base::BindRepeating(
--- a/shell/browser/zoom_level_delegate.h
+++ b/shell/browser/zoom_level_delegate.h
@@ -7,12 +7,12 @@

 #include <string>

+#include "base/values.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/host_zoom_map.h"
 #include "content/public/browser/zoom_level_delegate.h"

 namespace base {
-class DictionaryValue;
 class FilePath;
 }  // namespace base

@@ -45,8 +45,7 @@ class ZoomLevelDelegate : public content::ZoomLevelDelegate {
  void InitHostZoomMap(content::HostZoomMap* host_zoom_map) override;

 private:
-  void ExtractPerHostZoomLevels(
-      const base::DictionaryValue* host_zoom_dictionary);
+  void ExtractPerHostZoomLevels(const base::Value::Dict& host_zoom_dictionary);

  // This is a callback function that receives notifications from HostZoomMap
  // when per-host zoom levels change. It is used to update the per-host
--- a/shell/common/extensions/electron_extensions_client.cc
+++ b/shell/common/extensions/electron_extensions_client.cc
@@ -67,6 +67,7 @@ base::LazyInstance<ElectronPermissionMessageProvider>::DestructorAtExit

 ElectronExtensionsClient::ElectronExtensionsClient()
    : webstore_base_url_(extension_urls::kChromeWebstoreBaseURL),
+      new_webstore_base_url_(extension_urls::kNewChromeWebstoreBaseURL),
      webstore_update_url_(extension_urls::kChromeWebstoreUpdateURL) {
  AddAPIProvider(std::make_unique<extensions::CoreExtensionsAPIProvider>());
  AddAPIProvider(std::make_unique<ElectronExtensionsAPIProvider>());
@@ -127,6 +128,10 @@ const GURL& ElectronExtensionsClient::GetWebstoreBaseURL() const {
  return webstore_base_url_;
 }

+const GURL& ElectronExtensionsClient::GetNewWebstoreBaseURL() const {
+  return new_webstore_base_url_;
+}
+
 const GURL& ElectronExtensionsClient::GetWebstoreUpdateURL() const {
  return webstore_update_url_;
 }
--- a/shell/common/extensions/electron_extensions_client.h
+++ b/shell/common/extensions/electron_extensions_client.h
@@ -52,11 +52,13 @@ class ElectronExtensionsClient : public extensions::ExtensionsClient {
  const GURL& GetWebstoreBaseURL() const override;
  const GURL& GetWebstoreUpdateURL() const override;
  bool IsBlocklistUpdateURL(const GURL& url) const override;
+  const GURL& GetNewWebstoreBaseURL() const override;

 private:
  ScriptingAllowlist scripting_allowlist_;

  const GURL webstore_base_url_;
+  const GURL new_webstore_base_url_;
  const GURL webstore_update_url_;
 };

--- a/shell/renderer/api/electron_api_web_frame.cc
+++ b/shell/renderer/api/electron_api_web_frame.cc
@@ -23,6 +23,7 @@
 #include "shell/common/gin_converters/blink_converter.h"
 #include "shell/common/gin_converters/callback_converter.h"
 #include "shell/common/gin_converters/file_path_converter.h"
+#include "shell/common/gin_converters/value_converter.h"
 #include "shell/common/gin_helper/dictionary.h"
 #include "shell/common/gin_helper/error_thrower.h"
 #include "shell/common/gin_helper/function_template_extensions.h"
@@ -56,27 +57,6 @@

 namespace gin {

-template <>
-struct Converter<blink::WebLocalFrame::ScriptExecutionType> {
-  static bool FromV8(v8::Isolate* isolate,
-                     v8::Local<v8::Value> val,
-                     blink::WebLocalFrame::ScriptExecutionType* out) {
-    std::string execution_type;
-    if (!ConvertFromV8(isolate, val, &execution_type))
-      return false;
-    if (execution_type == "asynchronous") {
-      *out = blink::WebLocalFrame::kAsynchronous;
-    } else if (execution_type == "asynchronousBlockingOnload") {
-      *out = blink::WebLocalFrame::kAsynchronousBlockingOnload;
-    } else if (execution_type == "synchronous") {
-      *out = blink::WebLocalFrame::kSynchronous;
-    } else {
-      return false;
-    }
-    return true;
-  }
-};
-
 template <>
 struct Converter<blink::WebCssOrigin> {
  static bool FromV8(v8::Isolate* isolate,
@@ -132,7 +112,7 @@ bool SpellCheckWord(content::RenderFrame* render_frame,

 #endif

-class ScriptExecutionCallback : public blink::WebScriptExecutionCallback {
+class ScriptExecutionCallback {
 public:
  // for compatibility with the older version of this, error is after result
  using CompletionCallback =
@@ -144,7 +124,7 @@ class ScriptExecutionCallback : public blink::WebScriptExecutionCallback {
      CompletionCallback callback)
      : promise_(std::move(promise)), callback_(std::move(callback)) {}

-  ~ScriptExecutionCallback() override = default;
+  ~ScriptExecutionCallback() = default;

  // disable copy
  ScriptExecutionCallback(const ScriptExecutionCallback&) = delete;
@@ -193,8 +173,7 @@ class ScriptExecutionCallback : public blink::WebScriptExecutionCallback {
    }
  }

-  void Completed(
-      const blink::WebVector<v8::Local<v8::Value>>& result) override {
+  void Completed(const blink::WebVector<v8::Local<v8::Value>>& result) {
    v8::Isolate* isolate = promise_.isolate();
    if (!result.empty()) {
      if (!result[0].IsEmpty()) {
@@ -660,13 +639,20 @@ class WebFrameRenderer : public gin::Wrappable<WebFrameRenderer>,
    ScriptExecutionCallback::CompletionCallback completion_callback;
    args->GetNext(&completion_callback);

+    auto* self = new ScriptExecutionCallback(std::move(promise),
+                                             std::move(completion_callback));
+
    render_frame->GetWebFrame()->RequestExecuteScript(
        blink::DOMWrapperWorld::kMainWorldId, base::make_span(&source, 1),
-        has_user_gesture, blink::WebLocalFrame::kSynchronous,
-        new ScriptExecutionCallback(std::move(promise),
-                                    std::move(completion_callback)),
+        has_user_gesture ? blink::mojom::UserActivationOption::kActivate
+                         : blink::mojom::UserActivationOption::kDoNotActivate,
+        blink::mojom::EvaluationTiming::kSynchronous,
+        blink::mojom::LoadEventBlockingOption::kDoNotBlock,
+        base::NullCallback(),
+        base::BindOnce(&ScriptExecutionCallback::Completed,
+                       base::Unretained(self)),
        blink::BackForwardCacheAware::kAllow,
-        blink::WebLocalFrame::PromiseBehavior::kDontWait);
+        blink::mojom::PromiseResultOption::kDoNotWait);

    return handle;
  }
@@ -692,9 +678,19 @@ class WebFrameRenderer : public gin::Wrappable<WebFrameRenderer>,
    bool has_user_gesture = false;
    args->GetNext(&has_user_gesture);

-    blink::WebLocalFrame::ScriptExecutionType scriptExecutionType =
-        blink::WebLocalFrame::kSynchronous;
-    args->GetNext(&scriptExecutionType);
+    blink::mojom::EvaluationTiming script_execution_type =
+        blink::mojom::EvaluationTiming::kSynchronous;
+    blink::mojom::LoadEventBlockingOption load_blocking_option =
+        blink::mojom::LoadEventBlockingOption::kDoNotBlock;
+    std::string execution_type;
+    args->GetNext(&execution_type);
+
+    if (execution_type == "asynchronous") {
+      script_execution_type = blink::mojom::EvaluationTiming::kAsynchronous;
+    } else if (execution_type == "asynchronousBlockingOnload") {
+      script_execution_type = blink::mojom::EvaluationTiming::kAsynchronous;
+      load_blocking_option = blink::mojom::LoadEventBlockingOption::kBlock;
+    }

    ScriptExecutionCallback::CompletionCallback completion_callback;
    args->GetNext(&completion_callback);
@@ -724,13 +720,19 @@ class WebFrameRenderer : public gin::Wrappable<WebFrameRenderer>,
                           blink::WebURL(GURL(url)));
    }

+    // Deletes itself.
+    auto* self = new ScriptExecutionCallback(std::move(promise),
+                                             std::move(completion_callback));
+
    render_frame->GetWebFrame()->RequestExecuteScript(
-        world_id, base::make_span(sources), has_user_gesture,
-        scriptExecutionType,
-        new ScriptExecutionCallback(std::move(promise),
-                                    std::move(completion_callback)),
+        world_id, base::make_span(sources),
+        has_user_gesture ? blink::mojom::UserActivationOption::kActivate
+                         : blink::mojom::UserActivationOption::kDoNotActivate,
+        script_execution_type, load_blocking_option, base::NullCallback(),
+        base::BindOnce(&ScriptExecutionCallback::Completed,
+                       base::Unretained(self)),
        blink::BackForwardCacheAware::kPossiblyDisallow,
-        blink::WebLocalFrame::PromiseBehavior::kDontWait);
+        blink::mojom::PromiseResultOption::kDoNotWait);

    return handle;
  }
--- a/shell/renderer/electron_api_service_impl.cc
+++ b/shell/renderer/electron_api_service_impl.cc
@@ -107,8 +107,8 @@ ElectronApiServiceImpl::ElectronApiServiceImpl(
    RendererClientBase* renderer_client)
    : content::RenderFrameObserver(render_frame),
      renderer_client_(renderer_client) {
-  registry_.AddInterface(base::BindRepeating(&ElectronApiServiceImpl::BindTo,
-                                             base::Unretained(this)));
+  registry_.AddInterface<mojom::ElectronRenderer>(base::BindRepeating(
+      &ElectronApiServiceImpl::BindTo, base::Unretained(this)));
 }

 void ElectronApiServiceImpl::BindTo(
--- a/shell/renderer/electron_autofill_agent.cc
+++ b/shell/renderer/electron_autofill_agent.cc
@@ -52,8 +52,8 @@ AutofillAgent::AutofillAgent(content::RenderFrame* frame,
                             blink::AssociatedInterfaceRegistry* registry)
    : content::RenderFrameObserver(frame) {
  render_frame()->GetWebFrame()->SetAutofillClient(this);
-  registry->AddInterface(base::BindRepeating(&AutofillAgent::BindReceiver,
-                                             base::Unretained(this)));
+  registry->AddInterface<mojom::ElectronAutofillAgent>(base::BindRepeating(
+      &AutofillAgent::BindReceiver, base::Unretained(this)));
 }

 AutofillAgent::~AutofillAgent() = default;
--- a/shell/renderer/renderer_client_base.cc
+++ b/shell/renderer/renderer_client_base.cc
@@ -322,10 +322,11 @@ void RendererClientBase::RenderFrameCreated(

  dispatcher->OnRenderFrameCreated(render_frame);

-  render_frame->GetAssociatedInterfaceRegistry()->AddInterface(
-      base::BindRepeating(
-          &extensions::MimeHandlerViewContainerManager::BindReceiver,
-          render_frame->GetRoutingID()));
+  render_frame->GetAssociatedInterfaceRegistry()
+      ->AddInterface<extensions::mojom::MimeHandlerViewContainerManager>(
+          base::BindRepeating(
+              &extensions::MimeHandlerViewContainerManager::BindReceiver,
+              render_frame->GetRoutingID()));
 #endif

 #if BUILDFLAG(ENABLE_BUILTIN_SPELLCHECKER)
@@ -635,7 +636,7 @@ void RendererClientBase::AllowGuestViewElementDefinition(

  render_frame->GetWebFrame()->RequestExecuteV8Function(
      context->GetCreationContextChecked(), register_cb, v8::Null(isolate), 0,
-      nullptr, nullptr);
+      nullptr, base::NullCallback());
 }

 }  // namespace electron