fix: build errors

filenames.gni

@@ -763,6 +763,8 @@ filenames = {
     "shell/browser/extensions/electron_extension_host_delegate.h",
     "shell/browser/extensions/electron_extension_loader.cc",
     "shell/browser/extensions/electron_extension_loader.h",
+    "shell/browser/extensions/electron_extension_registrar_delegate.cc",
+    "shell/browser/extensions/electron_extension_registrar_delegate.h",
     "shell/browser/extensions/electron_extension_system_factory.cc",
     "shell/browser/extensions/electron_extension_system_factory.h",
     "shell/browser/extensions/electron_extension_system.cc",

shell/browser/api/electron_api_session.cc

@@ -1310,7 +1310,8 @@ v8::Local<v8::Promise> Session::GetSharedDictionaryUsageInfo() {
 v8::Local<v8::Promise> Session::LoadExtension(
     const base::FilePath& extension_path,
     gin::Arguments* args) {
-  gin_helper::Promise<const extensions::ElectronExtensionInfo&> promise(isolate_);
+  gin_helper::Promise<const extensions::ElectronExtensionInfo&> promise(
+      isolate_);
   v8::Local<v8::Promise> handle = promise.GetHandle();
 
   if (!extension_path.IsAbsolute()) {
@@ -1336,9 +1337,11 @@ v8::Local<v8::Promise> Session::LoadExtension(
 
   auto* extension_system = static_cast<extensions::ElectronExtensionSystem*>(
       extensions::ExtensionSystem::Get(browser_context()));
-  extension_system->LoadExtension(extension_path, load_flags,
+  extension_system->LoadExtension(
+      extension_path, load_flags,
       base::BindOnce(
-          [](gin_helper::Promise<const extensions::Extension*> promise,
+          [](gin_helper::Promise<const extensions::ElectronExtensionInfo&>
+                 promise,
              base::WeakPtr<ElectronBrowserContext> browser_context,
              const extensions::Extension* extension,
              const std::string& error_msg) {
@@ -1346,8 +1349,9 @@ v8::Local<v8::Promise> Session::LoadExtension(
               if (!error_msg.empty())
                 util::EmitWarning(promise.isolate(), error_msg,
                                   "ExtensionLoadWarning");
-              auto& info = extensions::ElectronExtensionInfo(extension, browser_context.get());
-              promise.Resolve(info);
+              const auto& extension_info = extensions::ElectronExtensionInfo(
+                  extension, browser_context.get());
+              promise.Resolve(extension_info);
             } else {
               promise.RejectWithErrorMessage(error_msg);
             }
@@ -1358,21 +1362,15 @@ v8::Local<v8::Promise> Session::LoadExtension(
 }
 
 void Session::RemoveExtension(const std::string& extension_id) {
-  auto* extension_system = static_cast<extensions::ElectronExtensionSystem*>(
-      extensions::ExtensionSystem::Get(browser_context()));
-  extension_system->RemoveExtension(extension_id);
+  browser_context()->extension_system()->RemoveExtension(extension_id);
 }
 
 void Session::EnableExtension(const std::string& extension_id) {
-  auto* extension_system = static_cast<extensions::ElectronExtensionSystem*>(
-      extensions::ExtensionSystem::Get(browser_context()));
-  extension_system->EnableExtension(extension_id);
+  browser_context()->extension_system()->EnableExtension(extension_id);
 }
 
 void Session::DisableExtension(const std::string& extension_id) {
-  auto* extension_system = static_cast<extensions::ElectronExtensionSystem*>(
-      extensions::ExtensionSystem::Get(browser_context()));
-  extension_system->DisableExtension(extension_id);
+  browser_context()->extension_system()->DisableExtension(extension_id);
 }
 
 v8::Local<v8::Value> Session::GetExtension(const std::string& extension_id) {
@@ -1380,7 +1378,9 @@ v8::Local<v8::Value> Session::GetExtension(const std::string& extension_id) {
   const extensions::Extension* extension =
       registry->GetInstalledExtension(extension_id);
   if (extension) {
-    return gin::ConvertToV8(isolate_, extension);
+    const auto& extension_info =
+        extensions::ElectronExtensionInfo(extension, browser_context());
+    return gin::ConvertToV8(isolate_, extension_info);
   } else {
     return v8::Null(isolate_);
   }
@@ -1390,29 +1390,40 @@ v8::Local<v8::Value> Session::GetAllExtensions() {
   auto* registry = extensions::ExtensionRegistry::Get(browser_context());
   const extensions::ExtensionSet extensions =
       registry->GenerateInstalledExtensionsSet();
-  std::vector<const extensions::Extension*> extensions_vector;
+  std::vector<extensions::ElectronExtensionInfo> extensions_vector;
   for (const auto& extension : extensions) {
     if (extension->location() !=
-        extensions::mojom::ManifestLocation::kComponent)
-      extensions_vector.emplace_back(extension.get());
+        extensions::mojom::ManifestLocation::kComponent) {
+      const auto& extension_info =
+          extensions::ElectronExtensionInfo(extension.get(), browser_context());
+      extensions_vector.emplace_back(extension_info);
+    }
   }
   return gin::ConvertToV8(isolate_, extensions_vector);
 }
 
-void Session::OnExtensionLoaded(content::BrowserContext* browser_context,
-                                const extensions::Extension* extension) {
-  Emit("extension-loaded", extension);
+void Session::OnExtensionLoaded(
+    content::BrowserContext* content_browser_context,
+    const extensions::Extension* extension) {
+  const auto& extension_info =
+      extensions::ElectronExtensionInfo(extension, browser_context());
+  Emit("extension-loaded", extension_info);
 }
 
-void Session::OnExtensionUnloaded(content::BrowserContext* browser_context,
-                                  const extensions::Extension* extension,
-                                  extensions::UnloadedExtensionReason reason) {
-  Emit("extension-unloaded", extension);
+void Session::OnExtensionUnloaded(
+    content::BrowserContext* content_browser_context,
+    const extensions::Extension* extension,
+    extensions::UnloadedExtensionReason reason) {
+  const auto& extension_info =
+      extensions::ElectronExtensionInfo(extension, browser_context());
+  Emit("extension-unloaded", extension_info);
 }
 
-void Session::OnExtensionReady(content::BrowserContext* browser_context,
+void Session::OnExtensionReady(content::BrowserContext* content_browser_context,
                                const extensions::Extension* extension) {
-  Emit("extension-ready", extension);
+  const auto& extension_info =
+      extensions::ElectronExtensionInfo(extension, browser_context());
+  Emit("extension-ready", extension_info);
 }
 #endif
 

shell/browser/extensions/electron_extension_loader.cc

@@ -133,13 +133,4 @@ void ElectronExtensionLoader::FinishExtensionLoad(
   std::move(cb).Run(extension.get(), result.second);
 }
 
-void ElectronExtensionLoader::FinishExtensionReload(
-    const ExtensionId& old_extension_id,
-    std::pair<scoped_refptr<const Extension>, std::string> result) {
-  scoped_refptr<const Extension> extension = result.first;
-  if (extension) {
-    extension_system_->AddExtension(extension.get());
-  }
-}
-
 }  // namespace extensions

shell/browser/extensions/electron_extension_loader.h

@@ -45,12 +45,6 @@ class ElectronExtensionLoader {
                                              const std::string&)> cb);
 
  private:
-  // If the extension loaded successfully, enables it. If it's an app, launches
-  // it. If the load failed, updates ShellKeepAliveRequester.
-  void FinishExtensionReload(
-      const ExtensionId& old_extension_id,
-      std::pair<scoped_refptr<const Extension>, std::string> result);
-
   void FinishExtensionLoad(
       base::OnceCallback<void(const Extension*, const std::string&)> cb,
       std::pair<scoped_refptr<const Extension>, std::string> result);

shell/browser/extensions/electron_extension_registrar_delegate.cc

@@ -22,16 +22,16 @@
 #include "extensions/common/error_utils.h"
 #include "extensions/common/file_util.h"
 #include "extensions/common/manifest_constants.h"
+#include "shell/browser/extensions/electron_extension_system.h"
 
 namespace extensions {
 
 using LoadErrorBehavior = ExtensionRegistrar::LoadErrorBehavior;
 
-namespace {
-
 ElectronExtensionRegistrarDelegate::ElectronExtensionRegistrarDelegate(
-    content::BrowserContext* browser_context)
-    : browser_context_(browser_context) {}
+    content::BrowserContext* browser_context,
+    ElectronExtensionSystem* extension_system)
+    : browser_context_(browser_context), extension_system_(extension_system) {}
 
 ElectronExtensionRegistrarDelegate::~ElectronExtensionRegistrarDelegate() =
     default;
@@ -84,11 +84,18 @@ void ElectronExtensionRegistrarDelegate::LoadExtensionForReload(
   // when loading this extension and retain it here. As is, reloading an
   // extension will cause the file access permission to be dropped.
   int load_flags = Extension::FOLLOW_SYMLINKS_ANYWHERE;
-  GetExtensionFileTaskRunner()->PostTaskAndReplyWithResult(
-      FROM_HERE, base::BindOnce(&LoadUnpacked, path, load_flags),
+  extension_system_->LoadExtension(
+      path, load_flags,
       base::BindOnce(&ElectronExtensionRegistrarDelegate::FinishExtensionReload,
-                     weak_factory_.GetWeakPtr(), extension_id));
-  did_schedule_reload_ = true;
+                     weak_factory_.GetWeakPtr()));
+}
+
+void ElectronExtensionRegistrarDelegate::FinishExtensionReload(
+    const Extension* extension,
+    const ExtensionId& extension_id) {
+  if (extension) {
+    extension_system_->AddExtension(extension);
+  }
 }
 
 void ElectronExtensionRegistrarDelegate::ShowExtensionDisabledError(

shell/browser/extensions/electron_extension_registrar_delegate.h

@@ -25,12 +25,14 @@ class BrowserContext;
 namespace extensions {
 
 class Extension;
+class ElectronExtensionSystem;
 
 // Handles extension loading and reloading using ExtensionRegistrar.
 class ElectronExtensionRegistrarDelegate : public ExtensionRegistrar::Delegate {
  public:
   explicit ElectronExtensionRegistrarDelegate(
-      content::BrowserContext* browser_context);
+      content::BrowserContext* browser_context,
+      ElectronExtensionSystem* extension_system);
   ~ElectronExtensionRegistrarDelegate() override;
 
   // disable copy
@@ -67,7 +69,13 @@ class ElectronExtensionRegistrarDelegate : public ExtensionRegistrar::Delegate {
   bool CanDisableExtension(const Extension* extension) override;
   bool ShouldBlockExtension(const Extension* extension) override;
 
-  raw_ptr<content::BrowserContext> browser_context_;  // Not owned.
+  // If the extension loaded successfully, enables it. If it's an app, launches
+  // it. If the load failed, updates ShellKeepAliveRequester.
+  void FinishExtensionReload(const Extension* extension,
+                             const ExtensionId& extension_id);
+
+  raw_ptr<content::BrowserContext> browser_context_;   // Not owned.
+  raw_ptr<ElectronExtensionSystem> extension_system_;  // Not owned.
   raw_ptr<ExtensionRegistrar> extension_registrar_ = nullptr;
 
   base::WeakPtrFactory<ElectronExtensionRegistrarDelegate> weak_factory_{this};

shell/browser/extensions/electron_extension_system.cc

@@ -46,8 +46,8 @@ ElectronExtensionSystem::ElectronExtensionSystem(
     BrowserContext* browser_context)
     : browser_context_(browser_context),
       extension_registrar_delegate_(
-          std::make_unique<ElectronExtensionRegistrarDelegate>(
-              browser_context)),
+          std::make_unique<ElectronExtensionRegistrarDelegate>(browser_context,
+                                                               this)),
       extension_registrar_(browser_context,
                            extension_registrar_delegate_.get()),
       store_factory_(base::MakeRefCounted<value_store::ValueStoreFactoryImpl>(
@@ -93,15 +93,9 @@ void ElectronExtensionSystem::EnableExtension(const std::string& extension_id) {
 }
 
 void ElectronExtensionSystem::DisableExtension(
-    const ExtensionId& extension_id,
-    disable_reason::DisableReason disable_reason) {
-  DisableExtension(extension_id, DisableReasonSet({disable_reason}));
-}
-
-void ElectronExtensionSystem::DisableExtension(
-    const ExtensionId& extension_id,
-    const DisableReasonSet& disable_reasons) {
-  extension_registrar_.DisableExtension(extension_id, disable_reasons);
+    const ExtensionId& extension_id) {
+  extension_registrar_.DisableExtension(
+      extension_id, disable_reason::DisableReason::DISABLE_NONE);
 }
 
 void ElectronExtensionSystem::Shutdown() {
@@ -115,7 +109,7 @@ void ElectronExtensionSystem::InitForRegularProfile(bool extensions_enabled) {
   user_script_manager_ = std::make_unique<UserScriptManager>(browser_context_);
   app_sorting_ = std::make_unique<NullAppSorting>();
   extension_loader_ =
-      std::make_unique<ElectronExtensionLoader>(browser_context_);
+      std::make_unique<ElectronExtensionLoader>(browser_context_, this);
 
   if (!browser_context_->IsOffTheRecord())
     LoadComponentExtensions();
@@ -156,7 +150,7 @@ void ElectronExtensionSystem::LoadComponentExtensions() {
         extensions::Extension::Create(
             root_directory, extensions::mojom::ManifestLocation::kComponent,
             *pdf_manifest, extensions::Extension::REQUIRE_KEY, &utf8_error);
-    AddExtension(pdf_extension);
+    AddExtension(pdf_extension.get());
   }
 #endif
 }

shell/browser/extensions/electron_extension_system.h

@@ -69,11 +69,7 @@ class ElectronExtensionSystem : public ExtensionSystem {
   // Disables the extension. If the extension is already disabled, just adds
   // the incoming disable reason(s). If the extension cannot be disabled (due to
   // policy), does nothing.
-  void DisableExtension(const ExtensionId& extension_id,
-                        disable_reason::DisableReason disable_reason =
-                            disable_reason::DisableReason::DISABLE_NONE);
-  void DisableExtension(const ExtensionId& extension_id,
-                        const DisableReasonSet& disable_reasons);
+  void DisableExtension(const ExtensionId& extension_id);
 
   // KeyedService implementation:
   void Shutdown() override;
@@ -106,6 +102,10 @@ class ElectronExtensionSystem : public ExtensionSystem {
       const std::string& extension_id,
       const base::Value::Dict& attributes) override;
 
+  base::WeakPtr<ElectronExtensionSystem> GetWeakPtr() {
+    return weak_factory_.GetWeakPtr();
+  }
+
  private:
   void OnExtensionRegisteredWithRequestContexts(
       scoped_refptr<Extension> extension);

shell/common/gin_converters/extension_converter.cc

@@ -4,7 +4,6 @@
 
 #include "shell/common/gin_converters/extension_converter.h"
 
-
 #include "extensions/common/extension.h"
 #include "gin/dictionary.h"
 #include "shell/browser/extensions/electron_extension_info.h"
@@ -15,7 +14,7 @@
 namespace gin {
 
 // static
-v8::Local<v8::Value> Converter<const extensions::ElectronExtensionInfo*>::ToV8(
+v8::Local<v8::Value> Converter<extensions::ElectronExtensionInfo>::ToV8(
     v8::Isolate* isolate,
     const extensions::ElectronExtensionInfo& info) {
   auto dict = gin::Dictionary::CreateEmpty(isolate);

shell/common/gin_converters/extension_converter.h

@@ -14,9 +14,10 @@ struct ElectronExtensionInfo;
 namespace gin {
 
 template <>
-struct Converter<const extensions::ElectronExtensionInfo> {
-  static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
-                                   const extensions::ElectronExtensionInfo& val);
+struct Converter<extensions::ElectronExtensionInfo> {
+  static v8::Local<v8::Value> ToV8(
+      v8::Isolate* isolate,
+      const extensions::ElectronExtensionInfo& val);
 };
 
 }  // namespace gin