《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 拆开看,它提供四样东西:
- 一个
WebLocalFrame/WebView,即"这棵 DOM 树属于哪个视口"; - 一个
Document,即"这棵树"; - 一个
WebFrameWidget+ui::Compositor,即"这棵树怎么变成像素"; - 一个
content.mojom.Frame关联通道,即"这个 frame 怎么和 browser 说话"。
worker 有 1 的一半(有 ExecutionContext 但没有 WebLocalFrame)、没有 2、没有 3、没有 4。service worker 更彻底:它连"哪个页面"都不知道,生命周期由 browser 的 ServiceWorkerContextWrapper 管理,可以在一万个标签页都关掉之后继续活着。utility process 四样全无。
| 执行环境 | 所在进程 | 所在线程 | Blink GlobalScope | Document | Node 环境 | require('electron') | IPC 出口 |
|---|---|---|---|---|---|---|---|
| 主 frame | renderer | 主线程 | 无(LocalDOMWindow) | 有 | 可选 | 有 | ipcRenderer |
| 专用 worker | renderer(与页面同进程) | WorkerThread | DedicatedWorkerGlobalScope | 无 | 可选 | 无 | 无 |
| worklet | renderer | WorkletThreadHolder 池化线程 | AudioWorkletGlobalScope 等 | 无 | 可选 | 无 | 无 |
| service worker | 独立 renderer 进程(无 WebContents) | WorkerThread | ServiceWorkerGlobalScope | 无 | 无 | 有(preload realm 内) | ipcRenderer(内部实例) |
| utility process | utility | 主线程(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 里要不要建 Node | electron_renderer_client.cc:241 | worker 脚本即将求值 | WorkerSettings::NodeIntegrationInWorker() |
| 进程要不要 sandbox | web_contents_preferences.cc:93-97 | 渲染进程启动前 | nodeIntegration || nodeIntegrationInWorker |
| 用哪个 RendererClient | electron_main_delegate.cc:428 | 进程初始化 | 命令行有没有 --no-sandbox |
| SW 的 preload 注入到哪 | preload_realm_context.cc:262 | SW 脚本即将求值 | 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);
}
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())。SetUpIsolate(isolate)—— 进程级 Node 初始化,一个 isolate 上只能成功一次(allocator shim 只加载一次),这是 worklet 复用问题的根源。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 里 |
sandboxed | true(硬编码) | frame 里来自 webPreferences |
contextIsolated | true(硬编码) | 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));
| frame | service 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 互相唤醒。
| worker | utility | |
|---|---|---|
| 主 loop | Blink 的 message loop | Node 的 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 | 专用 worker | service worker | utility process | |
|---|---|---|---|---|
| 控制面 | mojom::ElectronApiIPC(associated) | 无 | mojom::ElectronApiIPC(associated) | node::mojom::NodeService |
| 反向通道 | mojom::ElectronRenderer | 无 | mojom::ElectronRenderer | node::mojom::NodeServiceClient |
| 数据面 | 同上(SerializedValue) | 无 | 同上 | MessagePortDescriptor + mojo::Connector |
| 序列化 | Structured Clone | — | Structured Clone | Structured Clone(TransferableMessage) |
| transferable | postMessage 支持 | — | Send 不支持 | 支持(MessagePortMain) |
| 同步消息 | sendSync | — | MessageSync | 无 |
| browser 侧接收者 | ipcMain / webContents.ipc / frame.ipc | — | serviceWorker.ipc | child.on('message') |
| 渲染侧发送者 | ipcRenderer | — | preload realm 的 ipcRenderer | process.parentPort |
| 关联宿主 | RenderFrameHost | — | ServiceWorkerVersionBaseInfo | ServiceProcessHost |
几条值得展开:
"关联"(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 preload | sandboxed preload | SW preload | utility 入口 | |
|---|---|---|---|---|---|
| 触发 | ReadyToCommitNavigation | 同左 + nodeIntegrationInSubFrames | 同主 frame | SW 脚本求值前 | utilityProcess.fork() |
| 执行环境 | 页面 isolated world | 子 frame isolated world | 页面 isolated world | ShadowRealm | Node 主 context |
| bundle | renderer_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 worker | fetch 事件是核心能力 |
| 长期存在的 Node 服务 | utility process | 独立进程,崩溃不影响主进程 |
| 需要原生模块 | utility process | worker 里 process.dlopen 不是线程安全的 |
| 处理音频 | AudioWorklet | 实时线程,不能阻塞 |
| 需要 UI | 都不行 | 四种环境都没有 Blink 的渲染能力 |
最后一行值得强调:这四种环境没有一个能画像素。 它们能计算、能 I/O、能通信,但任何涉及 document、window、canvas 的代码都跑不了。这是"没有 frame"最直接的后果。
16.9 小结
四条路的形状完全不同:
- 专用 worker 最简单:一个 TLS 里的 observer、一个自建 uv loop、一个
worker_initbundle。能力边界很清楚——有 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