《Electron 45.2.3 内核解剖》第 16 章 Service Worker、Worker 与 utility process

3 阅读1小时+

《Electron 45.2.3 内核解剖》第 16 章 Service Worker、Worker 与 utility process:四种"没有 Blink"的进程

前三章讲的都是"有一个 frame"的世界:WebContents 持有 RenderFrameHost,RenderFrameHost 对应渲染进程里的 RenderFrame,上面挂 preload、contextBridge、ipcRenderer,下面挂 WebLocalFrame 和合成器。这条链路的所有设计前提是:有文档、有 viewport、有一棵要画的树。

但 Electron 里还有四种地方在跑用户代码,那里没有文档、没有 viewport、没有树:

  • new Worker('x.js') 创建的专用 worker;
  • audioWorklet.addModule()、CSS.paintWorklet.addModule() 这类 worklet;
  • navigator.serviceWorker.register('/sw.js') 注册的 service worker;
  • utilityProcess.fork('x.js') 拉起的工具进程。

前三种仍然是 Blink 的 ExecutionContext(WorkerGlobalScope 或 WorkletGlobalScope),第四种连 Blink 都没有——它是一个 Chromium 的 service process,里面只有 Node。它们共享同一个问题:没有 frame,那么"Electron 的那些东西"(Node、preload、ipcRenderer)该挂在哪?

答案是四种完全不同的挂法,对应四段几乎不相干的代码。这一章沿着四条路走一遍,你会发现 Electron 在这件事上没有统一抽象,只有四次各自为战的缝合;而每次缝合的位置,恰好暴露了 Chromium 那边对应的架构约束。

16.0 先把"没有 Blink"说准

"没有 Blink"不严谨。这四种环境里有三种跑的就是 Blink 的代码:WorkerGlobalScope、WorkletGlobalScope、ServiceWorkerGlobalScope 都是 blink::ExecutionContext 的子类,blink::WorkerThread 是 Blink 的线程封装,脚本编译、微任务队列、fetch、caches、IndexedDB 全部由 Blink 提供。

它们真正没有的是 frame。把 frame 拆开看,它提供四样东西:

  1. 一个 WebLocalFrame / WebView,即"这棵 DOM 树属于哪个视口";
  2. 一个 Document,即"这棵树";
  3. 一个 WebFrameWidget + ui::Compositor,即"这棵树怎么变成像素";
  4. 一个 content.mojom.Frame 关联通道,即"这个 frame 怎么和 browser 说话"。

worker 有 1 的一半(有 ExecutionContext 但没有 WebLocalFrame)、没有 2、没有 3、没有 4。service worker 更彻底:它连"哪个页面"都不知道,生命周期由 browser 的 ServiceWorkerContextWrapper 管理,可以在一万个标签页都关掉之后继续活着。utility process 四样全无。

执行环境所在进程所在线程Blink GlobalScopeDocumentNode 环境require('electron')IPC 出口
主 framerenderer主线程无(LocalDOMWindow)有可选有ipcRenderer
专用 workerrenderer(与页面同进程)WorkerThreadDedicatedWorkerGlobalScope无可选无无
workletrendererWorkletThreadHolder 池化线程AudioWorkletGlobalScope 等无可选无无
service worker独立 renderer 进程(无 WebContents)WorkerThreadServiceWorkerGlobalScope无无有(preload realm 内)ipcRenderer(内部实例)
utility processutility主线程(Node 的 loop 就是它)无无必有有process.parentPort

最值得注意的是两个"无":专用 worker 有 Node 但没有任何 Electron IPC,是纯 Node 孤岛;service worker 反过来,没有 Node 却有一套完整的 send/invoke——因为它在跑 preload 脚本,而 preload 跑在一个有 require 的影子 realm 里。两个"无"都不是遗漏,是被 Chromium 的架构逼出来的。

16.0.1 四个互不相同的决策点

一句话概括:"worker 里有没有 Node"、"SW 的 preload 跑在哪"、"utility 怎么收发消息"这三个问题,分别由三份不同的代码、在三个不同的进程里回答,彼此不知道对方的存在。

问题决策位置时机依据
worker 里要不要建 Nodeelectron_renderer_client.cc:241worker 脚本即将求值WorkerSettings::NodeIntegrationInWorker()
进程要不要 sandboxweb_contents_preferences.cc:93-97渲染进程启动前nodeIntegration || nodeIntegrationInWorker
用哪个 RendererClientelectron_main_delegate.cc:428进程初始化命令行有没有 --no-sandbox
SW 的 preload 注入到哪preload_realm_context.cc:262SW 脚本即将求值ElectronPreloadData() 有没有值
SW 的消息发给谁electron_api_ipc_dispatch.cc:551每条消息ServiceWorkerMain 还活着吗
utility 的消息发给谁parent_port.cc:101每条消息那条 MessagePortDescriptor

这里藏着一个连锁反应:nodeIntegrationInWorker: true 不只是"给 worker 开 Node",它还会把整个渲染进程从 sandbox 里拽出来。 看 web_contents_preferences.cc:86-98:

RendererProcessPreferences RendererProcessPreferences::From(
	const gin_helper::Dictionary& web_preferences) {
	RendererProcessPreferences prefs;
	bool sandbox;
	if (web_preferences.Get(options::kSandbox, &sandbox)) {
	prefs.sandboxed = sandbox;
	} else {
	bool node_integration = false, node_integration_in_worker = false;
	web_preferences.Get(options::kNodeIntegration, &node_integration);
	web_preferences.Get(options::kNodeIntegrationInWorker,
						&node_integration_in_worker);
	prefs.sandboxed = !(node_integration || node_integration_in_worker);
	}

只有显式给了 sandbox 才用它;否则"有 Node 就没 sandbox"。于是 { nodeIntegration: false, nodeIntegrationInWorker: true } 这个看起来很收敛的配置,实际效果是整个 renderer 带 --no-sandbox --no-zygote 启动(web_contents_preferences.cc:136-141):

	if (sandboxed || can_sandbox_frame) {
	command_line->AppendSwitch(switches::kEnableSandbox);
	} else if (!command_line->HasSwitch(switches::kEnableSandbox)) {
	command_line->AppendSwitch(sandbox::policy::switches::kNoSandbox);
	command_line->AppendSwitch(::switches::kNoZygote);
	}

而进程一旦带 --no-sandbox,CreateContentRendererClient() 就选另一个类(electron_main_delegate.cc:424-435):

	if (IsSandboxEnabled(command_line)) {
	renderer_client_ = std::make_unique<ElectronSandboxedRendererClient>();
	} else {
	renderer_client_ = std::make_unique<ElectronRendererClient>();
	}

IsSandboxEnabled() 的定义是(command_line_args.cc:57-60):

bool IsSandboxEnabled(base::CommandLine* command_line) {
	return command_line->HasSwitch(switches::kEnableSandbox) ||
		!command_line->HasSwitch(sandbox::policy::switches::kNoSandbox);
}

也就是说:没写 --no-sandbox 就算 sandbox 开。默认情况下 Electron 渲染进程用的是 ElectronSandboxedRendererClient;只有打开 nodeIntegration 或 nodeIntegrationInWorker,进程才被标上 --no-sandbox,从而切到 ElectronRendererClient。

这一步切换决定了三件事:专用 worker 里能不能建 Node(只有 ElectronRendererClient 重写了 worker 钩子);SW 的 preload 会不会被注入(只有 ElectronSandboxedRendererClient 重写了 SW 钩子);页面 preload 走哪套注入逻辑(isolated_bundle 还是 renderer_init)。

换句话说,第 12 章讲过的"两套 preload 实现",分界线并不在 webPreferences.sandbox 字段上,而在进程级命令行上;webPreferences.sandbox 只是影响命令行的输入之一。这个细节文档里几乎看不出来,却是理解本章所有分支的钥匙。

16.1 专用 worker:一个 Node 孤岛

16.1.1 谁来决定这个 worker 里有 Node

Blink 在每个 worker 脚本即将求值时回调 WorkerScriptReadyForEvaluationOnWorkerThread。Electron 的实现只有十来行(electron_renderer_client.cc:275-287):

void ElectronRendererClient::WorkerScriptReadyForEvaluationOnWorkerThread(
	v8::Local<v8::Context> context) {
	RendererClientBase::WorkerScriptReadyForEvaluationOnWorkerThread(context);
	auto* ec = blink::ExecutionContext::From(context);
	if (!WorkerHasNodeIntegration(ec))
	return;
	auto* current = WebWorkerObserver::GetCurrent();
	if (!current)
	current = WebWorkerObserver::Create(v8::Isolate::GetCurrent());
	current->WorkerScriptReadyForEvaluation(context);
}

判断集中在 WorkerHasNodeIntegration()(:241-271),四段各是一次排除:

electron_renderer_client.cc:248-255

	// We do not create a Node.js environment in service or shared workers
	// owing to an inability to customize sandbox policies in these workers
	// given that they're run out-of-process.
	if (ec->IsServiceWorkerGlobalScope() || ec->IsSharedWorkerGlobalScope() ||
	ec->IsMainThreadWorkletGlobalScope())
	return false;
	// Off-main-thread worklets ... do not derive from WorkerGlobalScope, so
	// check for them separately and read the flag from WorkletGlobalScope,
	// which copies it out of the same WorkerSettings as dedicated workers do.
	if (auto* wlgs = blink::DynamicTo<blink::WorkletGlobalScope>(ec))
	return wlgs->NodeIntegrationInWorker();
	auto* wgs = blink::DynamicTo<blink::WorkerGlobalScope>(ec);
	if (!wgs)
	return false;
	// Read the preference from the worker's settings, which were copied from
	// the initiating frame's WebPreferences at worker creation time.
	auto* worker_settings = wgs->GetWorkerSettings();
	return worker_settings && worker_settings->NodeIntegrationInWorker();

第一段,三种直接否决。 service worker 与 shared worker 被排除,理由是"无法定制它们的 sandbox 策略,因为它们跑在进程外"。Chromium 里专用 worker 与创建它的页面同进程同站点,sandbox 状态继承自页面;而 shared worker 与 service worker 由 browser 侧单独挑进程,进程可能被复用、可能被多个来源共享、可能在页面全关之后还活着。要在这样的进程里塞 Node,就得回答"这个进程的 --no-sandbox 是谁决定的、和哪个页面有关"——没有好答案,所以不做。这也正是文档那句 "not available in SharedWorkers or ServiceWorkers"(multithreading.md:26-27)的由来。

第二段单独处理 worklet。 worklet 有自己的专用线程但不继承自 WorkerGlobalScope,所以不能走第三段。NodeIntegrationInWorker() 定义在 WorkletGlobalScope 上,值来自 WorkerSettings——worklet 不是"另一套开关",读的是同一个 nodeIntegrationInWorker。

第三段是主路径。 从 wgs->GetWorkerSettings() 读而不是从进程级全局读:同一个进程里可能有多个 WebContents(nodeIntegrationInSubFrames 的 iframe、webview),webPreferences 可以不同,必须用"创建这个 worker 的那个 frame 的 settings"。

第四段兜底。 既不是 WorkerGlobalScope 也不是 worklet 的,一律 false。第一段里的 IsMainThreadWorkletGlobalScope() 理由不同:主线程 worklet 与页面共享 V8 context,Node 已经由 preload 建好,再建一次会炸。

16.1.2 WebWorkerObserver 的生命周期

决定建 Node 之后,干活的是 WebWorkerObserver::Create(v8::Isolate::GetCurrent())。这个类每线程一个,存在 base::ThreadLocalOwnedPointer 里(web_worker_observer.cc:24-25):

static base::NoDestructor<base::ThreadLocalOwnedPointer<WebWorkerObserver>>
	lazy_tls;

Create() 与 GetCurrent() 都很朴素(:46-57),Create() 不做"已存在则返回旧的"检查,调用方自己做 if (!current)。这个分工在 16.2 会变得重要:worklet 线程复用时,current 是故意保留的。

构造函数(:59-69)有三件事:

web_worker_observer.cc:59-66

WebWorkerObserver::WebWorkerObserver(v8::Isolate* isolate)
	: node_bindings_(
		NodeBindings::Create(NodeBindings::BrowserEnvironment::kWorker,
							nullptr)),
	electron_bindings_(
		std::make_unique<ElectronBindings>(node_bindings_->uv_loop())) {
	node_bindings_->SetUpIsolate(isolate);
	// SetUpIsolate registers Node's WebAssembly streaming callback, whose JS
	// side kNoBrowserGlobals never installs; put Blink's back.
	blink::WasmResponseExtensions::Initialize(isolate);
}
  1. NodeBindings::Create(kWorker, nullptr) —— 第二个参数是 uv_loop_t*,传 nullptr 意思是自建一个(node_bindings.cc:543-551 里 owned_loop_.emplace() + uv_loop_init)。所以每个 worker 线程有自己的 libuv 循环。这和 renderer 主线程不同,也和 utility process 不同(那里传的是 uv_default_loop())。
  2. SetUpIsolate(isolate) —— 进程级 Node 初始化,一个 isolate 上只能成功一次(allocator shim 只加载一次),这是 worklet 复用问题的根源。
  3. blink::WasmResponseExtensions::Initialize(isolate) —— 补回 Blink 的 WebAssembly 流式编译回调。SetUpIsolate 会注册 Node 的实现,而 Node 那套的 JS 侧依赖浏览器全局,在 kNoBrowserGlobals 下没装。

第三点是本章反复出现的主题的第一个实例:Node 与 Blink 在同一个 isolate 上共存时,同名全局必须有人仲裁,而仲裁结果往往是一句注释加一次手工回填。 16.2 会把这个主题推到极致。

16.1.3 第一次初始化:InitializeNewEnvironment

web_worker_observer.cc:73-86

void WebWorkerObserver::WorkerScriptReadyForEvaluation(
	v8::Local<v8::Context> worker_context) {
	active_context_count_++;
	if (environments_.empty()) {
	// First context on this thread - do full Node.js initialization.
	InitializeNewEnvironment(worker_context);
	} else {
	// Thread is being reused (AudioWorklet thread pooling). Share the
	// existing Node.js environment with the new context instead of
	// reinitializing, which would break existing contexts on this thread.
	ShareEnvironmentWithContext(worker_context);
	}
}

十二行,两个设计决定:计数器先行(先加后减,销毁时才能判断"是不是最后一个");分叉条件不是"是不是 worklet"而是"environments_ 空不空"(专用 worker 永不走到 else,所以这个分支天然只服务池化 worklet;Blink 若哪天开始复用专用 worker 线程,这段代码也不用改)。代价是分支语义不直观:读代码的人必须知道"environments_ 非空"等价于"这个线程被复用了"。

InitializeNewEnvironment(:88-126)二十来行,逐步都有讲究:

	v8::Context::Scope context_scope(worker_context);
	v8::Isolate* const isolate = v8::Isolate::GetCurrent();
	v8::MicrotasksScope microtasks_scope(
	worker_context, v8::MicrotasksScope::kDoNotRunMicrotasks);
	node_bindings_->PrepareEmbedThread();
	electron::util::InstallProcessCodeCache();
	v8::Maybe<bool> initialized = node::InitializeContext(worker_context);
	CHECK(!initialized.IsNothing() && initialized.FromJust());
	std::shared_ptr<node::Environment> env =
	node_bindings_->CreateEnvironment(isolate, worker_context, nullptr);
	// We do not want to crash Web Workers on unhandled rejections.
	env->options()->unhandled_rejections = "warn-with-error-code";
	electron_bindings_->BindTo(env->isolate(), env->process_object());
	node_bindings_->LoadEnvironment(env.get());
	node_bindings_->set_uv_env(env.get());
	node_bindings_->StartPolling();
	environments_.insert(std::move(env));
  • Context::Scope:后面所有操作都要求当前 context 是这个 worker 的。少了它,Node 的 bootstrap 会建到主线程 context 里去,症状是 worker 里 require 拿到页面的对象。
  • MicrotasksScope(kDoNotRunMicrotasks):worker context 用 kScoped 微任务策略(Blink 设的),V8 在这种策略下 DCHECK 要求每次 Function::Call 外面有 MicrotasksScope。选"不跑"是因为初始化期间不该跑用户微任务——LoadEnvironment 会执行 common/init,里面的 process.nextTick 包装若此时触发检查点,会进入一个没建完的环境。
  • PrepareEmbedThread():起 libuv 轮询线程。Electron 的事件循环是 base::MessageLoop,Node 的是 libuv,两者不在一个线程;EmbedThreadRunner 在独立线程里 uv_run 或阻塞在 PollEvents,有 I/O 时通过 uv_async 唤醒主线程。node_bindings.cc:1068-1076 的注释解释了为什么必须"每进程只有一个轮询线程":Windows 上 CreateIoCompletionPort 的并发上限绑在线程池上,多开一个会让上限翻倍,进而出现"某些 I/O 永不处理"(VS Code issue #142786 就是这么来的)。
  • InstallProcessCodeCache():把构建期生成的 Node 内置模块字节码装进本线程的 BuiltinLoader。主线程在 NodeBindings::Initialize 时已装过一次,但 worker 线程是新的线程、新的 loader,必须在 node::InitializeContext 之前再装,否则几十个内置模块要从源码重编。
  • CreateEnvironment(isolate, worker_context, nullptr):第三个参数 platform 传 nullptr。这个重载最终走到 :972 的五参数版,ElectronCommandLine::AsUtf8() 作为 Node 命令行参数——worker 的 process.execArgv 继承的是进程级命令行里被 IsAllowedOption 放行的调试开关。
  • unhandled_rejections = "warn-with-error-code":和 Node 24 默认一致,但显式设置是为了防止 Node 改默认值时 worker 行为跟着漂移。
  • BindTo:挂 Electron 扩展 API,全部就五项(electron_bindings.cc:70-80):takeHeapSnapshot、setFdLimit(POSIX)、activateUvLoop,加上 BindProcess 里的 crash/hang/getCreationTime/getHeapStatistics/getBlinkMemoryInfo/getSystemMemoryInfo/getSystemVersion/getCPUUsage。没有 parentPort,没有 ipcRenderer。
  • LoadEnvironment:执行 internal/electron/js2c/worker_init 这个 bundle(node_bindings.cc:1040-1050 的 CompileBundle + bundle->Call),也就是 lib/worker/init.ts:6-15。
  • set_uv_env + StartPolling:绑定 environment 并跑一次 loop,让 uv__io_poll 把事件注册上。
  • environments_.insert:存进 std::set<std::shared_ptr<node::Environment>>。shared_ptr 不能改成 unique_ptr,因为 CreateEnvironment 返回的 shared_ptr 带一个自定义 deleter(:951-967),负责清 embedder data、FreeEnvironment、FreeIsolateData。

16.1.4 worker_init 这个 bundle 做了什么

lib/worker/init.ts:6-13 只有 42 行,却决定了 worker 里"Electron 的世界"长什么样:

require('@electron/internal/common/init');
const { hasSwitch, getSwitchValue } = process._linkedBinding('electron_common_command_line');
const { makeRequireFunction } = require('internal/modules/helpers');
global.module = new Module('internal/electron/js2c/worker_init');
global.require = makeRequireFunction(global.module) as NodeRequire;
// NB. 'self' isn't defined in an AudioWorklet.
if (typeof self !== 'undefined' && self.location.protocol === 'file:') {
	const pathname = process.platform === 'win32' && self?.location.pathname[0] === '/'
	? self?.location.pathname.substr(1) : self?.location.pathname;
	global.__filename = path.normalize(decodeURIComponent(pathname));
	global.__dirname = path.dirname(global.__filename);
	global.module.filename = global.__filename;
	global.module.paths = Module._nodeModulePaths(global.__dirname);
} else {
	// For backwards compatibility we fake these two paths here
	global.__filename = path.join(process.resourcesPath, 'electron.asar', 'worker', 'init.js');
	global.__dirname = path.join(process.resourcesPath, 'electron.asar', 'worker');
	const appPath = hasSwitch('app-path') ? getSwitchValue('app-path') : null;
	if (appPath) global.module.paths = Module._nodeModulePaths(appPath);
}

第一段:common/init。 lib/common/init.ts(122 行)做三件事:把 process.nextTick/setImmediate/setTimeout/setInterval 包一层 activateUvLoop()(Electron 只在"有请求"时跑 uv loop,不主动激活的话回调会拖到下一次 I/O);在 Windows 上伪造一个永远 EOF 的 process.stdin;给 electron / electron/main / electron/renderer / electron/common / electron/utility 建假模块缓存条目,并改写 Module._resolveFilename。

第三件事有 process.type 分支(lib/common/init.ts:78-86),没有 worker 分支。所以 worker 里 require('electron') 走正常解析、找不到包、抛 MODULE_NOT_FOUND——不是"返回空对象",是根本没有这个东西。这与文档"Electron 的内置模块不能在多线程环境使用"一致:不是不能用,是没接进去。

第二段:手工造 global.module 和 global.require。 其他进程里这东西由 Node bootstrap 建(process.mainModule),worker 走了 kNoBrowserGlobals 又没有主模块,只能用 internal/modules/helpers 的 makeRequireFunction 造一个。new Module('internal/electron/js2c/worker_init') 传假 id 只是给 require 一个 parent,让相对路径有基准。

第三段:file: 协议时把 __filename 设成 worker 脚本路径。 注释说的是 "html file",但代码取的是 self.location.pathname,在 worker 里那是 worker 脚本自己的位置,不是页面。实际效果是 file:///app/renderer/worker.js 里 __filename = /app/renderer/worker.js、module.paths 从 /app/renderer 往上找 node_modules。注释与代码有出入,行为以代码为准——这是"注释会漂移,代码不会"的又一个例子。Windows 上那个判断去掉 /C:/... 的前导斜杠,decodeURIComponent 处理中文和空格。

第四段:非 file: 时伪造 electron.asar 里的路径。 注释直说 "For backwards compatibility"。为什么伪造而不是给 undefined?因为老代码会 path.join(__dirname, 'preload.js'),path.join(undefined, ...) 会抛,拼接一个不存在的路径只是得到不存在的路径。末尾的 --app-path 是给 Module._nodeModulePaths 用的:http://localhost:5173 这种场景下 __dirname 在 asar 里,往上找不到应用的 node_modules,所以用 browser 传下来的 app-path 当搜索根。

四段合起来,worker_init 的目标很清楚:让 worker 尽量像一个 Node 模块,只是没有 electron 模块。 它没有试图让 worker"像 renderer",也没有提供 IPC——因为 worker 里没有可用的通道。

16.1.5 worker 里为什么没有 ipcRenderer

ipcRenderer 的实现是 electron_api_ipc_renderer.cc:521-528,通过 NODE_LINKED_BINDING_CONTEXT_AWARE(electron_renderer_ipc, Initialize)(:533)注册,只在被 process._linkedBinding('electron_renderer_ipc') 显式加载时初始化。谁加载它?四条路:ipc-renderer.ts、common-init.ts:8、preload_environment.cc:46、preload_realm_context.cc:197——全部属于 renderer 或 service worker 那条线。worker bundle 里没有任何一处。

如果用户自己调呢?Initialize 是这样分叉的(:521-529):

void Initialize(v8::Local<v8::Object> exports,
				v8::Local<v8::Value> unused,
				v8::Local<v8::Context> context,
				void* priv) {
	if (IsWorkerThread())
	CreateEmitters<IPCServiceWorker>(context, exports);
	else
	CreateEmitters<IPCRenderFrame>(context, exports);
}

IsWorkerThread() 是 content::WorkerThread::GetCurrentId() != 0(:62-64),专用 worker 满足。于是走 IPCServiceWorker,而它的构造函数第一句就要 ServiceWorkerData:

explicit IPCServiceWorker(v8::Isolate* isolate) {
	DCHECK(IsWorkerThread());
	content::WorkerThread::AddObserver(this);
	observing_worker_thread_ = true;
	electron::ServiceWorkerData* service_worker_data =
	electron::preload_realm::GetServiceWorkerData(
		isolate->GetCurrentContext());
	DCHECK(service_worker_data);
	service_worker_data->proxy()->GetRemoteAssociatedInterface(
	electron_ipc_remote_.BindNewEndpointAndPassReceiver());
}

GetServiceWorkerData 从 context 的 embedder data 里取 PreloadRealmLifetimeController*(preload_realm_context.cc:256-260 → :76-87)。而专用 worker 的那个槽位存的是 node::IsolateData*(node_bindings.cc:861-870)。From() 只做 CHECK(controller) 非空检查,不做类型检查,于是把这个 IsolateData* 当 controller 用,读出来的 service_worker_data_ 是垃圾指针。

这不是漏洞(需要主动调用私有 binding,结果是崩溃而非越权),但它清楚说明:electron_renderer_ipc 的 worker 分支只服务 service worker,却被"是不是 worker 线程"这个过宽的条件保护着。 这是本章第一个"接缝没对齐"的例子,后面还有几个。

结论:专用 worker 里既没有 ipcRenderer,也没有 ipcMain,也没有 process.parentPort。要跟主进程通信只能靠 postMessage 让页面转达。这是一个真实的能力缺口。

16.2 池化线程:worklet 与环境共享

worklet 的特殊性来自一个 Blink 实现细节:AudioWorklet、PaintWorklet、AnimationWorklet、SharedStorageWorklet 的线程是被池化复用的。

web_worker_observer.cc:27-42 把这个事实写成判定函数:

// Returns true if `context` belongs to a worklet that runs on a thread
// pooled by Blink's WorkletThreadHolder, ... For these scopes the
// WebWorkerObserver and its NodeBindings must outlive the v8::Context so
// the next pooled context can reuse them — Node.js cannot be re-initialized
// on the same thread (the allocator shim only loads once).
bool IsPooledWorkletContext(v8::Local<v8::Context> context) {
	auto* ec = blink::ExecutionContext::From(context);
	if (!ec)
	return false;
	return ec->IsAudioWorkletGlobalScope() || ec->IsPaintWorkletGlobalScope() ||
		ec->IsAnimationWorkletGlobalScope() ||
		ec->IsSharedStorageWorkletGlobalScope();
}

四个 scope 一个不多一个不少,注释明确说"以 Blink 里 WorkletThreadHolder 的调用点为准"——上游加第五种 worklet,这里就得跟着改,没有编译期保护。

为什么池化?worklet 通常短命且数量多:一个页面可能同时跑十几个 AudioWorkletProcessor,每个都有自己的 scope,每个起一个线程的话线程创建销毁开销会超过音频处理本身。对 Blink 来说没问题,v8::Context 可以随便新建;对 Node 是灾难,因为 Node 无法在同一线程上初始化两次。

16.2.1 "不能初始化两次"卡在哪

三层原因:

一,SetUpIsolate 只能调一次。 它里面 node::InitializeOncePerProcess(node_bindings.cc:752-755)一个进程只允许成功一次。NodeBindings 用 g_is_initialized 做门禁(:646-648),复位靠 TearDownOncePerProcess,而后者只在 NodeBindings 析构时调用——worker 的 NodeBindings 是故意不在 context 销毁时析构的。

二,allocator shim 只加载一次。 Node 在 POSIX 上用 dlsym 拿原始 malloc 再替换实现,这个替换只能在"还没有任何分配发生"时做,做第二次会得到"用自己替换自己"的递归。

三,node::Environment 与线程绑定。 一个 environment 属于一个线程(持有 uv_loop_t、platform、isolate)。在同线程再建一个需要两个 environment 共享 loop 和 isolate——技术上 Node 支持(worker_threads 就是这么干的),但要走 node::NewIsolate 那条完整 worker 路径,Electron 走的是 embedder 路径,没有那套基础设施。

所以 Electron 的选择是:不重建,直接复用。

16.2.2 ShareEnvironmentWithContext 的五步手术

第二个及以后的 context 走到 ShareEnvironmentWithContext(:128-216)。88 行,目标只有一个:让新 context 看起来有 Node 环境,而所有对象都借用第一个 context 的。

void WebWorkerObserver::ShareEnvironmentWithContext(
	v8::Local<v8::Context> worker_context) {
	v8::Context::Scope context_scope(worker_context);
	v8::Isolate* const isolate = v8::Isolate::GetCurrent();
	v8::MicrotasksScope microtasks_scope(
	worker_context, v8::MicrotasksScope::kDoNotRunMicrotasks);
	DCHECK(!environments_.empty());
	node::Environment* env = environments_.begin()->get();
	v8::Maybe<bool> initialized = node::InitializeContext(worker_context);
	CHECK(!initialized.IsNothing() && initialized.FromJust());
	// Assign the existing Node.js environment to this new context so that
	// node::Environment::GetCurrent(context) returns the shared environment.
	env->AssignToContext(worker_context, env->principal_realm(),
					node::ContextInfo("electron_worker"));

前三步:进 scope、拿第一个 environment、node::InitializeContext(worker_context) 给新 context 建 Node 的 per-context 数据(AssignToContext 要求 context 已被 Node 初始化过)。

AssignToContext(context, principal_realm, context_info) 是核心,注意第二参数传的是 env->principal_realm()——新 context 共用第一个 context 的 realm。于是:

  • node::Environment::GetCurrent(new_context) 返回共享的 env(大多数 Node API 走这条,能通);
  • 但 env->principal_realm() 仍是第一个 context 的 realm,少数通过 realm 拿 context 的路径(某些 ESM 加载器代码)会拿到第一个 context。

这个不对称是共享方案的根基,也是它所有问题的来源。

16.2.3 手工搬运全局对象

AssignToContext 只解决"Node 知道这个 context 存在",没解决"这里有 process 和 require"。手工搬(:148-194):

	v8::Local<v8::Context> original_context = env->context();
	v8::Local<v8::Object> original_global = original_context->Global();
	v8::Local<v8::Object> new_global = worker_context->Global();
	// Script in the original context can redefine these globals with accessors
	// that throw, so read them defensively and fall back to the environment's
	// own process object / undefined rather than crashing the worker.
	v8::TryCatch try_catch(isolate);
	v8::Local<v8::Value> process_value;
	if (!original_global->Get(original_context, gin::StringToV8(isolate, "process"))
		.ToLocal(&process_value)) {
	process_value = env->process_object();
	}
	v8::Local<v8::Value> require_value;
	if (!original_global->Get(original_context, gin::StringToV8(isolate, "require"))
		.ToLocal(&require_value)) {
	require_value = v8::Undefined(isolate);
	}
	// Set up 'global' as an alias for globalThis. Node.js bootstrapping normally
	// does this during LoadEnvironment, but we skip full bootstrap for shared
	// contexts.
	new_global->Set(worker_context, gin::StringToV8(isolate, "global"), new_global).Check();
	new_global->Set(worker_context, gin::StringToV8(isolate, "process"), process_value).Check();
	new_global->Set(worker_context, gin::StringToV8(isolate, "require"), require_value).Check();
	// Copy Buffer from the original context if it exists.
	v8::Local<v8::Value> buffer_value;
	if (original_global->Get(original_context, gin::StringToV8(isolate, "Buffer"))
		.ToLocal(&buffer_value) && !buffer_value->IsUndefined()) {
	new_global->Set(worker_context, gin::StringToV8(isolate, "Buffer"), buffer_value).Check();
	}

四个细节:

TryCatch 是防御性的,不是装饰。 注释说第一个 context 的脚本可以用 accessor 重定义这些全局并抛异常——Object.defineProperty(globalThis, 'process', { get() { throw ... } }) 完全合法。不加 TryCatch,Get 失败而代码继续 ToLocalChecked() 会直接崩。加了之后失败走 fallback:process 退回 env->process_object(),require 退回 undefined(宁缺勿崩)。

这反映一个残酷现实:同线程的多个 worklet 共享一个全局环境,任何一个的 JS 都能污染其他所有。 Electron 能做的只是"不在污染下崩溃",做不到隔离。

global 必须手工设。 Node bootstrap 会在 LoadEnvironment 里把 global 设成 globalThis 的别名,共享 context 跳过了完整 bootstrap,所以要补。不补的后果是 worklet 里 global.Buffer 报 ReferenceError——很难查,因为 Buffer 本身存在。

Buffer 是"有就复制,没有就算"。 不无条件设,避免制造"'Buffer' in globalThis 为真但值是 undefined"的虚假存在。

全部 .Check()。 Set 返回 Maybe<bool>,context 被 detach 或全局被 freeze 时会失败。到这一步已无恢复手段,崩溃比静默半初始化更可诊断。

16.2.4 六个 Blink 全局的回填

	// Ensure the Blink implementations of fetch and friends are available in
	// the new pooled context. Node.js no longer touches these globals when
	// kNoBrowserGlobals is set, but some worklet global scopes do not expose
	// them at all; fall back to the original context's bindings in that case.
	for (const std::string_view key :
	{"fetch", "Response", "FormData", "Request", "Headers", "EventSource"}) {
	v8::MaybeLocal<v8::Value> blink_value =
		new_global->Get(worker_context, gin::StringToV8(isolate, key));
	if (!blink_value.IsEmpty() && !blink_value.ToLocalChecked()->IsUndefined())
	continue;
	v8::Local<v8::Value> orig_value;
	if (original_global->Get(original_context, gin::StringToV8(isolate, key))
			.ToLocal(&orig_value) && !orig_value->IsUndefined()) {
	new_global->Set(worker_context, gin::StringToV8(isolate, key), orig_value).Check();
	}
	}

逻辑是"缺什么补什么":新 context 自己有(Blink 给某些 worklet scope 装了 fetch)就不动,没有就从第一个 context 复制。

清单对应 Node 在 kNoBrowserGlobals 下不覆盖的那批全局:lib/internal/bootstrap/web/* 里这些名字在 noBrowserGlobals 为真时跳过安装,把位置留给宿主。宿主装了什么就是什么;而 AudioWorkletGlobalScope 这类压根没有网络 API,只能借。

EventSource 尤其有意思,它和 node_bindings.cc:677-686 是同一个故事的两半:

	// Node's setupEventsource() in lib/internal/process/pre_execution.js
	// deletes globalThis.EventSource when --experimental-eventsource is not
	// set, and unlike its sibling setup functions it does not check
	// noBrowserGlobals. Pass the flag so Blink's EventSource is left alone;
	// Node's own undici EventSource is never installed under
	// kNoBrowserGlobals so there is no conflict.
	if (browser_env_ == BrowserEnvironment::kRenderer ||
	browser_env_ == BrowserEnvironment::kWorker) {
	args.push_back("--experimental-eventsource");
	}

Node 的 setupEventsource() 有个疏漏:其他 setup 函数都检查 noBrowserGlobals,就它不检查,直接 delete globalThis.EventSource。于是 Electron 只能在命令行加 flag 让 Node 别删;加了之后 Node 会装自己的(基于 undici),但因为 kNoBrowserGlobals 那个安装也被跳过——结果是"flag 加了,东西没装,Blink 的保住了"。一个全局对象要经过"Node 别删 → Blink 提供 → 共享时手工借"三道手续才能在一个池化 worklet 里可用,这是本章最能说明"缝合"的例子。

16.2.5 拆除:全章最危险的一段

ContextWillDestroy(:218-327)110 行,注释里出现了 SEGV、deadlock、V8 DCHECK 三个词。

	node::Environment* env = node::Environment::GetCurrent(context);
	if (!env)
	return;
	const bool is_pooled_worklet = IsPooledWorkletContext(context);
	active_context_count_--;
	if (active_context_count_ == 0) {

第一句可能返回 nullptr,因为共享 context 被 UnassignFromContext 之后 GetCurrent 就查不到。这时直接 return,但 active_context_count_ 没减——如果某个 context 在销毁时已经 unassign,计数器永远到不了 0,整个线程的环境永远不拆。实际上这个分支只在"非 Node 的 worker context"触发(那种情况根本没加过计数),对称性成立,但它只靠调用约定维持,没有断言保护。

计数减一后,若是最后一个,七步拆除:

一,手工 emit exit(:229-274)。

	// Emit the "exit" event on the process object. We avoid using
	// gin_helper::EmitEvent here because it goes through
	// CallMethodWithArgs, which creates a node::CallbackScope ...
	// the CallbackScope destructor's InternalCallbackScope::Close()
	// tries to process ticks and microtask checkpoints, which can SEGV
	// because the worker context is being torn down by Blink.
		v8::MicrotasksScope microtasks_scope{
			isolate, ctx->GetMicrotaskQueue(),
			v8::MicrotasksScope::kDoNotRunMicrotasks};
		v8::TryCatch try_catch(isolate);
		emit_v.As<v8::Function>()->Call(ctx, env->process_object(), 1, args)
			.FromMaybe(v8::Local<v8::Value>());
		// ... cannot let an exception thrown by an 'exit' listener propagate
		// back into Blink (it would assert in V8::FromJustIsNothing ...)
		if (try_catch.HasCaught()) { /* LOG(ERROR) 记录后 */ try_catch.Reset(); }

三个独立的坑:不用 gin_helper::EmitEvent(它的 node::CallbackScope 析构会跑 tick 和微任务检查点,在 context 拆了一半时 SEGV);必须手工建 MicrotasksScope(kScoped 策略下 V8 DCHECK);必须 try_catch.Reset()(TryCatch 析构时若 HasCaught() 会重新抛,在将销毁的 environment 上重抛会让下次进入 V8 触发 FromJustIsNothing 断言)。三条互相独立,修好一条不会让另外两条消失——这种密度通常出现在"跨两个运行时销毁对方"的场景,因为销毁顺序没有唯一正确答案。

二,断 uv env(:276-277)。 set_uv_env(nullptr),保证后面 environments_.clear() 触发的 loop 运行不会再进这个将销毁的 context。

三,先停轮询线程(:279-286)。

	// Stop the embed thread before destroying environments. The embed
	// thread's PollEvents and FreeEnvironment's uv_run both compete for
	// completions on the same libuv event loop; on Windows (IOCP) this
	// race can deadlock.
	node_bindings_->StopPolling();

反过来会死锁:node::FreeEnvironment 会 uv_run 排干 handle,而 embed 线程同时在 PollEvents 等同一批 completion,IOCP 上一个 completion 只能被一个线程取走。

四,销毁 environment(:288-293)。

	util::ExplicitMicrotasksScope microtasks_scope(
		context->GetMicrotaskQueue());
	environments_.clear();

ExplicitMicrotasksScope 是 Electron 自己的 RAII(v8_util.h),给不涉及 Function::Call 的代码提供微任务作用域,避免 kScoped 下的 DCHECK 误报。

五,通知 ElectronBindings(:295-296)。 它维护 pending_next_ticks_ 里的 environment 指针,环境销毁后必须移除。

六,决定 observer 死活(:298-312)。

	if (!is_pooled_worklet) {
	lazy_tls->Set(nullptr);  // destroys *this; do not access members below
	return;
	}

lazy_tls->Set(nullptr) 析构 *this,之后不能碰任何成员——注释直接写 "do not access members below",因为这是 UB 而不是逻辑错误。这种"自杀式清理"在 Chromium 里通常被禁止(对象应在明确 owner 里销毁),这里是不得已:WebWorkerObserver 的所有者是 TLS,只有它能销毁自己。

七(else 分支),还有别的 context 活着(:313-326)。

	if (context != env->context()) {
	env->UnassignFromContext(context);
	}
	// If the destroyed context IS the primary context, we leave the env
	// assigned to it. The env's PrincipalRealm holds a Global<Context>
	// reference that keeps the V8 context alive even though Blink has
	// torn down its side.

主 context 不能 unassign,因为 env->context() 就是它,UvRunOnce 要进它的 scope。如果主 context 先销毁而其他还活着,env 会通过 PrincipalRealm 的 Global<Context> 把那个 v8::Context 强行留住——Blink 侧已拆、V8 侧还活。注释说这"安全",因为 UvRunOnce 只需要 V8 context scope。一个被 Blink 抛弃的 context 被 V8 强留,靠"只碰 V8 不碰 Blink"维持正确性——这已经不是设计,是妥协的极限。

整节的结论:Blink 为性能池化线程 → Node 不能同线程初始化两次 → 复用 environment 并手工搬全局 → 销毁顺序变成玄学 → 用一堆注释把踩过的坑标出来。复杂度几乎全部来自"两个运行时的生命周期假设不兼容",而它服务的场景(audioWorklet 里想用 fs)其实很小众。

16.3 service worker:一个没有 frame 的 renderer

service worker 是四种环境里唯一既有 preload 又有 IPC 的。它跨三个进程、五份代码:

[main]  session.serviceWorkers (ServiceWorkerContext)
		├─ ServiceWorkerMain  ← 按 (browser_context, partition, version) 索引
		│     └─ ipc : IpcMainImpl      ← serviceWorker.ipc.on/handle
		└─ ServiceWorkerMain.send() ──┐  mojom::ElectronRenderer::Message
										▼
[sw renderer]  ServiceWorkerData
				├─ proxy_ : WebServiceWorkerContextProxy   ← 关联接口宿主
				└─ receiver_ : mojom::ElectronRenderer
					│  preload_realm::GetPreloadRealmContext()
					▼
				preload realm (ShadowRealmGlobalScope)
				├─ process(手工构造)
				├─ electron 模块(filtered)
				└─ ipcRenderer ──┐  mojom::ElectronApiIPC
									▼
[browser]  ElectronApiSWIPCHandlerImpl  ← 每个 (process, version) 一个
			└─ ipc_dispatch::ServiceWorkerMessage → ServiceWorkerMain.ipc

图里有两条方向相反、用两个不同 mojom 接口的通道:SW → browser 走 mojom::ElectronApiIPC(Message/Invoke/MessageSync/ReceivePostMessage/MessageHost),browser → SW 走 mojom::ElectronRenderer。第 14 章这两个接口都出现过,但那里的宿主是 RenderFrame 与 ElectronApiServiceImpl,在 SW 这里两者都换成了"service worker 的 context proxy"。

16.3.1 SW 进程为什么一定是 sandboxed

SW 跑在一个独立的 renderer 进程里,这个进程没有 WebContents。看 electron_browser_client.cc:682-721 给渲染进程追加开关的逻辑:

	content::WebContents* web_contents =
		GetWebContentsFromProcessID(unsafe_process_id);
	if (web_contents) {
	auto* web_preferences = WebContentsPreferences::From(web_contents);
	if (web_preferences)
		web_preferences->AppendCommandLineSwitches(
			command_line, IsRendererSubFrame(unsafe_process_id));
	} else if (render_process_host && render_process_host->IsSpare()) {
	// Launched like a sandboxed window's renderer, which is the only kind
	// ShouldUseSpareRenderProcessHost() hands it to.
	command_line->AppendSwitch(switches::kEnableSandbox);
	}
	renderer_process_sandboxed_[unsafe_process_id] =
		!command_line->HasSwitch(sandbox::policy::switches::kNoSandbox);

一个 SW 进程:process_type 是 renderer,GetWebContentsFromProcessID 返回空(SW 不属于任何 WebContents),IsSpare() 也是假。于是两个分支都不进,一个 sandbox 开关都不加。

那它 sandboxed 不 sandboxed?取决于 IsSandboxEnabled() 那个默认:

  • 应用正常启动(无 --no-sandbox)→ 用 ElectronSandboxedRendererClient → SW 的 preload 有实现;
  • 应用带 --no-sandbox → 用 ElectronRendererClient → 它没有重写 SW 钩子,基类实现(renderer_client_base.cc:581-595)只转给 extensions → SW 的 preload 静默失效。

第二条值得写进 checklist:一个用 --no-sandbox 调试的应用,注册的 SW preload 不会执行,而且没有任何报错——ServiceWorkerData 不会被创建,ElectronPreloadData 到了渲染进程也没人读。这是"进程级开关影响功能级行为"的典型症状,和 16.0.1 那条连锁反应是同一机制。

顺带说明:这也是为什么 SW 里 contextIsolation 恒为 true。SW 的 preload 跑在 ShadowRealm 里,与 SW 的 global 天然隔离,不存在"关掉隔离"的选项。

16.3.2 渲染侧:ServiceWorkerData

Blink 在 SW 脚本求值前回调 WillEvaluateServiceWorkerOnWorkerThread,参数里有 WebServiceWorkerContextProxy*、v8::Context、version id、scope、script url、token。实现只有二十来行(electron_sandboxed_renderer_client.cc:181-204):

	// The browser attaches preload data only when the session has service
	// worker preload scripts registered (GetServiceWorkerStartupData).
	if (context_proxy->ElectronPreloadData().has_value()) {
	if (!service_worker_data) {
	service_worker_data = new ServiceWorkerData{
		context_proxy, service_worker_version_id, v8_isolate, v8_context};
	}
	preload_realm::OnCreatePreloadableV8Context(v8_isolate, v8_context,
												service_worker_data);
	}

ElectronPreloadData() 是判据。 这个值由 browser 侧塞进 EmbeddedWorkerStartParams,marshal 到 worker 线程。没有它说明这个 session 没注册 SW preload,整条链不用建。

service_worker_data 是 thread_local 裸指针(:34):

constinit thread_local ServiceWorkerData* service_worker_data = nullptr;

thread_local 而非成员,因为 ElectronSandboxedRendererClient 是进程级单例,一个进程里可能跑多个 SW 线程。裸指针而非 unique_ptr,因为生命周期由 Blink 的回调对(WillEvaluate... / WillDestroy...)管理,new/delete 显式配对最简单。

if (!service_worker_data) 说明"一个线程只有一个 SW"。 这个假设在销毁时被 DCHECK_EQ 验证(:206-223):

	if (service_worker_data) {
	DCHECK_EQ(service_worker_version_id,
			service_worker_data->service_worker_version_id());
	delete service_worker_data;
	service_worker_data = nullptr;
	}

如果 Blink 哪天开始在同线程复用 SW context(像 worklet 那样),这个 DCHECK 会立刻炸,if (!service_worker_data) 也会让第二个 SW 用上第一个的 context_proxy。这和 16.2 的池化问题同类,只是一个已发生、一个还没有。

ServiceWorkerData 只有 74 行,核心是构造函数注册关联接口(service_worker_data.cc:18-36):

ServiceWorkerData::ServiceWorkerData(blink::WebServiceWorkerContextProxy* proxy,
									int64_t service_worker_version_id,
									v8::Isolate* const isolate,
									const v8::Local<v8::Context>& v8_context)
	: proxy_{proxy},
	service_worker_version_id_{service_worker_version_id},
	isolate_{isolate},
	v8_context_(isolate_, v8_context) {
	proxy_->GetAssociatedInterfaceRegistry()
	.AddInterface<mojom::ElectronRenderer>(
		base::BindRepeating(&ServiceWorkerData::OnElectronRendererRequest,
							weak_ptr_factory_.GetWeakPtr()));
}

proxy_->GetAssociatedInterfaceRegistry() 是 Blink 给 SW 的关联接口宿主,对应 browser 侧 ServiceWorkerVersionBaseInfo。frame 那边用的是 RenderFrame::GetAssociatedInterfaceRegistry()——形态相同,宿主不同。这个模式在本章会出现三次(frame、SW、utility)。

v8_context_ 存的是 SW 自己的 context,不是 preload realm 的。收消息时要靠它查 realm(:38-61):

service_worker_data.cc:44-51

	v8::Local<v8::Context> context = v8_context_.Get(isolate_);
	v8::MaybeLocal<v8::Context> maybe_preload_context =
	preload_realm::GetPreloadRealmContext(context);
	if (maybe_preload_context.IsEmpty()) {
	return;
	}
	v8::Local<v8::Context> preload_context = maybe_preload_context.ToLocalChecked();
	v8::Context::Scope context_scope(preload_context);
	v8::Local<v8::Value> args = gin::ConvertToV8(isolate, arguments);
	ipc_native::EmitIPCEvent(isolate, preload_context, internal, channel, {}, args);

realm 没建起来(没有 preload 脚本)时直接 return,消息静默丢弃。 这就是为什么 ServiceWorkerData 只在有 ElectronPreloadData 时创建——没 preload 就没 realm,没 realm 就没人接消息。

另外两个方法 ReceivePostMessage 和 TakeHeapSnapshot 都是 NOTIMPLEMENTED()(:63-72)。前者意味着 ServiceWorkerMain.ipc.postMessage 这条路径对 SW 没实现(browser 侧写了,渲染侧断了);后者意味着 takeHeapSnapshot 对 SW 不可用。这两个标注说明 SW 链路的功能面只有 frame 的三分之一。

16.3.3 preload realm:给 service worker 造一个 ShadowRealm

这是本章技术含量最高的一段(316 行的 preload_realm_context.cc:272-279)。要解决的问题一句话:service worker 没有 require、没有 process,也不该有;但 preload 需要它们;那么 preload 放哪跑?

三个显而易见的选项都不行:直接跑在 SW 的 global 上,process/require/Buffer 会全部泄漏给网页可控的 sw.js;跑在 isolated world 里,isolated world 是 frame 的概念,SW 没有 frame;跑在 node::Environment 的新 context 里,那是 worklet 那一套,但 SW 里根本没有 Node 环境。

Electron 选了第四条:造一个 ShadowRealmGlobalScope,在它上面建新 v8::Context,把 preload 跑在里面。 这个 realm 与 SW 的 global 共享同一个 isolate、线程、微任务队列,但全局对象完全独立。

OnCreatePreloadableV8Context(:262-314)分六步:

	blink::DOMWrapperWorld* world = blink::DOMWrapperWorld::Create(
	isolate, blink::DOMWrapperWorld::WorldType::kShadowRealm);
	CHECK(world);  // Not yet run out of the world id.
	blink::ShadowRealmGlobalScope* shadow_realm_global_scope =
	blink::MakeGarbageCollected<blink::ShadowRealmGlobalScope>(
		initiator_execution_context);
	const blink::WrapperTypeInfo* wrapper_type_info =
	shadow_realm_global_scope->GetWrapperTypeInfo();
	v8::Local<v8::ObjectTemplate> global_template =
	wrapper_type_info->GetV8ClassTemplate(isolate, *world)
		.As<v8::FunctionTemplate>()
		->InstanceTemplate();
	v8::Local<v8::Object> global_proxy;  // Will request a new global proxy.
	v8::Local<v8::Context> context =
	v8::Context::New(isolate, nullptr, global_template, global_proxy,
					v8::DeserializeInternalFieldsCallback(),
					initiator_execution_context->GetMicrotaskQueue());
	context->UseDefaultSecurityToken();
	blink::ScriptState* script_state =
	blink::MakeGarbageCollected<blink::ScriptStateImpl>(
		context, world, *shadow_realm_global_scope);
	global_proxy = context->Global();
	blink::V8DOMWrapper::SetNativeInfoForGlobal(isolate, global_proxy,
											shadow_realm_global_scope);
	std::ignore =
	script_state->PerContextData()->ConstructorForType(wrapper_type_info);
	blink::MakeGarbageCollected<PreloadRealmLifetimeController>(
	initiator_execution_context, initiator_script_state,
	shadow_realm_global_scope, script_state, service_worker_data);

DOMWrapperWorld:WorldType::kShadowRealm 是 Blink 为 ShadowRealm 保留的类型。world 的作用是给 V8 对象模板做缓存分区,同一 Blink 类在不同 world 有不同 FunctionTemplate,prototype 才能按 world 隔离。CHECK(world) 的注释 "Not yet run out of the world id" 指 world id 有限,反复创建不释放会耗尽。

ShadowRealmGlobalScope:Blink 的 ExecutionContext 子类,oilpan 管理,构造时接收 initiator,从而继承 origin、CSP、设置。

v8::Context::New 的五个参数:global_template 来自 GetV8ClassTemplate(isolate, *world)->InstanceTemplate(),保证全局对象有正确的原型链;global_proxy 传空让 V8 自己造;第四参数是空的 DeserializeInternalFieldsCallback;最后一个参数是 initiator_execution_context->GetMicrotaskQueue()——新旧 context 共享微任务队列,于是 preload 里的 await 和 SW 脚本的微任务排在同一队列,顺序一致。不共享的话,sw.js 里 await fetch() 之后和 preload 里 await 之后的代码可能以任意顺序执行。

UseDefaultSecurityToken():V8 的 security token 决定两个 context 能否互相访问对象。默认 token 意味着"和同 isolate 里其他默认 token 的 context 互通",这正是要的——preload 要能拿到 SW 传过来的对象(比如 event.request),SW 也要能拿到 preload 通过 contextBridge 暴露的对象。

ScriptStateImpl + SetNativeInfoForGlobal:把 Blink 对象与 V8 全局对象双向绑定,是 Blink 的标准套路。

ConstructorForType:装 context 相关属性,实例化 FunctionTemplate,让 global_proxy 上有正确的 constructor。

16.3.4 PreloadRealmLifetimeController:一个自持的对象

第七步那个 controller 不是"顺便建一下",它是整个 realm 的生命周期管理者,而且自己持有自己:

class PreloadRealmLifetimeController
	: public blink::GarbageCollected<PreloadRealmLifetimeController>,
	public blink::ContextLifecycleObserver {
	public:
	explicit PreloadRealmLifetimeController(...)
	: initiator_script_state_(initiator_script_state),
		is_initiator_worker_or_worklet_(
			initiator_execution_context->IsWorkerOrWorkletGlobalScope()),
		shadow_realm_global_scope_(shadow_realm_global_scope),
		shadow_realm_script_state_(shadow_realm_script_state),
		service_worker_data_(service_worker_data) {
	// Align lifetime of this controller to that of the initiator's context.
	self_ = this;
	SetContextLifecycleNotifier(initiator_execution_context);
	RegisterDebugger(initiator_execution_context);
	initiator_context()->SetAlignedPointerInEmbedderData(
		kElectronContextEmbedderDataIndex, static_cast<void*>(this),
		v8::kEmbedderDataTypeTagDefault);
	realm_context()->SetAlignedPointerInEmbedderData(
		kElectronContextEmbedderDataIndex, static_cast<void*>(this),
		v8::kEmbedderDataTypeTagDefault);
	metrics_ = base::ProcessMetrics::CreateCurrentProcessMetrics();
	RunInitScript();
	}

self_ = this。 self_ 是 blink::Persistent<PreloadRealmLifetimeController>,被 GC_PLUGIN_IGNORE 标注:

	GC_PLUGIN_IGNORE(
	"Intentional GC root to keep this object alive until the context is "
	"destroyed")
	blink::Persistent<PreloadRealmLifetimeController> self_;

Persistent 是强引用。自己持有自己等于一个永远不回收的 root 环,直到 ContextDestroyed() 里 self_.Clear()。为什么?因为除了这个自引用,没有任何东西强引用 controller——它是 MakeGarbageCollected 出来的,OnCreatePreloadableV8Context 用完就不管了。没有 self_ 的话下一次 GC 就把它回收,realm 的销毁回调无人接、embedder data 指向悬空指针。GC_PLUGIN_IGNORE 是给 Blink 的 GC 插件看的"我知道这是环,别报警"——这个标注本身就承认了:这是一个刻意的内存泄漏,用 context 销毁来兜底回收。

SetContextLifecycleNotifier(initiator_execution_context):注册为 initiator(SW 的 context)的观察者,SW context 销毁时 ContextDestroyed() 被调用。注意观察的是 initiator 而不是 realm——realm 是自己管的,不需要观察。

双写 embedder data:两个 context 的同一个槽位都指向 controller。于是从 SW context 出发能找到 realm,从 realm 出发能找到 SW。这是 GetPreloadRealmContext 与 GetInitiatorContext(:229-254)的基础,两个函数都先检查 ExecutionContext 类型(IsServiceWorkerGlobalScope / IsShadowRealmGlobalScope),再取 controller。

RegisterDebugger(:142-158)把 realm 注册到 WorkerThreadDebugger 并改 URL:

	blink::KURL url_for_debugger(worker_context->Url());
	url_for_debugger.SetPath("electron-preload-realm");
	debugger->ContextCreated(worker_context->GetThread(), url_for_debugger,
							context);

让 DevTools 里能看到一个叫 electron-preload-realm 的执行上下文。没有它,preload 里的 debugger 语句和调用栈都会显示成 sw.js 的一部分。代码里那个孤零零的分号(:148)是历史修改的痕迹。

ContextDestroyed(:113-129)里的顺序也有讲究:

	shadow_realm_script_state_->DisposePerContextData();
	if (is_initiator_worker_or_worklet_) {
	shadow_realm_script_state_->DissociateContext();
	}
	shadow_realm_script_state_.Clear();
	shadow_realm_global_scope_->NotifyContextDestroyed();
	shadow_realm_global_scope_.Clear();
	self_.Clear();

DisposePerContextData 清 V8 侧数据,DissociateContext 切断 Blink 与 V8 context 的关联(只有 worker/worklet 场景需要,主线程不需要),最后 self_.Clear() 才允许 GC 回收自己。顺序反了会访问已释放对象。

16.3.5 preload realm 里的 process 是手工拼的

RunInitScript(:160-211)不跑任何 bundle,它手工构造 process 再调 RunPreloadScripts。

	// The browser attached the service-worker preload set + process info to
	// this worker's EmbeddedWorkerStartParams ... Deserialize and capture it
	// once on the ServiceWorkerData so preload contents and code caches are
	// looked up from it without marshaling them through V8.
	if (const std::optional<mojo_base::BigBuffer>& blob =
			service_worker_data_->proxy()->ElectronPreloadData()) {
	mojom::RendererStartupDataPtr data;
	if (mojom::RendererStartupData::Deserialize(
			base::span<const uint8_t>(*blob), &data)) {
		service_worker_data_->SetWorkerStartupData(std::move(data));
	}
	}
	gin_helper::Dictionary process = gin::Dictionary::CreateEmpty(isolate);
	ElectronBindings::BindProcess(isolate, &process, metrics_.get());
	process.SetMethod<&preload_utils::Uptime>("uptime");
	process.Set("argv", base::CommandLine::ForCurrentProcess()->argv());
	process.Set("pid", base::GetCurrentProcId());
	process.Set("sandboxed", true);
	process.Set("type", "service-worker");
	process.Set("contextIsolated", true);

先是反序列化 RendererStartupData(16.3.1 那个由 GetServiceWorkerStartupData 序列化的 blob),里面含 preload 源码、代码缓存、process 属性。只反序列化一次并挂到 ServiceWorkerData,因为 LookupPreloadScript(preload_utils.cc:94-112)要按 id 找脚本,每次都经 V8 传一遍成本太高。

process 的属性对照:

属性值与 frame 的差异
type"service-worker"frame 是 "renderer";不在 NodeBindings::ProcessType() 的 switch 里
sandboxedtrue(硬编码)frame 里来自 webPreferences
contextIsolatedtrue(硬编码)frame 里来自 webPreferences
pid / argv / uptime / crash 等同 frame—

sandboxed: true 不代表这个进程真 sandboxed(--no-sandbox 下不是),而是"preload 里的代码应按 sandboxed 方式写"——它没有 Node、没有 require('fs'),这是给用户代码的承诺而非对环境的描述。contextIsolated: true 是真的。

process.type = "service-worker" 是只在 SW preload 里存在的值。它不在 ProcessType() 的 switch 里(那里只有 browser/renderer/worker/utility),因为它不是 Node 环境的类型,只是给 JS 看的标记。common/init 会因为它不等于 browser/renderer/utility 而不建任何 electron 模块别名——但 SW 的 preload 又确实需要 require('electron'),矛盾在下一步解决:

	// Create ipcRenderer up front so that messages from the browser have
	// somewhere to go before a preload script asks for it.
	preload_utils::GetBinding(
		isolate, gin::StringToV8(isolate, "electron_renderer_ipc"));
	const mojom::RendererStartupDataPtr& startup_data =
		service_worker_data_->worker_startup_data();
	v8::Local<v8::Object> preload_process =
		preload_environment::CreateProcessObject(context, process, startup_data);
	v8::Local<v8::Object> electron_module =
		preload_environment::CreateElectronModule(
			context, preload_environment::Flavor::kServiceWorker);
	preload_environment::RunPreloadScripts(
		context, /*render_frame=*/nullptr, service_worker_data_.get(),
		preload_process, electron_module,
		preload_environment::Flavor::kServiceWorker, startup_data);

GetBinding 提前执行,因为 ipcRenderer 的创建会顺便把 ipcNative 装到 global 上(electron_api_ipc_renderer.cc:516-518):

	// ipc_native::EmitIPCEvent() delivers incoming messages to these.
	gin_helper::Dictionary(isolate, context->Global())
	.SetHidden("ipcNative", exports);

ipc_native::EmitIPCEvent 找一个隐藏的 ipcNative 对象分发消息。如果 preload 从没 require 过 ipcRenderer,这个对象不存在,browser 发来的消息就无处可去,静默丢失。这也解释了 IPCServiceWorker 构造函数里那句 DCHECK(service_worker_data):它是在 GetBinding 里触发的,此时 ServiceWorkerData 一定已建好。

CreateElectronModule(context, Flavor::kServiceWorker) 是给 preload 的 require('electron') 替代品(preload_environment.cc:191-207):

	for (size_t i = 0; i < kModules.size(); ++i) {
	if (kModules[i].renderer_only && flavor != Flavor::kRenderer)
	continue;
	module->SetLazyDataProperty(
		context, gin::StringToSymbol(isolate, kModules[i].name),
		ModuleGetter, v8::Integer::New(isolate, static_cast<int>(i)),
		static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontDelete)).Check();
	}

Flavor 只有两个值:kRenderer 和 kServiceWorker。唯一差别是 renderer_only 模块被过滤——那些需要 frame 的(webFrame、webContents)在 SW 里没意义。拿到的是一个惰性属性对象:每个模块名是 accessor,第一次读才 LoadBinding。这是第 8 章"模块按需加载"的变体,只不过模块表是 C++ 静态数组,不是 JS 的 module-list.ts。

RunPreloadScripts 遍历 data->preload_scripts,对每个调 CreatePreloadScript(render_frame=nullptr, service_worker_data.get(), ...),在 require/process/exports/module/global 五个参数下执行。LookupPreloadScript 正是靠这个二选一决定从哪拿数据:

	const mojom::RendererStartupDataPtr* data = nullptr;
	if (render_frame) {
	if (auto* api_service = ElectronApiServiceImpl::Get(render_frame))
	data = &api_service->startup_data();
	} else if (service_worker_data) {
	data = &service_worker_data->worker_startup_data();
	}

这就是"同一套 preload 执行器服务两种宿主"的实现:一个可空 render_frame 加一个可空 service_worker_data,恰好有一个非空。 用两个可空参数表达和类型,代价是调用点必须自己保证,编译器不检查。

16.3.6 browser → SW:ServiceWorkerMain

用户在 main 进程里看到的是 session.serviceWorkers 返回的 ServiceWorkerMain,一个 cppgc 管理的 gin::Wrappable,索引键三元(electron_api_service_worker_main.cc:68-78):

// ServiceWorkerKey -> ServiceWorkerMain
auto& GetVersionIdMap() {
	using Map = base::flat_map<ServiceWorkerKey,
							cppgc::WeakPersistent<ServiceWorkerMain>>;
	static base::NoDestructor<Map> instance;
	return *instance;
}

ServiceWorkerKey 是 {browser_context_id, storage_partition_config, version_id}。为什么要三个?version id 只在同一 storage partition 里唯一——两个 Session 可以有同名 scope 的 SW,version id 可能碰撞;partition 又可能因 persist: 前缀不同而属于不同存储分区。少一个分量就会出现"拿到别的 session 的 SW"。值是 WeakPersistent,因为对象是 cppgc 管理的,强引用会导致永不回收。

From() 的创建条件(:324-346):

	if (auto* service_worker = FromServiceWorkerKey(service_worker_key))
	return service_worker;
	// Ensure ServiceWorkerVersion exists and is not redundant (pending deletion)
	auto* live_version = GetLiveVersion(sw_context, version_id);
	if (!live_version || live_version->is_redundant()) {
	return nullptr;
	}
	return cppgc::MakeGarbageCollected<ServiceWorkerMain>(...);

is_redundant() 是 SW 生命周期里的特殊状态:已被新的替换或 unregister,但还在跑(可能有正在处理的 fetch)。它不能作为新工作的目标,也不能立刻销毁。From() 拒绝为 redundant 的 version 建对象——拿到也没用。

GetLiveVersion 用了 content 的私有 API(service_worker_context_wrapper.h,带 // nogncheck):

// Use private API to get the live version of the service worker. This will
// exist while in starting, stopping, or stopped running status.
content::ServiceWorkerVersion* GetLiveVersion(
	content::ServiceWorkerContext* service_worker_context, int64_t version_id) {
	auto* wrapper = static_cast<content::ServiceWorkerContextWrapper*>(
	service_worker_context);
	return wrapper->GetLiveVersion(version_id);
}

它与公开的 GetRunningServiceWorkerInfos() 的区别:前者能拿到"starting/stopping/stopped 但还没销毁"的 version,后者只有 running 的。这就是 ServiceWorkerMain 能在 worker 不 running 时还存在的原因。

这个对象最特别的地方是它会自己发现自己死了。

void ServiceWorkerMain::InvalidateVersionInfo() {
	version_info_.reset();
	if (version_destroyed_) return;
	version_info_ = GetLiveVersionInfo(service_worker_context_, version_id_);
	// if there's no version info, mark the version as destroyed
	if (!version_info_) {
	Destroy();
	}
}
void ServiceWorkerMain::Destroy() {
	if (version_destroyed_) return;
	version_destroyed_ = true;
	InvalidateVersionInfo();
	MaybeDisconnectRemote();
	GetVersionIdMap().erase(key_);
	keep_alive_.Clear();
}

Destroy() 里又调 InvalidateVersionInfo()——安全的递归,因为标志已置真,第二次进来立刻 return。这种"置标志再回调自己"让 Destroy() 可以从任何状态进入(构造、InvalidateVersionInfo、OnVersionRedundant、析构)。keep_alive_.Clear() 允许 GC 回收,但真正回收要等 JS 侧也放手。

MaybeDisconnectRemote()(:117-124)决定要不要断 mojo 连接:已经销毁,或者既不 starting 也不 running。stopped 也断,因为 remote_ 关联到"某个具体 worker 实例",worker 停了 endpoint 就失效,留着它下次 GetRendererApi() 会返回"is_bound 但已断开"的 remote,send 静默失败。

mojom::ElectronRenderer* ServiceWorkerMain::GetRendererApi() {
	if (!remote_.is_bound()) {
	if (!service_worker_context_->IsLiveRunningServiceWorker(version_id_)) {
	return nullptr;
	}
	service_worker_context_->GetRemoteAssociatedInterfaces(version_id_)
		.GetInterface(&remote_);
	}
	return remote_.get();
}

对应的渲染侧注册点就是 ServiceWorkerData 构造函数里那句 proxy_->GetAssociatedInterfaceRegistry().AddInterface<mojom::ElectronRenderer>(...)。

Send 失败是静默的(:138-150):worker 没在跑时 GetRendererApi() 返回 nullptr,直接 return。这是有意设计——SW 随时可能不在,send 时它可能已被 idle 回收。要保证送达,用户应先 startTask() 或用 startWorkerForScope()。

16.3.7 startTask:把 worker 钉住

SW 空闲会被回收,这对"发一条消息、等它处理"是致命的。startTask() 向 content 申请一个 external request,在请求结束前不会被 idle 回收(:152-195):

	// TODO(samuelmaddock): maybe make timeout configurable in the future
	auto request_uuid = base::Uuid::GenerateRandomV4();
	content::ServiceWorkerExternalRequestResult start_result =
	service_worker_context_->StartingExternalRequest(
		version_id_,
		content::ServiceWorkerExternalRequestTimeoutType::kDoesNotTimeout,
		request_uuid);
	if (start_result != content::ServiceWorkerExternalRequestResult::kOk) {
	thrower.ThrowError("Unable to start service worker task.");
	return {};
	}
	auto task = gin_helper::Dictionary::CreateEmpty(isolate);
	// The task references this ServiceWorkerMain so that end() can be called for
	// as long as the task is alive; end() itself only holds it weakly.
	v8::Local<v8::Object> wrapper;
	if (GetWrapper(isolate).ToLocal(&wrapper)) {
	task.GetHandle()->SetPrivate(
		isolate->GetCurrentContext(),
		v8::Private::ForApi(isolate, gin::StringToV8(isolate, "serviceWorker")),
		wrapper).Check();
	}
	task.Set("end", gin::ConvertToV8(isolate,
	base::BindRepeating(
		[](const cppgc::WeakPersistent<ServiceWorkerMain>& self,
			const std::string& uuid, v8::Isolate* isolate) {
			if (self) self->FinishExternalRequest(isolate, uuid);
		},
		cppgc::WeakPersistent<ServiceWorkerMain>(this),
		request_uuid.AsLowercaseString())));

四个设计点:

kDoesNotTimeout。 content 支持 kTimeout(几秒后自动释放)和 kDoesNotTimeout。选后者因为"任务"语义就是"我要多久就多久"。代价是忘了调 end() worker 永不回收,文档明确警告:"If never called, the service won't terminate while otherwise idle."

私有属性挂 wrapper。 v8::Private::ForApi 创建"JS 看不到但 C++ 能查"的键(第 14 章讲 ipcNative 用的同一套)。挂 wrapper 让 task 强引用 ServiceWorkerMain 的 JS 包装,只要 task 活着对象就不会被 GC。但 end() 的闭包只持 WeakPersistent——这个不对称很关键:task 活着 → worker 对象活着;worker 对象活着 ≠ task 活着。后者若成立就泄漏。

end 是绑定过的 C++ 函数。 base::BindRepeating + gin::ConvertToV8,闭包捕获弱引用和 uuid 字符串,所以 end 可以脱离 task 单独取出调用(const { end } = task; end(); 也工作)。

AsLowercaseString()。 uuid 在 end 里被 ParseLowercase 重新解析,格式必须一致,否则抛 "Invalid external request UUID"。

FinishExternalRequest(:248-294)把五种 content 错误码翻译成字符串:kBadRequestId → "Unknown external request UUID",kWorkerNotRunning → "Service worker is no longer running",kWorkerNotFound → "Service worker was not found",kNullContext/default → "Service worker context is unavailable and may be shutting down"。

注意 kOk 之后还有个检查(:264-269):

	// Still release the request above so a doomed worker can stop.
	if (version_destroyed_) {
	isolate->ThrowException(v8::Exception::TypeError(
		gin::StringToV8(isolate, "ServiceWorkerMain is destroyed")));
	return;
	}

先释放请求,再报告"对象已销毁"。 顺序不能反:先抛异常的话调用方的 catch 会让 FinishedExternalRequest 永远不被调用,worker 就永远不回收。这种"副作用无条件执行、错误报告放后面"的模式,在资源释放类 API 里是标准做法。

16.3.8 SW → browser:ElectronApiSWIPCHandlerImpl

反方向的实现是 229 行的 electron_api_sw_ipc_handler_impl.cc:28-34。结构和 frame 版的 ElectronApiIPCHandlerImpl(第 14 章)很像,但有三处关键不同。

一,一个进程里有多个 handler。 frame 版是"一个 RenderFrameHost 一个 handler";SW 没有 frame 可挂,于是挂到 RenderProcessHost 的 UserData 上,而且是一个列表(:28-49):

const void* const kUserDataKey = &kUserDataKey;
class ServiceWorkerIPCList : public base::SupportsUserData::Data {
	public:
	std::vector<std::unique_ptr<ElectronApiSWIPCHandlerImpl>> list;
	static ServiceWorkerIPCList* Get(
	content::RenderProcessHost* render_process_host,
	bool create_if_not_exists) { /* GetUserData / SetUserData */ }
};

一个 SW 进程可以同时跑多个 service worker(不同 scope、不同 version),每个 version 有自己的 ElectronApiIPC 通道、自己的 version_id、自己的 ServiceWorkerMain。kUserDataKey = &kUserDataKey 是 Chromium 里常见的自指技巧:把变量自己的地址当键,保证跨翻译单元唯一。

二,version_id_ 是构造参数,不在消息里。 它来自 RegisterAssociatedInterfaceBindersForServiceWorker:

electron_browser_client.cc:1816-1823

void ElectronBrowserClient::RegisterAssociatedInterfaceBindersForServiceWorker(
	const content::ServiceWorkerVersionBaseInfo& service_worker_version_info,
	blink::AssociatedInterfaceRegistry& associated_registry) {
	CHECK(service_worker_version_info.process_id);
	associated_registry.AddInterface<mojom::ElectronApiIPC>(
	base::BindRepeating(&ElectronApiSWIPCHandlerImpl::BindReceiver,
						service_worker_version_info.process_id,
						service_worker_version_info.version_id));

BindReceiver(:212-227)拿 process_id 和 version_id 就能建 handler:

	auto* render_process_host =
	content::RenderProcessHost::FromID(render_process_id);
	if (!render_process_host) return;
	auto* service_worker_ipc_list = ServiceWorkerIPCList::Get(
	render_process_host, /*create_if_not_exists=*/true);
	service_worker_ipc_list->list.push_back(
	std::make_unique<ElectronApiSWIPCHandlerImpl>(
		render_process_host, version_id, std::move(receiver)));

对比 frame 版:frame 每条消息都要从 frame_tree_node_id 找 WebFrameMain,因为 frame 会经历导航 swap。SW 的 version id 在一个 worker 实例生命周期里不变,可以固化成成员。这是"生命周期更稳定 → 信息可以前置"的例子。

三,MakeIPCEvent 处理"session 不存在"(:174-189):

api::IpcMainServiceWorkerEvent* ElectronApiSWIPCHandlerImpl::MakeIPCEvent(
	v8::Isolate* isolate, api::Session* session, bool internal,
	electron::mojom::ElectronApiIPC::InvokeCallback callback) {
	if (!session) {
	// We must always invoke the callback if present.
	gin_helper::internal::ReplyChannel::SendError(isolate, std::move(callback),
												"Session does not exist");
	return {};
	}
	return api::IpcMainServiceWorkerEvent::Create(
	isolate, session, version_id_,
	render_process_host_->GetID().GetUnsafeValue(), std::move(callback));
}

session 从 api::Session::FromBrowserContext(GetBrowserContext()) 拿,返回 WeakCell,可能为空(session 正在销毁,或这个 browser context 根本不是 Electron 的)。空的时候必须回错误而不是只 return——否则调用方的 invoke Promise 永远 pending。这是第 14 章"反 TOCTOU"主题的延伸:任何带 => 的 mojom 方法,只要可能提前返回,就必须保证回调被调用一次且仅一次。

MessageHost 直接 NOTIMPLEMENTED()(:158-162):

void ElectronApiSWIPCHandlerImpl::MessageHost(
	const std::string& channel, electron::SerializedValue arguments) {
	NOTIMPLEMENTED();  // Service workers have no <webview>
}

sendToHost 是 <webview> 专用,SW 没有 embedder。它连回调都没有,所以不会造成 Promise 悬挂。

销毁路径两条。 正常路径:mojo 断开 → RemoteDisconnected → Destroy();异常路径:渲染进程崩了 → RenderProcessExited → Destroy()。

void ElectronApiSWIPCHandlerImpl::Destroy() {
	auto* service_worker_ipc_list = ServiceWorkerIPCList::Get(
	render_process_host_, /*create_if_not_exists=*/false);
	CHECK(service_worker_ipc_list);
	// std::erase_if will lead to a call to the destructor for this object.
	std::erase_if(service_worker_ipc_list->list, base::MatchesUniquePtr(this));
}
void ElectronApiSWIPCHandlerImpl::RenderProcessExited(
	content::RenderProcessHost* host,
	const content::ChildProcessTerminationInfo& info) {
	CHECK_EQ(host, render_process_host_);
	// TODO(crbug.com/1407197): Investigate clearing the user data from
	// RenderProcessHostImpl::Cleanup.
	Destroy();
	// This instance has now been deleted.
}

CHECK_EQ(host, ...) 是因为一个进程可能被多个 observer 观察(每个 handler 都 AddObserver(this)),必须确认通知是给自己的。Destroy() 里 erase_if 触发 unique_ptr 析构,而析构函数会 RemoveObserver——在观察者回调里删除观察者自己。这是允许的(Chromium 的 observer list 支持遍历中删除),但必须在 Destroy() 之后立刻 return。注释 "This instance has now been deleted" 就是在提醒。

两条路径都指向同一个 CHECK(service_worker_ipc_list)。如果走到这里列表已经没了(进程销毁时 UserData 先被清),CHECK 会崩。注释里那个 crbug 指的正是"UserData 清理时机不确定",这是一个潜在崩溃点,只是很少触发。

16.3.9 消息最终落到哪:一个刻意的不对称

ipc_dispatch::ServiceWorkerMessage 的目标集合由 CollectServiceWorkerTargets 决定(electron_api_ipc_dispatch.cc:550-566):

// The worker's ServiceWorkerMain.ipc, if the worker (still) exists.
void CollectServiceWorkerTargets(v8::Local<v8::Context> context,
								api::Session* session, int64_t version_id,
								v8::LocalVector<v8::Object>* out) {
	api::ServiceWorkerContext* workers = session->ServiceWorkerContext();
	if (!workers) return;
	v8::Local<v8::Value> worker =
	workers->GetWorkerFromVersionIDIfExists(isolate, version_id);
	v8::Local<v8::Object> ipc;
	if (!worker.IsEmpty() && worker->IsObject() &&
	IpcOf(context, worker.As<v8::Object>()).ToLocal(&ipc)) {
	out->push_back(ipc);
	}
}

对比 frame 版的 CollectFrameTargets(:528-548):

	if (frame_tree_node_id) { /* frame.ipc */ }
	v8::Local<v8::Object> wc_ipc;
	if (IpcOf(context, sender).ToLocal(&wc_ipc)) out->push_back(wc_ipc);
	out->push_back(GetRegistry().ipc_main.Get(isolate));
frameservice worker
webContents.ipc有无(没有 WebContents)
frame.ipc有无(没有 frame)
ipcMain有(第三个目标)没有

结论:ipcMain.on(channel) 收不到 SW 发来的消息,ipcMain.handle(channel) 也不会被 SW 的 invoke 命中。 必须用 serviceWorker.ipc.on/handle。

文档没明说(ipc-main-service-worker.md 只说这是 IpcMain 的一个变体),但代码里是硬事实。为什么这么设计?因为 ipcMain 是"全局收件箱",如果 SW 的消息也进这里,用户无法区分"页面发来的"和"后台 worker 发来的",而同一 channel 名在两类来源里含义可能完全不同。更重要的是:SW 有多个实例,消息必须能路由到"是哪个 SW",而 IpcMainEvent 上没有 versionId(只有 sender/frameId/processId/frame/senderFrame)。IpcMainServiceWorkerEvent 才有 versionId 和 session。

所以这不是遗漏,是"事件对象缺少路由信息"导致的必然结果。要让 ipcMain 也收,就得给 IpcMainEvent 加 versionId,让同一个 handler 同时处理两种来源——那会让 ipcMain 的类型和语义都变脏。

同样的缺失出现在 invoke 上:

void ServiceWorkerInvoke(v8::Isolate* isolate,
						api::IpcMainServiceWorkerEvent* ipc_event, bool internal,
						const std::string& channel, v8::Local<v8::Value> args) {
	v8::LocalVector<v8::Object> targets(isolate);
	if (internal) {
	targets.push_back(registry.ipc_main_internal.Get(isolate));
	} else {
	CollectServiceWorkerTargets(context, session, ipc_event->version_id(), &targets);
	}
	RunInvokeHandler(context, targets, event, channel, args);

FindInvokeHandler(:383-398)在这组 targets 里找 _invokeHandlers,找不到就回 "No handler registered for 'channel'"。也就是说:在 ipcMain.handle('x') 之后,ipcRenderer.invoke('x') 从 frame 发能成功,从 SW 发会失败,错误信息还很迷惑("没注册 handler",但你明明注册了)。

这是本章最该写进调试手册的一条:功能在页面上正常、在 SW 里静默失败、错误指向"没注册 handler"。

16.3.10 session.serviceWorkers:browser 侧的观测面

browser 侧还有一个纯观测对象 ServiceWorkerContext(electron_api_service_worker_context.cc:83-90),是 session.serviceWorkers 的实现。构造时订阅 content 的观察者接口(:83-92):

ServiceWorkerContext::ServiceWorkerContext(
	v8::Isolate* isolate, ElectronBrowserContext* browser_context)
	: service_worker_context_{browser_context->GetDefaultStoragePartition()
								->GetServiceWorkerContext()},
	browser_context_id_{browser_context->UniqueId()},
	storage_partition_config_{
		browser_context->GetDefaultStoragePartition()->GetConfig()} {
	service_worker_context_->AddObserver(this);
}

存下 browser_context_id_ 和 storage_partition_config_ 正是为了给 ServiceWorkerMain::FromVersionID 提供完整的 key。

六个回调全部转发成 JS 事件:

content 回调Electron 做了什么
OnRegistrationCompleted(scope)emit 'registration-completed'
OnReportConsoleMessage(...)emit 'console-message'(六个字段)
OnVersionStartingRunning / StartedRunning / StoppingRunning / StoppedRunning合并成 'running-status-changed'
OnVersionRedundant转给对应的 ServiceWorkerMain
void ServiceWorkerContext::OnRunningStatusChanged(
	int64_t version_id, blink::EmbeddedWorkerStatus running_status) {
	if (auto* worker = ServiceWorkerMain::FromVersionID(
		browser_context_id_, storage_partition_config_, version_id))
	worker->OnRunningStatusChanged(running_status);
	EmitWithoutEvent("running-status-changed",
				gin::DataObjectBuilder(isolate)
					.Set("versionId", version_id)
					.Set("runningStatus", running_status)
					.Build());
}

顺序重要:先通知 ServiceWorkerMain(更新状态、可能销毁自己),再 emit 给 JS。 反过来,用户在处理器里调 getWorkerFromVersionID 可能拿到一个还没来得及销毁的旧对象。

OnVersionRedundant 里有个容易漏的边界(electron_api_service_worker_main.cc:224-237):

void ServiceWorkerMain::OnVersionRedundant() {
	redundant_ = true;
	// content only broadcasts OnStopped for versions that reached RUNNING;
	// anything else gets no further running status change, so destroy now.
	auto* version = GetLiveVersion(service_worker_context_, version_id_);
	if (!version ||
	version->running_status() != blink::EmbeddedWorkerStatus::kRunning) {
	Destroy();
	}
}

content 只对"曾经进入 RUNNING"的 version 广播 stopped。一个"注册了但从没启动"的 SW 被 unregister 后不会再有任何状态变化,如果等着 OnRunningStatusChanged(kStopped) 才销毁,对象永远不会释放。所以这里主动查一次 running_status()。这种"上游只对某个子集发通知"的假设,是跨进程事件转发里最常见的泄漏源——代码用注释把假设固定下来,但假设完全依赖 content 的实现细节,上游一改就回归。

StartWorkerForScope(:231-273)把"按 scope 启动 worker"包成 Promise:

	service_worker_context_->StartWorkerForScope(
	scope, storage_key,
	base::BindOnce(&ServiceWorkerContext::DidStartWorkerForScope,
					gin::WrapPersistent(weak_factory_.GetWeakCell(
						isolate->GetCppHeap()->GetAllocationHandle())),
					shared_promise),
	base::BindOnce(&ServiceWorkerContext::DidFailToStartWorkerForScope,
					gin::WrapPersistent(weak_factory_.GetWeakCell(...)),
					shared_promise));

shared_promise 是 std::shared_ptr<gin_helper::Promise<...>>,两个回调各持一份:只有一个会被调用,但编译期不知道是哪个,两边都得有所有权(Promise 不可复制,所以用 shared_ptr)。gin::WrapPersistent(weak_factory_.GetWeakCell(...)) 把 weak cell 包成强引用传给回调,是 cppgc 对象跨异步边界保活的固定写法(第 7 章)。回调里 Resolve 之后立刻 shared_promise.reset()——忘了 reset 会活到 JS 的 Promise 被 GC 为止,实际上就是泄漏。

16.4 utility process:一个真正的 Chromium service

前三种环境都还在 Blink 的世界里(有 ExecutionContext、有 WorkerThread)。utility process 完全不同:没有 Blink、没有 ExecutionContext、没有 WorkerThread、甚至没有 RenderProcessHost。 它是 Chromium 的 ServiceProcessHost 拉起的一个 service 进程,Electron 往里面塞了一个完整的 Node。它也是四种里唯一"天生就有 Node"的:不需要 nodeIntegrationInWorker、不需要 preload,utilityProcess.fork() 一调,进程里立刻有一个 node::Environment。

16.4.1 JS 层:ForkUtilityProcess 的四层包装

utility-process.ts:94-101(159 行)比看起来做得多。

参数重排。 fork(path, options) 这种省略 args 的形式被识别为"第二个参数是对象且不是数组",此时 options = args; args = [],args == null 则补空数组。

stdio 归一化。 字符串简写展开成 ['ignore', x, x];'pipe' 时创建两个 PassThrough;stdin 恒为 'ignore'(数组形式里 stdio[0] !== 'ignore' 直接抛错)。PassThrough 充当"用户随时开始监听也不丢数据"的缓冲。

handle.emit 的拦截。 这是最精妙的地方:

	this.#handle!.emit = (channel: string | symbol, ...args: any[]) => {
	if (channel === 'exit') {
		try {
		this.emit('exit', ...args);
		} finally {
		this.#handle = null;
		const stdout = this.#stdout, stderr = this.#stderr;
		this.#stdout = this.#stderr = null;
		if (!this.#stdoutConnected) stdout?.end();
		if (!this.#stderrConnected) stderr?.end();
		}
		return false;
	} else if (channel === 'stdout' && this.#stdout) {
		this.#stdoutConnected = true;
		new Socket({ fd: args[0], readable: true }).pipe(this.#stdout);   // stderr 同构
		return true;
	} else {
		return this.emit(channel, ...args);
	}
	};

C++ 侧的 UtilityProcessWrapper 是 EventEmitterMixin,用 EmitWithoutEvent 往 JS 发事件;但 JS 侧的 ForkUtilityProcess 不是那个 C++ 对象,只是持有 #handle 的 EventEmitter。于是这里直接覆盖 C++ 对象上的 emit(它从 EventEmitter.prototype 继承,可被实例属性遮蔽),由闭包决定转发还是自己处理:stdout/stderr 把 C++ 交来的 fd 包成 Socket 接到 PassThrough 上,exit 先透传事件、再断开引用。

exit 里那段注释("leave the streams' listeners alone")值得完整理解:进程退出时管道里可能还有没读完的数据(子进程最后几行日志),此时 end() 会丢数据;所以"已连接"的流不动,让它读到 EOF 自己 end,"没连接过"的流要主动 end,否则读端永远等不到数据也不会 end。stdoutConnected 的定义是"C++ 已经把 fd 交过来了",不是"用户监听了 data"。

_unwrapHandle()。 私有字段外部拿不到,但有些 API 需要把 C++ 对象传给另一个 C++ 函数,比如 session.registerLocalAIHandler(handler)(session.ts:116-120)——每多一层 JS 包装,就多一个要打洞的地方。

16.4.2 C++ 侧:UtilityProcessWrapper 与 launch

electron_api_utility_process.cc:73-80(739 行)比 SW 那套简单,因为只有两个方向要自己实现:NodeService 管控制面,MessagePortDescriptor 管数据面,都不需要"找 frame"或"找 version"。

注册表:构造即注册。

// Tracks every UtilityProcessWrapper from construction until termination,
// including ones whose child has not launched yet and so has no pid.
struct UtilityProcessRegistry {
	using Entries = std::vector<cppgc::WeakPersistent<api::UtilityProcessWrapper>>;
	void Add(api::UtilityProcessWrapper* wrapper) { wrappers_.emplace_back(wrapper); }
	void Remove(api::UtilityProcessWrapper* wrapper) {
	std::erase_if(wrappers_, [wrapper](const auto& entry) {
	return !entry || entry.Get() == wrapper;
	});
	}
	Entries wrappers_;
};
	// Registered before anything can fail, so that browser shutdown also reaches
	// a wrapper whose child is still launching.
	GetAllUtilityProcessWrappers().Add(this);

注释解释的场景:app.quit() 时如果某个 utility 还在 launch(没有 pid),ShutdownAll() 必须能找到它并走完 exit 流程,否则进程会挂着——所以注册要在构造最开头,早于任何可能失败的操作。存 WeakPersistent(对象归 cppgc 管,强引用会永不回收),Remove 里 !entry || 处理"弱引用已失效"。

stdio:一个平台两套实现。 Windows 用 CreatePipe + _open_osfhandle(HANDLE 转 CRT fd),POSIX 用 pipe() + FileHandleMappingVector。Windows 那段注释点出易错点:管道句柄的"可继承"属性不在这里设,由 base::Launch 统一处理(Chromium 约定:所有句柄继承集中在一处配置)。

失败路径 fail_launch 有两个要点:清理已创建的 fd(否则泄漏),以及用 PostTask 延迟发 exit。原因写在注释里——"Nothing else calls HandleTermination() if we bail before launch; post it so 'exit' fires after JS has attached its listeners":构造函数还在跑,JS 的 child.on('exit') 还没注册,同步 emit 会丢事件。这个模式在任何"构造 + 事件"的 API 里都是必需的(第 9 章的 NativeWindow 也用过)。

ServiceProcessHost::Launch。 真正启动进程:

	content::ServiceProcessHost::Launch(
	std::move(receiver),
	content::ServiceProcessHost::Options()
		.WithDisplayName(...)
		.WithExtraCommandLineSwitches(params->exec_args)
		.WithCurrentDirectory(current_working_directory)
		.WithEnvironment(env_map, env_map.empty() ? false : true)
		.WithStdoutHandle(std::move(stdout_write))      // WIN
		.WithStderrHandle(std::move(stderr_write))      // WIN
		.WithFeedbackCursorOff(true)                    // WIN
		.WithAdditionalFds(std::move(fds_to_remap))     // POSIX
		.WithChildFlags(...) .WithDisclaimResponsibility(...)  // MAC
		.WithProcessCallback(...)
		.Pass());
  • WithDisplayName 出现在 app.getAppMetrics() 的 name 和 child-process-gone 里(默认 "Node Utility Process",可用 serviceName 覆盖),是 utility 在任务管理器里唯一的身份标识。
  • WithEnvironment(env_map, clear_environment) 的第二个参数是"是否清空父进程环境",代码写的是"用户给了 env 就清空"——不清空的话 PATH 会从父进程漏进来,用户以为设了完整环境,实际是"父进程环境 + 我的覆盖"。
  • WithFeedbackCursorOff(true)(Windows)避免子进程启动时鼠标指针闪一下;WithChildFlags(kChildProcessHelperPlugin) + WithDisclaimResponsibility(macOS)分别对应"用带特殊 entitlements 的 Plugin helper 启动"和"TCC 权限不归属父应用"。

独立的 message pipe。

	// We use a separate message pipe to support postMessage API
	// instead of the existing receiver interface so that we can
	// support queuing of messages without having to block other interfaces.
	blink::MessagePortDescriptorPair pipe;
	host_port_ = pipe.TakePort0();
	params->port = pipe.TakePort1();
	connector_ = std::make_unique<mojo::Connector>(
	host_port_.TakeHandleToEntangleWithEmbedder(),
	mojo::Connector::SINGLE_THREADED_SEND,
	base::SingleThreadTaskRunner::GetCurrentDefault());
	connector_->set_incoming_receiver(this);
	connector_->set_connection_error_handler(base::BindOnce(
	&UtilityProcessWrapper::CloseConnectorPort, base::Unretained(this)));

为什么独立管道?postMessage 需要排队(消息可以发得比接收方处理得快),与控制接口共用会阻塞控制消息(比如 UpdateURLLoaderFactory)。MessagePortDescriptorPair 是一对已连通的 pipe,一端留 browser,另一端经 params->port 交给子进程;SINGLE_THREADED_SEND 表示只在创建线程发送,省掉加锁;set_incoming_receiver(this) 让 UtilityProcessWrapper::Accept(它同时继承 mojo::MessageReceiver)接管接收。

URL loader factory:有 session 和没 session 两条路(:521-568)。

	loader_params->process_id = network::OriginatingProcessId::browser();
	loader_params->is_orb_enabled = false;
	loader_params->is_trusted = true;
	if (session_) {
	// Build a factory through CreateURLLoaderFactoryBuilder so requests go
	// through ProxyingURLLoaderFactory (enabling webRequest interception).
	auto [factory_builder, header_client] =
		browser_context->CreateURLLoaderFactoryBuilder();
	loader_params->header_client = std::move(header_client);
	url_loader_factory = std::move(factory_builder).Finish<...>(
		network_context, std::move(loader_params));
	} else {
	network_context = g_browser_process->system_network_context_manager()->GetContext();
	network_context->CreateURLLoaderFactory(
		url_loader_factory.InitWithNewPipeAndPassReceiver(), std::move(loader_params));
	}

三条:process_id = OriginatingProcessId::browser()(utility 没有独立 network 身份,也不该有);is_orb_enabled = false + is_trusted = true(utility 是"自己的代码",不是网页内容);session 分支用 builder 而非直接建,因为 builder 外面包了 ProxyingURLLoaderFactory,webRequest 的拦截逻辑就在那里——直接创建的话,utility 里 net.request 发出的请求不会经过 webRequest。文档只说了 "enables HTTP caching and other session-specific network features",没提 webRequest:实际只有设了 session 的 utility 才会被拦截。

网络服务崩溃后的重建。 network service 是可独立崩溃/重启的进程,它挂了之后之前发出的所有 URLLoaderFactory remote 都失效,utility 的网络请求开始报错直到进程重启。Electron 用 RegisterNetworkServiceProcessGoneHandler 订阅"进程没了",重新建工厂通过 UpdateURLLoaderFactory 推给子进程(node_service.cc:241-247 换掉 URLLoaderBundle 里的工厂),于是 network service 重启后 utility 的网络能力能自己恢复。

16.4.3 生命周期:四条路径收敛到 HandleTermination

// :320-353
void UtilityProcessWrapper::HandleTermination(uint32_t exit_code) {
	// Called from multiple callsites; only the first one may proceed.
	if (terminated_) return;
	terminated_ = true;
	GetAllUtilityProcessWrappers().Remove(this);
	pid_ = base::kNullProcessId;
	content::ServiceProcessHost::RemoveObserver(this);
	DispatchPendingMessages();
	CloseConnectorPort();
	CloseStdioReadFds();
#if BUILDFLAG(IS_POSIX)
	// SIGTERM/SIGKILL 的退出码对用户来说是"优雅关闭",归一化成 0
	if (killed_ && (exit_code == SIGTERM || exit_code == SIGKILL)) exit_code = 0;
#endif
	EmitWithoutEvent("exit", exit_code);
	keep_alive_.Clear();
}

四条来源:

一,正常终止观察(:367-374)。 OnServiceProcessTerminatedNormally(info) 先做两个过滤——if (!info.IsService<node::mojom::NodeService>() || info.GetProcess().Pid() != pid_) return;——再 HandleTermination(info.exit_code())。

IsService<node::mojom::NodeService>() 过滤"同一进程里其他 service"的通知(16.4.7 会说,utility 里还跑着打印、代理等服务)。Pid() != pid_ 过滤"不是我"——ServiceProcessHost 的观察者是全局的,每个 wrapper 都会收到所有进程的事件。

二,崩溃(:376-383)。 同样的两个过滤,同样的收敛。崩溃和正常退出在 JS 侧只体现为 exit 里不同的 code。

三,mojo 断开(:355-365)。

void UtilityProcessWrapper::OnServiceProcessDisconnected(
	uint32_t exit_code, const std::string& description) {
	if (description == "process_exit_termination") {
	HandleTermination(exit_code);
	} else if (pid_ == base::kNullProcessId) {
	// Pipe dropped before launch means the child failed to launch; the host
	// is deleted without notifying observers, so this is the only signal.
	HandleTermination(kLaunchFailureExitCode);
	}
}

用 set_disconnect_with_reason_handler 而不是 set_disconnect_handler,多出的 description 由子进程主动提供(见 16.4.4 的 ResetWithReason)。为什么需要这条? 子进程正常退出时 node::SetProcessExitHandler 会先调 ResetWithReason,让 browser 立刻拿到退出码,比 ServiceProcessHost 的观察者通知更快更可靠(后者依赖 waitpid,某些平台有延迟)。第二个分支处理"还没 launch 就断了":pid_ 还是 null,说明进程从没起来,而注释说这种 host 会被删除但不通知观察者,所以这是唯一的信号。

四,浏览器关闭(:600-611)。

// static
void UtilityProcessWrapper::ShutdownAll() {
	// Shutdown() removes each wrapper from the registry and runs 'exit'
	// listeners, so iterate over a copy that keeps the wrappers alive.
	std::vector<cppgc::Persistent<UtilityProcessWrapper>> wrappers;
	for (const auto& wrapper : GetAllUtilityProcessWrappers().wrappers()) {
	if (wrapper) wrappers.emplace_back(wrapper.Get());
	}
	for (const auto& wrapper : wrappers) wrapper->Shutdown(0 /* exit_code */);
}

遍历副本的两个理由都在这段里:Shutdown() 会 Remove(this) 修改原列表;副本用 cppgc::Persistent(强引用)而非弱引用,因为 CloseConnectorPort 可能触发 GC,弱引用会返回 null。而 Shutdown() 本身只做三件事——node_service_remote_.reset()、CloseConnectorPort()、HandleTermination(exit_code),不 DispatchPendingMessages(),因为 JS 环境正在销毁,派发消息会往半死的 context 里 emit。

HandleTermination 的顺序值得注意:先派发积压消息,再关端口。

	// Messages the child posted before it exited can still be queued on the
	// port when its exit is observed: the connector dispatches them one per
	// task, and the exit notification may already be ahead of those tasks.
	// A readable pipe never blocks WaitForIncomingMessage().
	while (!connector_closed_ && connector_ && connector_->is_valid() &&
		connector_->handle().QuerySignalsState().readable()) {
	if (!connector_->WaitForIncomingMessage()) break;
	}

mojo::Connector 的接收是任务化的,每个消息一个 task。子进程退出前发的最后几条消息可能还在管道里排队,而"退出"通知(来自另一个通道)可能先到,此时直接关端口就丢消息。这个循环用 QuerySignalsState().readable() 判断还有没有东西,有就同步取一条派发,直到取不到(可读的管道不会阻塞,这是 mojo 的语义保证)。本质是"两个通道的到达顺序无保证",只能靠抽干,而抽干是同步的,消息多时 browser 主线程会卡一下。

Kill() 与退出码归一化。

bool UtilityProcessWrapper::Kill() {
	if (pid_ == base::kNullProcessId) return false;
	base::Process process = base::Process::Open(pid_);
	bool result = process.Terminate(content::RESULT_CODE_NORMAL_EXIT, false);
	// Refs crbug.com/818244
	base::EnsureProcessTerminated(std::move(process));
	killed_ = result;
	return result;
}

POSIX 上 Terminate 发 SIGTERM,waitpid 拿到的"退出码"实际是信号编号 15,所以 HandleTermination 里归一化。EnsureProcessTerminated 是另一件事:子进程收到 SIGTERM 后若不退出(卡在系统调用里)要保证它最终被 reap,否则变僵尸——它先等一段时间再 SIGKILL。注释里那两句还暴露一个隐性假设:Linux 上 utility 目前没开 sandbox、不走 Zygote,所以直接对 pid 操作即可;一旦开了 sandbox,reap 必须改走 Zygote。

16.4.4 子进程侧:NodeService 的初始化

node_service.cc(312 行)。构造时注意 loop 的来源(:103-112):

NodeService::NodeService(mojo::PendingReceiver<node::mojom::NodeService> receiver)
	: node_bindings_{NodeBindings::Create(NodeBindings::BrowserEnvironment::kUtility,
										uv_default_loop())},
	electron_bindings_{
		std::make_unique<ElectronBindings>(node_bindings_->uv_loop())} {
	if (receiver.is_valid()) receiver_.Bind(std::move(receiver));
}

和 worker 的 Create(kWorker, nullptr) 对比:utility 传 uv_default_loop(),worker 传 nullptr(自建)。 因为 utility 是"Node 主导"的:进程启动第一件事就是跑 Node,Chromium 的 UtilityThread message loop 和 Node 的 uv loop 最终合成一个。worker 是"Blink 主导"的:线程上已有 message loop,Node 只能自建 loop,再用 PrepareEmbedThread 起轮询线程通过 uv_async 互相唤醒。

workerutility
主 loopBlink 的 message loopNode 的 uv loop
Node 的 loop自建,靠 embed thread 驱动uv_default_loop(),直接跑
process.nextTick需要 activateUvLoop 唤醒不需要
setTimeout 精度受 Blink 调度影响纯 libuv timer

common/init 里那个 wrapWithActivateUvLoop 对 utility 是无害冗余(uv_async_send 一个本来就在跑的 loop),代码没为它特判,因为冗余成本很低。

Initialize 的七步(:130-239)。 开头三步:if (NodeBindings::IsInitialized()) return;(进程级幂等,一个 utility 只初始化一次 Node)、GetRemote().Bind(std::move(client_pending_remote)); GetRemote().reset_on_disconnect();(browser 消失时 remote 自动 reset)、以及 if (params->url_loader_factory_params) UpdateURLLoaderFactory(std::move(params->url_loader_factory_params));——这一步在建 node::Environment 之前,所以入口脚本一跑起来,net.request 就已经有工厂可用了。

V8 trap handler(:143-151)在 isolate 创建前装:if (electron::fuses::IsWasmTrapHandlersEnabled()) electron::SetUpWebAssemblyTrapHandler();。顺序是硬约束——V8 初始化时会调 IsTrapHandlerEnabled(),那时没装,之后就不让装了(renderer 里同样如此)。

	js_env_.emplace(node_bindings_->uv_loop());
	// Empty when the isolate was created from the embedded Node startup
	// snapshot: the main context is then materialized ... inside
	// CreateEnvironment and entered below -- the same path the browser takes.
	const v8::Local<v8::Context> context = isolate->GetCurrentContext();
	node_bindings_->Initialize(isolate, context);

JavascriptEnvironment 是 Electron 对 isolate 的封装(第 6 章)。context 可能为空——如果 isolate 是从 Node 启动快照建的,主 context 会在 CreateEnvironment 里物化,这条路径和 browser 进程完全一样。

ParentPort 的创建时机(:166-171): ParentPort::GetInstance()->Initialize(std::move(params->port))。注释点明两件事:它是 cppgc 管理的 wrappable,必须晚于 isolate(heap 属于 isolate);connector 创建时是 paused 的,直到入口脚本调 parentPort.start(),模拟 Node worker_threads 的行为。

环境创建(:177-189):

	// Append program path for process.argv0
	auto program = base::CommandLine::ForCurrentProcess()->GetProgram();
	params->args.insert(params->args.begin(), base::WideToUTF8(program.value()));
	node_env_ = node_bindings_->CreateEnvironment(
	isolate, context, js_env_->platform(),
	js_env_->max_young_generation_size_in_bytes(), params->args,
	params->exec_args);

params->args 是用户的 args,把可执行文件路径插到第 0 位变成 process.argv[0](Node 约定:argv[0] 可执行文件、argv[1] 脚本、argv[2..] 参数)。exec_args(来自 execArgv)单独传,变成 Node 命令行选项而不是 argv 的一部分。

SetProcessExitHandler:整个文件最关键的一段(:197-206)。

	node::SetProcessExitHandler(
	node_env_.get(), [this](node::Environment* env, int exit_code) {
		// Destroy node platform.
		node_env_stopped_ = true;
		ParentPort::GetInstance()->Close();
		js_env_->DestroyMicrotasksRunner();
		GetRemote().reset();
		receiver_.ResetWithReason(exit_code, "process_exit_termination");
		node::DefaultProcessExitHandler(env, exit_code);
	});

六步顺序有意义:标记 node_env_stopped_(让析构别再 node::Stop);关消息管道(要退出了,没人处理在飞的消息);销毁微任务执行器;断开 NodeServiceClient;ResetWithReason(exit_code, "process_exit_termination");真正退出。第五步是整个生命周期里最重要的设计:它把"Node 环境退出"变成一条 mojo 断开通知,附带退出码和原因,browser 不必等 waitpid、不必轮询就知道子进程退出了、退出码是多少。原因字符串还区分"正常退出"与"管道意外断开"——只有带 "process_exit_termination" 的断开才走 HandleTermination。

process.SetHidden("_serviceStartupScript", ...)(:216-219) 把入口脚本路径传下去,由 lib/utility/init.ts:8-9 读出并 process.argv.splice(1, 0, entryScript)。用隐藏值而不是塞进 params->args:脚本路径和用户参数是两回事,混在 args 里会让 argv 构造逻辑变复杂。

V8FatalErrorCallback:先报告,再崩溃(:50-66)。

void V8FatalErrorCallback(const char* location, const char* message) {
	if (GetRemote().is_bound() && GetRemote().is_connected()) {
	auto* isolate = v8::Isolate::TryGetCurrent();
	std::ostringstream outstream;
	node::GetNodeReport(isolate, message, location,
						v8::Local<v8::Object>() /* error */, outstream);
	GetRemote()->OnV8FatalError(location, outstream.str());
	}
	electron::crash_keys::SetCrashKey("electron.v8-fatal.message", message);
	electron::crash_keys::SetCrashKey("electron.v8-fatal.location", location);
	volatile int* zero = nullptr;
	*zero = 0;  // NOLINT(clang-analyzer-core.NullDereference)
}

V8 的 fatal error(OOM、CHECK 失败)默认 abort(),产生 SIGABRT。这个 handler 做三件事再崩:用 GetNodeReport 生成诊断报告发给 browser(变成 UtilityProcess 的 'error' 事件);把 location/message 写进 crash key,让 minidump 带上这两个字符串;故意空指针解引用。第三步看似荒谬但必要:SIGABRT 在多数平台上被用于正常中止,crashpad 默认不当崩溃上报,而空指针写产生 SIGSEGV 一定会被抓住;用 volatile 写而不是 std::raise(SIGSEGV),因为编译器可能把 raise 优化掉或当成"不会返回"而改变代码布局。这是 Electron 里少见的"故意崩溃"代码(另一处是 process.crash()),它说明一个现实:在崩溃报告这件事上,"怎么死"比"死了"更重要。

16.4.5 ParentPort:一个手写的 worker_threads 端口

parent_port.cc:49-54(176 行)实现 process.parentPort,一个 cppgc 管理的 gin::Wrappable,同时是 mojo::MessageReceiver。

单例 + 延迟创建(:34-42):static base::NoDestructor<cppgc::Persistent<ParentPort>> 配一个 MakeGarbageCollected 的 lambda 初始化器,是"进程级单例 + 延迟构造"的标准写法。Persistent 保证对象不被 GC——否则 JS 侧没人引用时它会消失,而 process.parentPort 还指着它。

Initialize:paused 的 connector(:47-57)。

	connector_ = std::make_unique<mojo::Connector>(
	port_.TakeHandleToEntangleWithEmbedder(),
	mojo::Connector::SINGLE_THREADED_SEND,
	base::SingleThreadTaskRunner::GetCurrentDefault());
	connector_->PauseIncomingMethodCallProcessing();
	connector_->set_incoming_receiver(this);

PauseIncomingMethodCallProcessing() 让 connector 把收到的消息留在管道里不派发,直到 ResumeIncomingMethodCallProcessing()。Node 的 worker_threads 里 parentPort 开始时也是暂停的:主线程在子线程注册 message 监听器之前发的消息不能丢。Electron 用 mojo 的 pause/resume 实现同样语义,而且更彻底——消息连读都不读,留在管道里(背压在 mojo 上,不在 JS 堆里)。

PostMessage(:59-78):

	v8::Local<v8::Value> message_value = v8::Undefined(isolate);
	args->GetNext(&message_value);
	blink::TransferableMessage transferable_message;
	if (!electron::SerializeV8Value(isolate, message_value,
									&transferable_message)) {
	// SerializeV8Value sets an exception.
	return;
	}
	mojo::Message mojo_message =
		blink::mojom::TransferableMessage::WrapAsMessage(
			std::move(transferable_message));
	connector_->Accept(&mojo_message);

三个细节:postMessage() 无参时发送 undefined(GetNext 不改 message_value,不抛错),和 Node 一致、与浏览器不同;blink::TransferableMessage 带来结构化克隆 + transferable 支持;WrapAsMessage 把消息变成一段字节流再 Accept。SerializeV8Value 失败时已经抛了异常,直接 return。

Accept:接收 + 派发为 message(:101-126)。

	if (!blink::mojom::TransferableMessage::DeserializeFromMessage(
		std::move(*mojo_message), &message)) return false;
	if (!MessagePort::EntanglePorts(isolate, std::move(message.ports),
								&wrapped_ports)) return false;
	auto event = gin::DataObjectBuilder(isolate)
				.Set("data", electron::DeserializeV8Value(isolate, message))
				.Set("ports", wrapped_ports)
				.Build();
	gin_helper::EmitEvent(isolate, self, "message", event);

事件对象是 { data, ports },和 Node worker_threads 的 MessageEvent 一致(浏览器的是 { data, ports, source, origin, lastEventId })。

Close 的借还协议(:80-87):

	port_.GiveDisentangledHandle(connector_->PassMessagePipe());
	connector_ = nullptr;
	port_.Reset();
	connector_closed_ = true;

Connector 从 MessagePortDescriptor 那里"借"了 handle(TakeHandleToEntangleWithEmbedder),销毁前必须"还"回去(GiveDisentangledHandle),否则 Reset() 里的 DCHECK 会炸。browser 侧 CloseConnectorPort(:399-408)是配对的另一半,连注释也各写了一遍——GiveDisentangledHandle() 把无效 handle 换成一个 dangling 的,所以即使 connector 的 pipe 已经没了,port 仍然会被 reset。同一个协议在两端各写一遍,因为 browser 和 utility 是两个不同的编译目标,不能共享实现;两边注释还略有差异,说明它们是被不同 bug 逼出来的。

16.4.6 utility_init:把入口脚本跑起来

lib/utility/init.ts:8-17(67 行):

const entryScript: string = v8Util.getHiddenValue(process, '_serviceStartupScript');
process.argv.splice(1, 0, entryScript);
// `stream/web` is required on first use rather than at startup: it evaluates
// all of Node's WHATWG streams.
v8Util.setHiddenValue(global, 'isReadableStream',
	(val: unknown) => val instanceof (require('stream/web')).ReadableStream);
v8Util.setHiddenValue(global, 'isLanguageModel',
	(val: unknown) => val instanceof LanguageModelUtility);
v8Util.setHiddenValue(global, 'isLanguageModelClass',
	(val: any) => Object.is(val, LanguageModelUtility) || val?.prototype instanceof LanguageModelUtility || false);
require('@electron/internal/common/init');
process._linkedBinding('electron_browser_event_emitter').setEventEmitterPrototype(EventEmitter.prototype);

三个 isXxx 谓词是给 C++ 用的类型判断函数(utility_ai_language_model.cc:149-151):C++ 要判断一个 JS 值是不是 ReadableStream/LanguageModel,但 C++ 侧没有这些类的类型信息(前者是 Node 的类,后者是 Electron 的 JS 类),所以让 JS 提供谓词、C++ 通过隐藏值取出来调用。stream/web 延迟 require 是因为它会求值所有 WHATWG streams,启动时做会拖慢每个 utility,而大部分 utility 根本不用 AI。

setEventEmitterPrototype 把 Electron 的 C++ EventEmitter 基类原型设成 Node 的,这样 ParentPort 能用真正的 Node 实现(包括 newListener/removeListener)。

process.parentPort 的定义: process._linkedBinding('electron_utility_parent_port').createParentPort(),然后用 Object.defineProperty(process, 'parentPort', { enumerable: true, writable: false, value: parentPort }) 钉死。createParentPort 对应 ParentPort::Create(:128-135),那里要手工建一次对象模板:if (data->GetObjectTemplate(&kWrapperInfo).IsEmpty()) GetConstructor(...)——模板平时是第一次 new 时惰性创建的,但 ParentPort 不允许 new(抛 "Illegal constructor"),这个触发点永远不会发生。

引用计数式启停:

// Based on third_party/electron_node/lib/internal/worker/io.js
parentPort.on('newListener', (name: string) => {
	if (name === 'message' && parentPort.listenerCount('message') === 0) {
	parentPort.start();
	}
});
parentPort.on('removeListener', (name: string) => {
	if (name === 'message' && parentPort.listenerCount('message') === 0) {
	parentPort.pause();
	}
});

注释直说抄自 Node 的 worker_threads。newListener 在监听器被添加之前触发,所以此时 listenerCount('message') 还是 0——正是"这是第一个"的判据。第一个加入时 start(),最后一个移除时 pause()。

runEntryPointWithESMLoader 而非 require,是为了支持 ESM 入口(.mjs 或 type: "module"),ESM loader 对 CJS 有回退。第三个参数 Object.create(null) 是 import attributes——传无原型空对象而不是 undefined,因为 Node 内部对两者处理不同。catch 里用 internalBinding('errors').triggerUncaughtException(err) 而不是直接 throw,是为了让 process.on('uncaughtException') 有机会处理(从 async 函数里 throw 会变成 unhandled rejection)。

这三十行合起来,把 utility 变成了"几乎和 Node 一样"的运行时:有 process.argv、parentPort、ESM、完整 EventEmitter、process.type === 'utility'、require('electron'),唯一缺的是 process.send 和 cluster。

16.4.7 同一个进程里的其他 service

utility 里不只有 Node。ElectronContentUtilityClient(163 行)用 mojo::ServiceFactory 注册了六个主线程服务:RunWindowsIconReader、RunWindowsUtility、RunPrintCompositor、两个打印后端 host(sandboxed / unsandboxed)、RunPrintingService,另加一个 IO 线程的 RunProxyResolver,最后才是 RunNodeService。

这解释了 OnServiceProcessTerminatedNormally 里那句 info.IsService<node::mojom::NodeService>():同一进程里可能有多个 service,观察者收到所有 service 的事件,必须按类型过滤。

也解释了为什么 utility 的进程模型和 worker 完全不同:worker 是"Blink 线程 + Node 环境",utility 是"Chromium service 宿主 + 一堆 mojo 服务",Node 只是其中之一。从 Chromium 的角度看,NodeService 和 PrintCompositor 没有本质区别——都是 ServiceFactory 里的一个工厂函数。所以"utility 能同时干打印和跑 JS"并不奇怪:它本来就是"杂活进程"。

ExposeInterfacesToBrowser(:114-132)里还有一段 Windows 提权处理:utility_process_running_elevated_ 为真时只暴露需要提权的 Mojo 接口,不暴露 PdfToEmfConverterFactory 这种普通接口——提权进程不该有普通进程的全部能力。"先探测、再决定暴露什么"在 Chromium 的 utility client 里是标准模式。

16.5 四条通路对照

frame专用 workerservice workerutility process
控制面mojom::ElectronApiIPC(associated)无mojom::ElectronApiIPC(associated)node::mojom::NodeService
反向通道mojom::ElectronRenderer无mojom::ElectronRenderernode::mojom::NodeServiceClient
数据面同上(SerializedValue)无同上MessagePortDescriptor + mojo::Connector
序列化Structured Clone—Structured CloneStructured Clone(TransferableMessage)
transferablepostMessage 支持—Send 不支持支持(MessagePortMain)
同步消息sendSync—MessageSync无
browser 侧接收者ipcMain / webContents.ipc / frame.ipc—serviceWorker.ipcchild.on('message')
渲染侧发送者ipcRenderer—preload realm 的 ipcRendererprocess.parentPort
关联宿主RenderFrameHost—ServiceWorkerVersionBaseInfoServiceProcessHost

几条值得展开:

"关联"(associated)的含义。 frame 和 SW 的 ElectronApiIPC 都是 associated interface:它们的消息和同一 channel 上其他接口的消息保持顺序。对 frame 来说那个"其他接口"是 content.mojom.Frame(导航、输入);对 SW 来说 ServiceWorkerHost(install/activate、fetch 事件)。utility 的 NodeService 不是 associated——它没有"其他接口"需要保序。

utility 的数据面是唯一原生支持 transfer 的。 frame 和 SW 的 Message/Invoke 只传 SerializedValue(纯字节),只有 ReceivePostMessage 带 ports;utility 的 postMessage 从一开始就用 TransferableMessage,因为 API 是照 worker_threads 设计的。

但注意:ServiceWorkerMain 有 ipc.postMessage(IpcMainServiceWorker 继承自 IpcMainImpl),可渲染侧 ServiceWorkerData::ReceivePostMessage 是 NOTIMPLEMENTED()。SW 的 ipc.postMessage 是一条走不通的路——browser 侧发出,到 SW 侧被丢弃。

同步消息只有 frame 和 SW 有。 SW 的 MessageSync(electron_api_sw_ipc_handler_impl.cc:137-156)调的还是 ServiceWorkerMessage,只是 sync=true,于是 AddReturnValue(context, event) 会给 event 装 returnValue setter(第 14 章:sendSync 的"发送"发生在给 returnValue 赋值那一刻)。ipcRenderer.sendSync 在 SW 里可用这件事文档没提,它能工作是因为 SW preload 的 ipcRenderer 和 frame 是同一份 C++ 实现(EmitterMethods),只是 transport 不同。

16.6 五种 preload 对照

主 frame preload子 frame preloadsandboxed preloadSW preloadutility 入口
触发ReadyToCommitNavigation同左 + nodeIntegrationInSubFrames同主 frameSW 脚本求值前utilityProcess.fork()
执行环境页面 isolated world子 frame isolated world页面 isolated worldShadowRealmNode 主 context
bundlerenderer_init同左isolated_bundle无(直接执行源码)utility_init
require('electron')完整完整受限受限(过滤 renderer-only)完整(electron/utility)
Node 全局有(nodeIntegration)有无无有
ipcRenderer有有有有无(用 parentPort)
contextBridge有有有有无

三处容易搞错的:

一,SW preload 用 Flavor::kServiceWorker 而非 kRenderer。 CreateElectronModule 里 if (kModules[i].renderer_only && flavor != Flavor::kRenderer) continue;——SW preload 里 require('electron').webFrame 是 undefined。合理(SW 没 frame),但一个 preload 同时注册给 frame 和 SW 时就得自己判断。

二,SW preload 不加载任何 bundle。 frame 的 preload 前面还有 renderer_init 或 isolated_bundle 打底(提供 require、process、模块系统),SW 的这些全是 C++ 手工造的。所以 SW preload 可用的 API 集合是 frame preload 的子集,且这个子集硬编码在 C++ 里。

三,utility 没有 preload。 直接跑入口脚本,中间没有注入环节:没有 contextBridge(用不上),没有 ipcRenderer(用 parentPort)。

16.7 常见误解

"nodeIntegrationInWorker 可以在 sandbox: true 下用。" 不能。sandbox 显式给了就用它(web_contents_preferences.cc:90-97),而 worker 里建不建 Node 取决于 WorkerHasNodeIntegration 读的 WorkerSettings;sandbox: true 的进程用 ElectronSandboxedRendererClient,它根本没重写 worker 钩子。更准确的说法是:此时 WorkerSettings 里有 nodeIntegrationInWorker 这个值,但没人生效。

"service worker 里可以用 Node。" 不能。WorkerHasNodeIntegration 第一个判断就排除了 IsServiceWorkerGlobalScope()。SW 里能用的只有 preload realm 里那些:受限的 require、手工构造的 process、ipcRenderer。没有 fs、path、child_process。

"worker 里有 ipcRenderer。" 没有。worker_init 不加载 binding,common/init 不给 worker 建 electron 别名;强行加载还会走进 IPCServiceWorker 并踩到错误的 embedder data。

"ipcMain.handle 能收到 SW 的 invoke。" 不能。CollectServiceWorkerTargets 不追加 registry.ipc_main,而 frame 的 CollectFrameTargets 会。SW 的 invoke 必须用 serviceWorker.ipc.handle。

"utilityProcess 可以访问 DOM。" 不能。没有 Blink、没有 WebContents、没有 BrowserWindow。require('electron') 在 utility 里只给不依赖 UI 的模块。

"startTask 是可选的。" 语法上可选,语义上常必需。SW 空闲会被回收,send() 在 worker 没跑时静默失败。要保证一次交互完成,要么先 startTask(),要么用 startWorkerForScope()。不调 end() 则 worker 永不回收。

"utilityProcess.fork 的 session 只影响 cookie。" 不止。给了 session 走 CreateURLLoaderFactoryBuilder(),工厂外面包了 ProxyingURLLoaderFactory,webRequest 才能拦截;不给则直接建工厂,不经过 webRequest。

"process.type 在 worker 里是 'renderer'。" 不是。NodeBindings::ProcessType()(:1055-1066)对 kWorker 返回 "worker"、kUtility 返回 "utility";SW preload 里是 "service-worker"(不在那个 switch 里,是手工设的)。五个可能值:browser/renderer/worker/utility/service-worker。

16.8 资源模型与选择

专用 worker:一个 isolate + 一个 environment + 一个 uv loop + 一个轮询线程。 开 nodeIntegrationInWorker 后每个 worker 都要走 InitializeNewEnvironment(InitializeContext、CreateEnvironment、LoadEnvironment、PrepareEmbedThread、StartPolling),成本在几十毫秒量级,而且每个 worker 一份——Blink 不复用专用 worker 线程。不开 Node 的话成本低一个数量级。所以这是个全局决策:对所有 worker 生效,没有 per-worker 开关。

worklet:几乎零边际成本,但有污染风险。 池化线程 + 共享 environment,第二个 worklet 只做五次 Set 加一次 AssignToContext。代价是所有 worklet 共享同一个 process/require/Buffer,任何一个的 JS 都能污染其他所有。这也是 RendererClientBase::WorkerScriptReadyForEvaluationOnWorkerThread(renderer_client_base.cc:624-633)跳过 worklet 的原因:

	// Worklets can share a thread and isolate (via WorkletThreadHolder), so the
	// per-thread OOM state would be prematurely removed when the first worklet
	// is destroyed. Skip worklets for now; can be revisited with ref-counting.
	if (blink::ExecutionContext::From(context)->IsWorkletGlobalScope())
	return;

OOM 栈追踪的注册是 per-thread 的,第一个 worklet 销毁时会注销,同线程上还活着的其他 worklet 就失去 OOM 栈信息。代码选择"worklet 干脆不注册",注释说以后可以用引用计数解决——一个已知的、被接受的缺陷。

service worker:每次启动都要序列化 startup data。 GetServiceWorkerStartupData(electron_browser_client.cc:856-874)在每次 SW 启动时被调用,注释写着 "this runs on every service worker start"。renderer_startup_data::Build 会读 asar 里的 preload 文件、读代码缓存(ScopedAllowBlockingForElectron 说明是阻塞 I/O),再序列化成 BigBuffer。SW 频繁启停(idle 回收后再来一个 fetch)时这个成本会反复付。

所以那句短路判断很重要:没注册 SW preload 就直接返回 nullopt,省掉所有 I/O——没有 SW preload 的应用不为这个特性付任何成本。反过来,"要不要给 SW 注册 preload"是个影响面很大的决策:注册了才有 IPC 通道。

utility process:一个进程一份 isolate + 一个完整 Node 环境 + 一个 mojo 服务宿主。 最重的选择。ServiceProcessHost::Launch(进程创建、sandbox 初始化)、NodeService::Initialize(isolate、environment、utility_init)、URL loader factory 创建,全都要付。

但它也最"干净":没有 Blink、没有线程复用、没有 preload realm,生命周期只有一个方向(创建 → 运行 → 退出)。所以适合重活:跑完整 Node 服务、CPU 密集计算、托管第三方库。代价是进程间通信只能 postMessage(结构化克隆),没有共享内存(除非用 SharedArrayBuffer 走 transfer)。

需求选择原因
后台跑 JS,不需要 Node专用 worker最轻,同进程,零 IPC 成本
需要 fs/net,且与页面数据紧密相关专用 worker + nodeIntegrationInWorker但会把整个 renderer 拉出 sandbox
页面卸载后仍要运行service worker唯一"页面关了还能活"的环境
需要拦截网络请求service workerfetch 事件是核心能力
长期存在的 Node 服务utility process独立进程,崩溃不影响主进程
需要原生模块utility processworker 里 process.dlopen 不是线程安全的
处理音频AudioWorklet实时线程,不能阻塞
需要 UI都不行四种环境都没有 Blink 的渲染能力

最后一行值得强调:这四种环境没有一个能画像素。 它们能计算、能 I/O、能通信,但任何涉及 document、window、canvas 的代码都跑不了。这是"没有 frame"最直接的后果。

16.9 小结

四条路的形状完全不同:

  • 专用 worker 最简单:一个 TLS 里的 observer、一个自建 uv loop、一个 worker_init bundle。能力边界很清楚——有 Node,没 IPC。
  • worklet 最别扭:线程被池化,Node 不能重建,于是环境被共享、全局对象靠手工搬运、销毁顺序靠注释维持。服务的场景很小,代码复杂度最高。
  • service worker 最完整:browser 侧有 ServiceWorkerMain 和 ipc,渲染侧有 ServiceWorkerData 和 ShadowRealm preload,中间有两条方向的 mojom 通道。复杂度不在单点,而在"三方协作"——content 的生命周期、Blink 的 realm、Electron 的 preload 必须对齐。
  • utility process 最重也最规整:一个 Chromium service、一个 Node 环境、一条 MessagePort、一个 parentPort。每个环节都有明确对应物,没有"借用"和"回填"。

四条路共享的只有一件事:它们都在回答"没有 frame 的时候,Electron 的那些东西挂在哪"。 而四个答案各不相同,因为 Chromium 给这四种环境提供的挂载点本来就不同:worker 有 WorkerSettings,worklet 有 WorkletGlobalScope,service worker 有 WebServiceWorkerContextProxy,utility 有 ServiceProcessHost。

如果只带走一句话:Electron 的"多进程"不是统一设计,而是 Chromium 已有的四套宿主机制,各自被塞进了一个 Node 或一个 preload。 理解这一点之后,那些看起来奇怪的行为——ipcMain 收不到 SW 的消息、worker 里没有 ipcRenderer、utility 的 webRequest 要开 session 才有——都不再是 bug,而是"缝合位置"的直接后果。

下一章换方向:这些进程都要联网,而 Electron 的网络栈是整个框架里被改造得最深的一块——从 session 到 net,从 protocol 到 webRequest,Chromium 的 network service 在这里被切开了好几个口子。

16.10 本章源码落点索引

下列位置全部来自本仓库源码树,按实现层归集;每个 路径:行号 指向该文件中与本章论述对应的声明或实现行,可逐条复核。

  • 渲染进程 C++ 层:electron_sandboxed_renderer_client.h:14 web_worker_observer.h:15 electron_renderer_client.h:15 renderer_client_base.h:19 service_worker_data.h:24 preload_environment.h:14 electron_extensions_renderer_client.cc:14 electron_extensions_renderer_client.h:11
  • 浏览器进程 C++ 层:electron_api_service_worker_context.h:22 electron_api_service_worker_main.h:27 electron_api_utility_process.h:34 javascript_environment.cc:43 javascript_environment.h:16 electron_api_session.cc:136 electron_api_session.h:29 save_page_handler.cc:15
  •  save_page_handler.h:15 electron_api_ipc_handler_impl.cc:24 electron_api_ipc_handler_impl.h:18 electron_api_sw_ipc_handler_impl.h:18 electron_web_contents_utility_handler_impl.cc:23 electron_web_contents_utility_handler_impl.h:15 login_handler.cc:30 login_handler.h:13
  • API 文档与类型:ipc-renderer.md:2 service-worker-main.md:5 service-workers.md:5 ipc-main-service-worker-invoke-event.md:3 ipc-main-service-worker-event.md:3 ipc-renderer-event.md:3 service-worker-info.md:3 utility-process.md:7
  •  environment-variables.md:31 docs/api/local-ai-handler.md:5 session.md:5
  • JS 门面与运行时:service-worker-main.ts:3 ipc-renderer-internal-utils.ts:3 ipc-renderer-internal.ts:1 local-ai-handler.ts:3
  • shell 其余实现:service_worker_converter.cc:12 service_worker_converter.h:14 node_bindings.h:27 node_bindings_linux.cc:11 node_bindings_linux.h:12 node_bindings_mac.cc:15 node_bindings_mac.h:12 node_bindings_win.cc:13
  •  node_bindings_win.h:12
  • 其他相关位置:api-ipc-renderer.spec.ts:9 api-service-worker-main.spec.ts:13 api-service-workers.spec.ts:13 api-utility-process.spec.ts:20 electron-versioning.md:262 docs/tutorial/local-ai-handler.md:2 sandbox.md:29 tutorial-3-preload.md:2
  • 接口契约层:electron_api_environment.cc:11
  • spec 与测试:utility-process-helpers.ts:10