chore: throw in utility net before app is ready

lib/utility/api/net.ts

@@ -1,11 +1,20 @@
+import { app } from 'electron/main';
 import { IncomingMessage } from 'electron/utility';
 import type { ClientRequestConstructorOptions } from 'electron/utility';
 import { ClientRequest } from '@electron/internal/common/api/net-client-request';
 import { fetchWithSession } from '@electron/internal/browser/api/net-fetch';
 
 const { isOnline, resolveHost } = process._linkedBinding('electron_common_net');
+const { _ensureNetworkServiceInitialized } = process._linkedBinding('electron_browser_utility_process');
+
+if (app.isReady()) {
+  _ensureNetworkServiceInitialized();
+}
 
 export function request (options: ClientRequestConstructorOptions | string, callback?: (message: IncomingMessage) => void) {
+  if (!app.isReady()) {
+    throw new Error('net module can only be used after app is ready');
+  }
   return new ClientRequest(options, callback);
 }
 

shell/browser/api/electron_api_utility_process.cc

@@ -194,22 +194,6 @@ UtilityProcessWrapper::UtilityProcessWrapper(
   connector_->set_connection_error_handler(base::BindOnce(
       &UtilityProcessWrapper::CloseConnectorPort, weak_factory_.GetWeakPtr()));
 
-  mojo::PendingRemote<network::mojom::URLLoaderFactory> url_loader_factory;
-  network::mojom::URLLoaderFactoryParamsPtr loader_params =
-      network::mojom::URLLoaderFactoryParams::New();
-  loader_params->process_id = pid_;
-  loader_params->is_orb_enabled = false;
-  loader_params->is_trusted = true;
-  network::mojom::NetworkContext* network_context =
-      g_browser_process->system_network_context_manager()->GetContext();
-  network_context->CreateURLLoaderFactory(
-      url_loader_factory.InitWithNewPipeAndPassReceiver(),
-      std::move(loader_params));
-  params->url_loader_factory = std::move(url_loader_factory);
-  mojo::PendingRemote<network::mojom::HostResolver> host_resolver;
-  network_context->CreateHostResolver(
-      {}, host_resolver.InitWithNewPipeAndPassReceiver());
-  params->host_resolver = std::move(host_resolver);
   node_service_remote_->Initialize(std::move(params));
 }
 
@@ -250,6 +234,30 @@ void UtilityProcessWrapper::CloseConnectorPort() {
   }
 }
 
+void UtilityProcessWrapper::EnsureNetworkServiceInitialized() {
+  if (network_context_initialized_)
+    return;
+
+  network_context_initialized_ = true;
+  mojo::PendingRemote<network::mojom::URLLoaderFactory> url_loader_factory;
+  network::mojom::URLLoaderFactoryParamsPtr loader_params =
+      network::mojom::URLLoaderFactoryParams::New();
+  loader_params->process_id = pid_;
+  loader_params->is_orb_enabled = false;
+  loader_params->is_trusted = true;
+  network::mojom::NetworkContext* network_context =
+      g_browser_process->system_network_context_manager()->GetContext();
+  network_context->CreateURLLoaderFactory(
+      url_loader_factory.InitWithNewPipeAndPassReceiver(),
+      std::move(loader_params));
+  mojo::PendingRemote<network::mojom::HostResolver> host_resolver;
+  network_context->CreateHostResolver(
+      {}, host_resolver.InitWithNewPipeAndPassReceiver());
+
+  node_service_remote_->InitializeNetworkService(std::move(url_loader_factory),
+                                                 std::move(host_resolver));
+}
+
 void UtilityProcessWrapper::Shutdown(int exit_code) {
   if (pid_ != base::kNullProcessId)
     GetAllUtilityProcessWrappers().Remove(pid_);
@@ -431,6 +439,9 @@ void Initialize(v8::Local<v8::Object> exports,
   v8::Isolate* isolate = context->GetIsolate();
   gin_helper::Dictionary dict(isolate, exports);
   dict.SetMethod("_fork", &electron::api::UtilityProcessWrapper::Create);
+  dict.SetMethod(
+      "_ensureNetworkServiceInitialized",
+      &electron::api::UtilityProcessWrapper::EnsureNetworkServiceInitialized);
 }
 
 }  // namespace

shell/browser/api/electron_api_utility_process.h

@@ -48,6 +48,7 @@ class UtilityProcessWrapper
   static raw_ptr<UtilityProcessWrapper> FromProcessId(base::ProcessId pid);
 
   void Shutdown(int exit_code);
+  void EnsureNetworkServiceInitialized();
 
   // gin::Wrappable
   static gin::WrapperInfo kWrapperInfo;
@@ -84,6 +85,7 @@ class UtilityProcessWrapper
   int stdout_read_fd_ = -1;
   int stderr_read_fd_ = -1;
   bool connector_closed_ = false;
+  bool network_context_initialized_ = false;
   std::unique_ptr<mojo::Connector> connector_;
   blink::MessagePortDescriptor host_port_;
   mojo::Remote<node::mojom::NodeService> node_service_remote_;

shell/browser/browser_process_impl.cc

@@ -93,7 +93,7 @@ BuildState* BrowserProcessImpl::GetBuildState() {
   return nullptr;
 }
 
-void BrowserProcessImpl::PreEarlyInitialization() {
+void BrowserProcessImpl::PostEarlyInitialization() {
   PrefServiceFactory prefs_factory;
   auto pref_registry = base::MakeRefCounted<PrefRegistrySimple>();
   PrefProxyConfigTrackerImpl::RegisterPrefs(pref_registry.get());

shell/browser/browser_process_impl.h

@@ -52,7 +52,7 @@ class BrowserProcessImpl : public BrowserProcess {
   static void ApplyProxyModeFromCommandLine(ValueMapPrefStore* pref_store);
 
   BuildState* GetBuildState() override;
-  void PreEarlyInitialization();
+  void PostEarlyInitialization();
   void PreCreateThreads();
   void PreMainMessageLoopRun();
   void PostDestroyThreads() {}

shell/browser/electron_browser_main_parts.cc

@@ -223,9 +223,6 @@ int ElectronBrowserMainParts::PreEarlyInitialization() {
   ui::ColorProviderManager::Get().AppendColorProviderInitializer(
       base::BindRepeating(AddChromeColorMixers));
 
-  // Initialize after user script environment creation.
-  fake_browser_process_->PreEarlyInitialization();
-
   return GetExitCode();
 }
 
@@ -279,6 +276,9 @@ void ElectronBrowserMainParts::PostEarlyInitialization() {
   // and/or user data directory.
   logging::InitElectronLogging(*base::CommandLine::ForCurrentProcess(),
                                /* is_preinit = */ false);
+
+  // Initialize after user script environment creation.
+  fake_browser_process_->PostEarlyInitialization();
 }
 
 int ElectronBrowserMainParts::PreCreateThreads() {

shell/browser/net/system_network_context_manager.cc

@@ -226,6 +226,7 @@ SystemNetworkContextManager* SystemNetworkContextManager::GetInstance() {
     // ElectronBrowserClient::OnNetworkServiceCreated(), which calls
     // CreateInstance() to initialize |g_system_network_context_manager|.
     content::GetNetworkService();
+    DCHECK(g_system_network_context_manager);
   }
 
   return g_system_network_context_manager;

shell/services/node/node_service.cc

@@ -68,16 +68,19 @@ NodeService::~NodeService() {
   }
 }
 
+void NodeService::InitializeNetworkService(
+    mojo::PendingRemote<network::mojom::URLLoaderFactory> url_loader_factory,
+    mojo::PendingRemote<network::mojom::HostResolver> host_resolver) {
+  URLLoaderBundle::GetInstance()->SetURLLoaderFactory(
+      std::move(url_loader_factory), mojo::Remote(std::move(host_resolver)));
+}
+
 void NodeService::Initialize(node::mojom::NodeServiceParamsPtr params) {
   if (NodeBindings::IsInitialized())
     return;
 
   ParentPort::GetInstance()->Initialize(std::move(params->port));
 
-  URLLoaderBundle::GetInstance()->SetURLLoaderFactory(
-      std::move(params->url_loader_factory),
-      mojo::Remote(std::move(params->host_resolver)));
-
   js_env_ = std::make_unique<JavascriptEnvironment>(node_bindings_->uv_loop());
 
   v8::HandleScope scope(js_env_->isolate());

shell/services/node/node_service.h

@@ -57,8 +57,11 @@ class NodeService : public node::mojom::NodeService {
   NodeService(const NodeService&) = delete;
   NodeService& operator=(const NodeService&) = delete;
 
-  // mojom::NodeService implementation:
+  // mojom::NodeService:
   void Initialize(node::mojom::NodeServiceParamsPtr params) override;
+  void InitializeNetworkService(
+      mojo::PendingRemote<network::mojom::URLLoaderFactory> url_loader_factory,
+      mojo::PendingRemote<network::mojom::HostResolver> host_resolver) override;
 
  private:
   // This needs to be initialized first so that it can be destroyed last

shell/services/node/public/mojom/node_service.mojom

@@ -15,11 +15,10 @@ struct NodeServiceParams {
   array<string> args;
   array<string> exec_args;
   blink.mojom.MessagePortDescriptor port;
-  pending_remote<network.mojom.URLLoaderFactory> url_loader_factory;
-  pending_remote<network.mojom.HostResolver> host_resolver;
 };
 
 [ServiceSandbox=sandbox.mojom.Sandbox.kNoSandbox]
 interface NodeService {
   Initialize(NodeServiceParams params);
+  InitializeNetworkService(pending_remote<network.mojom.URLLoaderFactory> url_loader_factory, pending_remote<network.mojom.HostResolver> host_resolver);
 };