前言:一个浏览器为什么需要多个进程?
Chromium 将网页执行放在受沙箱约束的 Renderer 中,由 Browser 管理导航、权限和进程,以隔离网页代码和故障。但职责拆开后,一次操作就需要双方配合:保存网页时,Browser 的保存任务 Job 准备输出文件,Renderer 读取 DOM 和页面资源。
添加图片注释,不超过 140 字(可选)
图 1:两侧淡蓝区域表示进程,淡黄表示输出资源,淡绿表示页面资源。上方请求由保存 Job 发给 RenderFrameImpl,下方状态与摘要沿相反方向返回。
为什么不能直接调用?
同一进程中,对象可以通过指针调用另一个对象的方法;跨进程则不能这样做,因为双方拥有独立的地址空间。
RenderFrameImpl 在 Renderer 中处理目标 Frame;Browser 的 RenderFrameHostImpl 只是宿主侧表示,不是对端对象指针。因此,保存 Job 必须发送请求,让目标 Frame 序列化页面,再返回结果。
| Browser 知道什么 | Renderer 知道什么 |
|---|---|
| 保存哪个页面、准备哪个文件、任务是否结束 | DOM、页面资源、如何生成网页内容 |
| 导航、Frame 树、权限、子进程管理 | Blink / V8、脚本、布局、页面执行 |
独立地址空间阻止了直接调用,却没有消除协作需求。Browser 需要把请求、参数和结果变成可传输的消息——Chromium 使用 Mojo 完成这件事。
一、Mojo 是什么?为什么 Chromium 使用它?
Mojo 是 Chromium 的组件通信基础设施,既支持跨进程,也支持同进程使用。.mojom 声明接口、参数和响应,生成代码负责将调用编码成消息,并在接收侧分发给本地实现对象。
调用路径是:本地代理 → 消息 → 对端本地实现。双方共享接口契约,而不是对象指针。
socket 与 Mojo 分别解决什么?
| socket 提供 | Mojo 补上 |
|---|---|
| 字节与平台句柄传输 | 类型化接口、参数编码、消息验证 |
| 平台 IO 能力 | 端点交付、逻辑路由、响应匹配、断连处理 |
| 底层通信原语 | MessagePipe、DataPipe、SharedBuffer 及跨平台 API |
Mojo 把“调用哪个方法、参数是什么、结果属于哪次请求”变成协议;业务仍负责授权、对象寿命和异步完成条件。
Mojo 方法默认异步。Browser 提交保存请求后,调用便返回,不会同步等待文件写完;保存 Job 在响应回调中处理结果,再决定继续下一个 Frame 或结束任务。等待期间,Browser 仍可处理其他事件。
二、最小实际应用:从 Logger 的手动绑定看懂一次调用
先用只有一个 Log 方法的 Logger 看清接线:声明接口 → 准备实现 → 连接两个端点。暂时把双方放在同一进程,排除 Frame 路由和文件保存的干扰。
添加图片注释,不超过 140 字(可选)
图 2:A 留给调用者,B 交给接收者;端点和业务对象不是同一个东西。
第一步:定义方法
在 sample/logger.mojom 中声明 Log(string message),这个方法没有业务响应:
module sample.mojom;
interface Logger {
Log(string message);
};
输入路径决定生成头文件路径 sample/logger.mojom.h;module sample.mojom 决定命名空间 sample::mojom。
第二步:实现业务,准备 Receiver
#include "base/logging.h"
#include "mojo/public/cpp/bindings/receiver.h"
#include "sample/logger.mojom.h"
class LoggerImpl : public sample::mojom::Logger {
public:
explicit LoggerImpl(
mojo::PendingReceiver<sample::mojom::Logger> receiver)
: receiver_(this, std::move(receiver)) {}
void Log(const std::string& message) override {
LOG(INFO) << message;
}
private:
mojo::Receiver<sample::mojom::Logger> receiver_;
};
LoggerImpl::Log() 执行业务;receiver_(this, …) 指定消息分发给谁。Receiver 不拥有这里的实现对象,所以 this 必须在接收器使用期间有效。
第三步:手动把两端接起来
创建 MessagePipe 两端:A 绑定到调用方 Remote,B 交给 LoggerImpl 的 Receiver。下面只展示接线;消息循环和对象存活条件见本节末尾。
#include "mojo/public/cpp/bindings/remote.h"
#include "mojo/public/cpp/system/message_pipe.h"
#include "sample/logger.mojom.h"
void DemonstrateLogger() {
mojo::MessagePipe pipe;
mojo::Remote<sample::mojom::Logger> logger(
mojo::PendingRemote<sample::mojom::Logger>(
std::move(pipe.handle0), 0));
mojo::PendingReceiver<sample::mojom::Logger> receiver(
std::move(pipe.handle1));
LoggerImpl impl(std::move(receiver));
logger->Log("Hello!");
}
| 代码动作 | 所有权变化 |
|---|---|
| 创建 MessagePipe | 当前作用域持有 A、B 两端 |
| 构造 PendingRemote,再绑定 Remote | A 交给调用端 |
| 构造 PendingReceiver | B 等待交给实现侧 |
| 构造 LoggerImpl | Receiver 消费 B,并以 impl 为分发目标 |
Pending 表示端点尚未绑定,不表示等待响应。PendingRemote(..., 0) 的 0 是已知接口版本;std::move() 本身只是类型转换,消费端点时才发生所有权转移。
用原图再看一次发送与接收
添加图片注释,不超过 140 字(可选)
参考图:端点创建与 PendingReceiver。
添加图片注释,不超过 140 字(可选)
参考图:Remote 提交方法消息,而不是调用远程指针。
添加图片注释,不超过 140 字(可选)
参考图:接收端绑定后,Stub 才能把消息分发到 LoggerImpl。
便捷函数只是把手动步骤封装起来
mojo::Remote<sample::mojom::Logger> logger;
auto receiver = logger.BindNewPipeAndPassReceiver();
LoggerImpl impl(std::move(receiver));
logger->Log("Hello!");
mojo/public/cpp/bindings/remote.h:260,省略校验后的核心逻辑:
MessagePipe pipe;
Bind(PendingRemote<Interface>(std::move(pipe.handle0), 0), task_runner);
return PendingReceiver<Interface>(std::move(pipe.handle1));
BindNewPipeAndPassReceiver:创建逻辑 Pipe,自己绑定 A,把 B 返回给接收者。
运行条件不能省:独立程序需要 Mojo 初始化、任务环境和消息循环。提交 Log() 后立刻退出,可能在分发前销毁对象;测试可用 FlushForTesting() 等待分发,生产代码应按业务响应协调。Flush 不会自动等待方法另起的异步工作。
LoggerImpl 就在当前作用域,B 可以直接交给它。网页保存的实现却在另一个进程的目标 Frame 中:怎样找到它,并把接收端送过去?
三、进入 Chromium 实战:Browser 为什么要向 Renderer 请求接口?
先认识业务:MHTML 不是 Mojo
回到保存网页:MHTML 将 HTML、图片、CSS 等资源打包成一个存档文件,扩展名为 .mhtml / .mht。此时调用方是 Browser 保存 Job,实现方是 RenderFrameImpl;与 Logger 相比,多了输出资源交付和异步结果。本文追踪 MHTML 内核保存路径,不讨论各平台保存框的格式选项。
添加图片注释,不超过 140 字(可选)
图 3:MHTML 是保存业务,Mojo 是请求与结果的运输机制。接线与业务执行是两个阶段。
共同协议:参数、输出资源、异步响应
共同契约是 MhtmlFileWriter::SerializeAsMHTML;=> 声明保存后返回的状态和资源摘要。content/common/download/mhtml_file_writer.mojom:87:
interface MhtmlFileWriter {
SerializeAsMHTML(SerializeAsMHTMLParams params)
=> (MhtmlSaveStatus status,
array<mojo_base.mojom.ByteString> digests_of_uris_to_skip);
};
同文件 :44、:52 的输出与参数结构:
union MhtmlOutputHandle {
mojo_base.mojom.File file_handle;
handle<data_pipe_producer> producer_handle;
};
struct SerializeAsMHTMLParams {
string mhtml_boundary_marker;
bool mhtml_binary_encoding;
bool mhtml_popup_overlay_removal;
array<mojo_base.mojom.ByteString> digests_of_uris_to_skip;
mojo_base.mojom.ByteString salt;
MhtmlOutputHandle output_handle;
};
参数决定怎么保存,output_handle 交付可写资源,=> 定义返回状态和资源摘要。它不是把文件路径发给 Renderer,让它自己任意打开文件。
GN 生成代码,不决定进程归属
添加图片注释,不超过 140 字(可选)
图 4:双方依赖同一契约;对象实例化与端点绑定决定运行位置。
双方要在 C++ 中使用这份协议,先由 mojom target 生成代码。content/common/BUILD.gn:439:
mojom("mojo_bindings") {
visibility = [ "//content/*" ]
disable_variants = true
sources = [
"download/mhtml_file_writer.mojom",
"frame.mojom",
# 其他协议省略
]
}
模板入口是 mojo/public/tools/bindings/mojom.gni:510:GN 展开构建图,构建系统运行 parser / generator 并编译 C++。
| 生成物 | 正文中会用到的职责 |
|---|---|
| .mojom.h / .mojom-forward.h | 类型、接口与前置声明 |
| .mojom.cc | Proxy 发送、Stub 分发、编解码 |
| shared-internal / shared-message-ids | 数据布局、验证结构与方法 ID |
已有生成物位于 out/Arm64SystemWebViewRelease/gen/content/common/download/;源码通过生成目录包含头文件:
#include "content/common/download/mhtml_file_writer.mojom.h"
Browser 与 Renderer 分别在 content/browser/BUILD.gn:209、content/renderer/BUILD.gn:226 依赖 //content/common:mojo_bindings。保存 manager 和 render_frame_impl.cc 分别列入两侧业务 target。多种进程角色代码可能链接到同一库,不能把 GN target 当成运行时进程。
Renderer:先登记接线回调
接收侧由已有的 RenderFrameImpl 实现接口并持有接收器,无需另建 MhtmlFileWriterImpl。content/renderer/render_frame_impl.h:1347:
mojo::AssociatedReceiver<mojom::MhtmlFileWriter>
mhtml_file_writer_receiver_{this};
content/renderer/render_frame_impl.cc:6565,初始化时注册:
GetAssociatedInterfaceRegistry()->AddInterface<mojom::MhtmlFileWriter>(
base::BindRepeating(&RenderFrameImpl::BindMhtmlFileWriter,
base::Unretained(this)));
注册只预留接线入口:收到 MhtmlFileWriter 请求时,调用 BindMhtmlFileWriter。此时尚未接到 Browser 的端点;Unretained(this) 也不延长 Frame 寿命。
Browser:请求接口,然后发送保存任务
Browser 的保存 Job 准备文件,并逐个处理目标 Frame。入口为 content/browser/web_contents/web_contents_impl.cc:7088:
WebContentsImpl::GenerateMHTML
→ MHTMLGenerationManager::SaveMHTML
→ 保存 Job 准备文件并组织 Frame 队列
→ Job::SendToNextRenderFrame
content/browser/download/mhtml_generation_manager.cc:373,核心业务代码:
rfh->GetRemoteAssociatedInterfaces()->GetInterface(&writer_);
writer_.set_disconnect_handler(
base::BindOnce(&Job::OnConnectionError, base::Unretained(this)));
auto params = CreateMojoParams();
params->output_handle =
mojom::MhtmlOutputHandle::NewFileHandle(browser_file_.Duplicate());
writer_->SerializeAsMHTML(
std::move(params),
base::BindOnce(&Job::SerializeAsMHTMLResponse,
weak_factory_.GetWeakPtr()));
GetInterface 发起接口接线,SerializeAsMHTML 提交业务。rfh 选择 Frame,Duplicate() 准备可传输的文件引用,callback 留在 Browser 处理结果。
Renderer:接线函数不执行保存
BindMhtmlFileWriter 接收端点并指定执行序列,不读取 DOM,也不写文件。content/renderer/render_frame_impl.cc:6589:
void RenderFrameImpl::BindMhtmlFileWriter(
mojo::PendingAssociatedReceiver<mojom::MhtmlFileWriter> receiver) {
mhtml_file_writer_receiver_.reset();
mhtml_file_writer_receiver_.Bind(
std::move(receiver), GetTaskRunner(blink::TaskType::kInternalDefault));
}
真正业务在后续消息到达时执行,入口是同文件 :5790:
解包参数
→ 主 Frame 生成 MHTML header
→ WebFrameSerializer::GenerateMHTMLParts
→ OnSerializeMHTMLComplete
→ MHTMLHandleWriterDelegate 写入输出
→ OnWriteMHTMLComplete
→ callback.Run(status, digests)
Browser 在 SerializeAsMHTMLResponse() 收到结果,继续下一个 Frame 或结束任务;换 Frame 时重新请求对应接口,而不是每个调用新建 socket。
还剩一个关键问题:GetInterface 怎样把接收端送进目标 Frame 的 BindMhtmlFileWriter?
四、展开 Chromium 的接线过程:Registry、Provider 和 Bind 各负责什么?
上一节的保存请求已经有了调用端 writer_,但它怎样接到 Renderer 的实现上?接线要解决两件事:把接收端送到正确的 Frame,再接到这个 Frame 的 Receiver。
Browser 的保存 Job 用这一行完成接线(content/browser/download/mhtml_generation_manager.cc:390):
rfh->GetRemoteAssociatedInterfaces()->GetInterface(&writer_);
rfh 是 Browser 中代表目标 Frame 的 RenderFrameHostImpl;writer_ 是调用代理,真正的 RenderFrameImpl 始终留在 Renderer。这里不是取回远程对象,而是接通两端。
添加图片注释,不超过 140 字(可选)
图 5:Browser 递送接收端,Renderer 定位 Frame、查表并绑定;绑定后的业务消息走下方的新接口。
1. Provider 先解决:接收端应该送到哪个 Frame?
Provider 是递送接口请求的入口,不是 MHTML 实现。首次需要时,Browser 借已有 RouteProvider 交付 Provider 的接收端,同时指定目标 FrameToken(content/browser/renderer_host/render_frame_host_impl.cc:RenderFrameHostImpl::GetRemoteAssociatedInterfaces()):
#
GetAgentSchedulingGroup().GetRemoteRouteProvider()->GetRoute(
GetFrameToken(), remote_interfaces.BindNewEndpointAndPassReceiver());
Renderer 将接收端与 FrameToken 一起保存(content/renderer/agent_scheduling_group.cc:421):
associated_interface_provider_receivers_.Add(
this, std::move(receiver), frame_token,
agent_group_scheduler_->DefaultTaskRunner());
此后,从这个 Provider 收到的请求,都能通过接收器上下文找到目标 Frame。Provider 按需建立并缓存,不是每请求一个接口就新建 socket,也不是每次请求都重新传 FrameToken。
2. GetInterface 再解决:把哪一个接收端送过去?
GetInterface(&writer_) 创建 MhtmlFileWriter 的待关联端点对:调用端 A 留在 writer_,接收端 B 交给 Provider(third_party/blink/public/common/associated_interfaces/associated_interface_provider.h:69):
template <typename Interface>
void GetInterface(mojo::AssociatedRemote<Interface>* remote) {
GetInterface(remote->BindNewEndpointAndPassReceiver(GetTaskRunner()));
}
Provider 随后通过已有 Mojo 接口发送“接口名 + B”(third_party/blink/common/associated_interfaces/associated_interface_provider.cc:99):
proxy_->GetAssociatedInterface(
name, mojo::PendingAssociatedReceiver<mojom::AssociatedInterface>(
std::move(handle)));
名字来自生成的 Interface::Name_。这次 Mojo 调用只负责递送新接收端,还没有执行 SerializeAsMHTML。
3. Registry 与 Bind 最后解决:B 应该接到谁?
Renderer 从当前 Provider 接收器取出 FrameToken,找到目标 Frame,再交付名字与端点(content/renderer/agent_scheduling_group.cc:430,正常命中路径):
const auto& frame_token =
associated_interface_provider_receivers_.current_context();
if (auto* listener = GetListener(frame_token)) {
listener->OnAssociatedInterfaceRequest(name, receiver.PassHandle());
}
这个 Frame 的 Registry 在初始化时已经登记了 MhtmlFileWriter 的 binder(content/renderer/render_frame_impl.cc:6565):
GetAssociatedInterfaceRegistry()->AddInterface<mojom::MhtmlFileWriter>(
base::BindRepeating(&RenderFrameImpl::BindMhtmlFileWriter,
base::Unretained(this)));
Registry 就是本地的“接口名 → 回调”表;getter 只返回这个表,AddInterface 只登记回调。请求到达后,OnAssociatedInterfaceRequest() 调用 TryBindInterface(),后者才查表并执行 binder(third_party/blink/common/associated_interfaces/associated_interface_registry.cc:26):
auto it = interfaces_.find(name);
if (it == interfaces_.end())
return false;
it->second.Run(std::move(*handle));
return true;
这里的 binder 是本地 C++ 接线回调,不是 Android Binder。模板适配器把端点转成类型化接收端,再调用下面的函数(content/renderer/render_frame_impl.cc:6589):
void RenderFrameImpl::BindMhtmlFileWriter(
mojo::PendingAssociatedReceiver<mojom::MhtmlFileWriter> receiver) {
mhtml_file_writer_receiver_.reset();
mhtml_file_writer_receiver_.Bind(
std::move(receiver), GetTaskRunner(blink::TaskType::kInternalDefault));
}
Receiver 的成员声明已经把实现指定为当前 Frame(content/renderer/render_frame_impl.h:1347):
mojo::AssociatedReceiver<mojom::MhtmlFileWriter> mhtml_file_writer_receiver_{
this};
Provider 负责送,Registry 负责找,Bind 负责接。接上以后,业务消息才会分发到这个 this 的 SerializeAsMHTML(),不再经过 Registry 查表。
4. 为什么创建的是 Endpoint,而不是新 Pipe?
接线主线已经走完,再看 AssociatedRemote 的特殊之处:它创建的是待关联端点,随后加入已有 Pipe,而不像 Logger 的普通 Remote 那样创建独立 MessagePipe。
添加图片注释,不超过 140 字(可选)
图 6:关联端点经历三个状态:本地待关联 → 接收端随 Provider 消息交付 → 新接口按 interface_id 在同一 Pipe 上通信。这里没有新建独立 MessagePipe。
创建阶段只有待关联状态(mojo/public/cpp/bindings/associated_remote.h:207):
ScopedInterfaceEndpointHandle remote_handle;
ScopedInterfaceEndpointHandle receiver_handle;
ScopedInterfaceEndpointHandle::CreatePairPendingAssociation(
&remote_handle, &receiver_handle);
Bind(PendingAssociatedRemote<Interface>(std::move(remote_handle), 0),
std::move(task_runner));
return PendingAssociatedReceiver<Interface>(std::move(receiver_handle));
发送 B 时,Message::SerializeHandles() 将端点加入消息所属的关联组(mojo/public/cpp/bindings/lib/message.cc:563):
UNSAFE_TODO(handles_fragment->storage()[i]) =
group_controller->AssociateInterface(std::move(handle));
加入关联组,意味着调用端可以发送;对端绑定 Receiver,意味着消息可以分发到实现。GetInterface 返回并不是 Renderer 已完成绑定的同步确认。
至此,Job 可以通过 writer_ 发出保存请求。下一节只追这次业务消息:它如何被编码、送达、执行,再把结果带回来。
五、连接建立以后:一次方法调用如何变成消息,又变回函数?
接线回答了“交给谁”。现在沿 writer_->SerializeAsMHTML(params, callback) 走一圈:Browser 把调用变成消息,Renderer 把消息还原为本地调用,结果再沿原请求返回。
添加图片注释,不超过 140 字(可选)
图 7:左侧把调用变成消息,右侧把消息还原为本地调用。
1. Browser:参数发出去,callback 留下来
writer_ 的 operator-> 返回生成的 Proxy,也就是调用代理。Proxy 不执行保存:它编码参数,并为这个异步请求准备本地响应处理器。
下面是按当前生成模板展开的教学等价代码,不是构建目录中生成文件的直接摘录;EncodeRequest 等名称表示被省略的具体编码步骤(mojo/public/tools/bindings/generators/cpp_templates/interface_definition.tmpl:329、:357):
void SerializeAsMHTML(params, callback) {
auto message = EncodeRequest(params, kFlagExpectsResponse);
auto responder = MakeForwardToCallback(std::move(callback));
SendMojoMessage(*receiver_, message, std::move(responder));
}
参数与资源进入消息,callback 不进入消息。InterfaceEndpointClient 为请求分配 request_id,并用它保存本地 responder(mojo/public/cpp/bindings/lib/interface_endpoint_client.cc:668、:702):
uint64_t request_id = next_request_id_++;
if (request_id == 0) {
request_id = next_request_id_++;
}
message->set_request_id(request_id);
base::AutoLock lock(async_responders_lock_);
async_responders_.emplace(
request_id, PendingAsyncResponse{message_name, std::move(responder)});
随后,Bindings 的 Router 标出接口实例,Connector 把消息提交给 MessagePipe(mojo/public/cpp/bindings/lib/multiplex_router.cc:156;mojo/public/cpp/bindings/lib/connector.cc:356):
message->set_interface_id(id_);
return router_->connector_.Accept(message);
MojoResult rv =
WriteMessageNew(message_pipe_.get(), message->TakeMojoMessage(),
MOJO_WRITE_MESSAGE_FLAG_NONE);
先暂时把底层看成运输层:它把消息带到 Renderer,但不会替 Renderer 执行保存。
2. Renderer:Stub 解码,最后调用本地实现
第四章的 Bind 已准备好接收链与执行序列。消息到达后,Bindings 按接口实例分流、验证消息,再由生成的 Stub 按方法 ID 解码参数并调用实现。
以下同样是教学展开,依据当前模板的 AcceptWithResponder() 分支(mojo/public/tools/bindings/generators/cpp_templates/interface_definition.tmpl:579):
case SerializeAsMHTML_method_id:
auto params = DecodeAndValidate(message);
auto callback = ProxyToResponder::CreateCallback(message, responder);
impl->SerializeAsMHTML(std::move(params), std::move(callback));
最后一行才是普通 C++ 业务调用,执行位置在 Renderer。这里的 impl 是 Receiver 绑定的 RenderFrameImpl;这里的 callback 也是 Renderer 本地创建的响应发送器,并不是 Browser 那个函数对象。
3. 返回结果:同一个 request_id 找回 Browser callback
添加图片注释,不超过 140 字(可选)
图 8:两侧各自持有本地 callback / responder,用 request_id 对上同一次调用。
Renderer 完成写入后运行本地响应 callback(content/renderer/render_frame_impl.cc:5878):
std::move(callback).Run(save_status, std::move(digests_of_new_parts));
生成的 ProxyToResponder 编码响应,带回原请求的 ID(mojo/public/tools/bindings/generators/cpp_templates/interface_definition.tmpl:495):
message.set_request_id(request_id_);
message.set_trace_nonce(trace_nonce_);
::mojo::internal::SendMojoMessage(*responder_, message);
Browser 按 request_id 找到本地 responder,校验响应对应的方法,再解码并执行 Job 原先提供的 callback。这是原请求的响应,不需要另外建立一个“通知 Browser”的接口。断连则进入 Job::OnConnectionError(),而不是伪装成成功响应。
4. 回看标识与顺序:各自只解决一个问题
| 标识 | 解决的问题 |
|---|---|
| FrameToken | Provider 请求属于哪个 Frame |
| Interface::Name_ | 接线时选择哪个 binder |
| interface_id | 同一 Pipe 上选择哪个接口实例 |
| 方法 ID / message name | Stub 应解码并调用哪个方法 |
| request_id | 响应对应哪一次请求 |
添加图片注释,不超过 140 字(可选)
参考图:关联接口在同一 MessagePipe 上按 interface_id 分流。Master 指主接口,不是服务发现中心。
同组接口共享消息传输顺序,但先收到,不等于先完成。Job 通过响应与自身状态决定后续步骤,不会因为请求已经发出就认定文件已经写完。
到这里,我们看清了 Bindings 如何完成一次调用;下一节再区分它使用的逻辑 Pipe,与真正跨进程的平台连接。
六、Mojo 技术架构:从类型化调用到逻辑消息端点
上一节把 MessagePipe 当成运输入口,但它是不是一个 socket?先分清三个层次:业务接口定义“说什么”,逻辑 Pipe 连接端点,平台连接才负责跨进程运输。
添加图片注释,不超过 140 字(可选)
图 9:逻辑接口、逻辑 MessagePipe、平台连接是三个层次;只有上层接口需要了解业务方法。
1. 先看分工,再看源码层次
| 层次 | 负责什么 | 在 MHTML 中对应什么 |
|---|---|---|
| 业务接口与 Bindings | 参数编码、验证、方法分发、响应匹配 | MhtmlFileWriter 的 Proxy / Stub |
| 逻辑 MessagePipe | 消息端点与消息交付 | Provider 与关联业务接口所依附的 Pipe |
| 平台连接 | 跨进程字节与平台资源传输 | Linux Channel / socket 等路径 |
同一 Pipe 上的多个接口由 interface_id 区分;不同逻辑 Pipe 则由更底层的路由区分。不能把“一个接口”“一条逻辑 Pipe”“一个 socket”画等号。
添加图片注释,不超过 140 字(可选)
参考图:Mojo 分层。
源码入口依次是 mojo/public/cpp/bindings、mojo/public/cpp/system / mojo/public/c/system、mojo/core / third_party/ipcz,再到平台 Channel。System API 提供统一操作入口,上层不必跟着底层传输实现一起变化。
2. 为什么多个 Pipe 可以共用平台连接?
每条逻辑 Pipe 管理自己的端点和消息关系;跨进程时,底层路由可以让它们复用已有平台连接,而不必为每条 Pipe 单独创建 socket。
添加图片注释,不超过 140 字(可选)
参考图:独立逻辑 Pipe 可以复用平台连接,“一条通道”只是简化示意。
这也解释了 CreateMessagePipe 为什么不直接调用 socketpair。C++ 包装只进入 Mojo 系统 API(mojo/public/cpp/system/message_pipe.h:54):
MojoResult rv = MojoCreateMessagePipe(options, handle0.mutable_value(),
handle1.mutable_value());
若使用 ipcz 后端,创建的是当前节点中的一对 portal(mojo/core/core_ipcz.cc:168):
MojoResult MojoCreateMessagePipeIpcz(
const MojoCreateMessagePipeOptions* options,
MojoHandle* message_pipe_handle0,
MojoHandle* message_pipe_handle1) {
return GetIpczAPI().OpenPortals(GetIpczNode(), IPCZ_NO_FLAGS, nullptr,
message_pipe_handle0, message_pipe_handle1);
}
创建逻辑端点与建立 OS 连接是两件事。端点随后可以经已有连接交付给另一进程,跨进程路由由底层维护。
3. MessagePipe、DataPipe、SharedBuffer 各用在哪里?
| 对象 | 语义 | 典型用途 |
|---|---|---|
| MessagePipe | 双向消息,可附带句柄 | 方法请求、响应、接收端交付 |
| DataPipe | 单向字节流,有容量与背压 | 网络响应体、MHTML 的流式输出路径 |
| SharedBuffer | 共享内存,本身不定义业务同步 | 大块共享数据 |
它们是不同的资源语义,不是三种网络协议。MojoHandle 是本进程的 Mojo 资源句柄,Linux fd 是本进程的内核描述符;跨进程交付资源,不能只复制这些本地整数。
4. 原图中的旧 Core,和 ipcz 是什么关系?
有些参考图使用 Node / Port / Channel 来表示旧 Core。它仍适合解释逻辑端点与平台连接的分工,但不能把旧类名直接插入现代 ipcz 调用链。
添加图片注释,不超过 140 字(可选)
参考图:旧 Core 的 Node / Port / Channel 模型;现代 ipcz 对应 Portal / Router / NodeLink。
旧 Core 与 ipcz 是替代后端,不是前后串联的两层。mojo::core::Init() 按所选后端安装 System thunk(mojo/core/embedder/embedder.cc:114):
| 后端 | 初始化与系统入口 | 主要路由概念 |
|---|---|---|
| ipcz | InitializeIpczNodeForProcess / GetMojoIpczImpl | Portal、Router、NodeLink |
| 旧 Core | InitializeCore / GetSystemThunks | Port、Node、NodeChannel |
实际后端仍受构建、feature 与 embedder 配置影响,本文没有观测运行时 flags。接下来沿 Linux 的平台引导与基础 socket 路径向下追,回答逻辑端点最终借用的 OS 连接从哪里来。
七、Linux 底层:最早的连接从哪里来,socket 如何真正传消息?
上一节区分了逻辑 Pipe 与平台连接。现在沿两个问题往下追:连接先怎样建立,建立以后又怎样运输消息与文件引用?
1. 启动时先有 socket,随后才有 Mojo 接口
添加图片注释,不超过 140 字(可选)
图 10:先创建 socketpair 并将一端交给子进程,再由 Send / Accept 引导 Mojo 节点连接、交付初始逻辑端点,随后建立 Frame 接口。初始 Pipe 由 AttachMessagePipe 准备,不是 socket 自动生成的。
Linux 的基础引导路径先创建连通的 Unix socket 两端(mojo/public/cpp/platform/platform_channel.cc:149,略去注释):
int fds[2];
PCHECK(socketpair(AF_UNIX, SOCK_STREAM, 0, fds) == 0);
PCHECK(fcntl(fds[0], F_SETFL, O_NONBLOCK) == 0);
PCHECK(fcntl(fds[1], F_SETFL, O_NONBLOCK) == 0);
*local_endpoint = PlatformHandle(base::ScopedFD(fds[0]));
*remote_endpoint = PlatformHandle(base::ScopedFD(fds[1]));
- AF_UNIX 表示本机 IPC;socketpair 已经连通两端,不需要 TCP 的 listen / accept。
- SOCK_STREAM 提供有序字节流,但不提供应用消息边界。
- O_NONBLOCK 让 IO 在暂时无数据或写满时不阻塞,稍后由事件推进。
Browser 保留一端,另一端经进程启动的继承 / fd remap 交给子进程;普通启动与 zygote 路径的具体交付方式可以不同。
2. Invitation 用平台连接交付初始逻辑端点
socket 只让进程具备运输条件;还要用 Invitation 引导 Mojo 节点连接,并交付最初的 Pipe。
| 父进程 | 子进程 |
|---|---|
| AttachMessagePipe:准备初始逻辑端点 | 恢复启动时交付的平台 endpoint |
| Send:经平台 endpoint 发送 Invitation | Accept:接受 Invitation |
| 保留初始 Pipe 的本地端 | ExtractMessagePipe:取出对应逻辑端点 |
Chromium 的实际发送入口(content/browser/child_process_launcher_helper.cc:420):
mojo::OutgoingInvitation::Send(
std::move(invitation), process.process.Handle(),
mojo_channel_->TakeLocalEndpoint(), process_error_callback_);
子进程由 InitializeMojoIPCChannel() 接受 Invitation 后,提取初始端点(content/child/child_thread_impl.cc:636):
child_process_pipe_for_receiver =
invitation.ExtractMessagePipe(kChildProcessReceiverAttachmentName);
child_process_host_pipe_for_remote =
invitation.ExtractMessagePipe(kChildProcessHostRemoteAttachmentName);
先有 OS 连接,再交付初始 Pipe,随后才建立进程接口、调度组与 Frame Provider。第四章的接口递送建立在这条引导链上,不是凭空从一个未连接端点开始。
3. 连接建立后:逻辑消息向下进入平台传输
添加图片注释,不超过 140 字(可选)
图 11:现代 ipcz 跨进程路径的分层概览。左侧向下提交消息,右侧向上交付业务;图中省略了 trap / watcher 和部分 Bindings 细节,完整调用路线见下文。
在 ipcz 后端,Connector 提交的消息由 System API 交给 portal;已序列化分支通过 Put 提交数据与附带对象(mojo/core/core_ipcz.cc:196):
m->AttachDataPipePortals();
const IpczResult result = GetIpczAPI().Put(
message_pipe_handle, m->data().data(), m->data().size(),
m->handles().data(), m->handles().size(), IPCZ_NO_FLAGS, nullptr);
未序列化的本地消息另有延迟编码分支。远端目标则沿以下链路继续向下;ipcz 维护逻辑路由,Mojo driver / Channel 承接平台 IO。
Router::SendOutboundParcel
→ RemoteRouterLink::AcceptParcel
→ NodeLink::Transmit
→ DriverTransport::Transmit
→ ipcz driver 的 Transmit
→ mojo::core::ipcz_driver::Transport::Transmit
→ Channel::WriteNextIpczMessage
→ ChannelPosix / ChannelLinux
源码入口分别在 third_party/ipcz/src/ipcz/router.cc、remote_router_link.cc、node_link.cc、driver_transport.cc,以及 mojo/core/ipcz_driver/transport.cc、mojo/core/channel.cc。这里没有串入旧 Core 的 NodeChannel。
4. socket 传的是字节流,Channel 负责恢复消息边界
添加图片注释,不超过 140 字(可选)
图 12:recv 的分段不等于消息分段,Channel 累积到完整帧再上交。
一次发送可能被拆成多次读取,多帧也可能一次到达。Channel::OnReadComplete() 累积字节、检查帧头和总长度,完整后才上交;Bindings 消息头再负责接口、方法与响应匹配(mojo/core/channel.cc:1085)。
因此,MessagePipe 的消息边界是 Mojo 维护的,不是 SOCK_STREAM 自带的。
5. 输出文件怎么过去:传资源引用,不传 fd 数值
MHTML 参数还携带输出文件引用。普通字节可以用 send;需要传平台句柄时,Channel 使用 sendmsg,通过 ancillary data 的 SCM_RIGHTS 交付引用。
SocketWrite() 的普通字节路径(mojo/public/cpp/platform/socket_utils_posix.cc:70):
return send(socket, bytes, num_bytes, MSG_NOSIGNAL);
SendmsgWithHandles() 标记附带数据,并由 sendmsg 发送(同文件 :89、:97,两处选段):
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_RIGHTS;
return HANDLE_EINTR(sendmsg(socket, &msg, MSG_NOSIGNAL));
添加图片注释,不超过 140 字(可选)
图 13:SCM_RIGHTS 交付内核资源引用,Renderer 的 fd 编号无需与 Browser 相同。
Duplicate() 先准备输出文件引用,Mojo 将其编码成可交付资源;接收进程获得自己的 fd,引用同一个内核文件资源。传过去的是可用的资源能力,不是 Browser fd 表中的整数。
6. 没写完或没读完怎么办?
- 写入侧:部分写后推进 offset;遇到 EAGAIN / EWOULDBLOCK,保留剩余消息与句柄状态,等待可写事件继续 Flush。
- 读取侧:OnFdReadable() 用 recvmsg 接收字节与 fd,交给 Channel 组帧;读到半帧就继续等待,不提前执行半条业务消息。
对应实现是 mojo/core/channel_posix.cc:275、:336、:353。完整帧再经 Transport / ipcz 路由到本地 portal,由 watcher 唤醒 Connector,最终进入 EndpointClient / Stub;平台 IO 序列与 Receiver 的业务执行序列不同。
以上是基础 socket 路径,不代表所有配置下的 payload 都必须经过 socket:ChannelLinux::Write() 在已启用共享 buffer 且条件满足时可使用共享内存与通知,否则回退 ChannelPosix(mojo/core/channel_linux.cc:571)。
我们已追到 Linux 的字节与资源传输。下一节回到 MHTML,把这些层拼成一次完整往返,而不再重复每个类的定义。
八、把所有层合起来:一份 MHTML 参数到底走了哪条路?
现在回到 Browser 的保存 Job:接线只负责接通接口,保存请求与响应才完成这一轮业务。下图将第五章的调用过程,与第六、七章的运输层合在一起。
添加图片注释,不超过 140 字(可选)
总览图:请求在 Browser 向下提交、在 Renderer 向上交付;响应沿反方向返回。callback 本身留在各自进程,跨界的是参数、资源与关联标识。
1. 沿图读一轮,不再把接线混进业务调用
| 阶段 | 关键动作 | 最终落点 |
|---|---|---|
| 接线 | Provider 递送端点,Registry 找 binder,Receiver 绑定 | 目标 Frame 的实现 |
| 请求 | Proxy 编码,Bindings / System / ipcz / Channel 运输 | RenderFrameImpl::SerializeAsMHTML |
| 执行 | 序列化页面并写入输出资源 | Renderer 本地响应 callback |
| 响应 | 返回状态与摘要,按 request_id 匹配 | Browser 的 Job callback |
接线完成后,业务请求不再查 Registry。响应也不是一次新建接口的调用,而是原请求的返回消息。
2. 收到响应,为什么仍不能直接认定整份文件完成?
响应说明当前请求到达了协议约定的完成阶段;整份保存还可能有其他 Frame,也可能仍在等待流式数据。Job 会检查自身状态后再继续或结束(content/browser/download/mhtml_generation_manager.cc:564):
bool MHTMLGenerationManager::Job::CurrentFrameDone() const {
bool waiting_for_response_from_renderer = !!frame_tree_node_id_of_busy_frame_;
return !waiting_for_response_from_renderer && !waiting_on_data_streaming_;
}
成功且当前 Frame 已完成、有剩余 Frame,才发起下一次请求;失败则结束任务;没有剩余 Frame 且当前工作完成,才进入最终收尾。
3. 用五个状态检查自己是否真的读懂
| 状态 | 只说明什么 |
|---|---|
| 已注册 | 本地 binder 存在 |
| Remote 已绑定 | 本地代理持有端点状态 |
| 已关联 | 关联端点加入 Pipe,可以发送方法 |
| Receiver 已绑定 | 接收端可以分发到实现 |
| 收到业务响应 | 本次请求约定的阶段结束,不自动等于整个 Job 完成 |
Mojo 不传远程对象指针:它传协议与资源能力,再在对端形成一次本地调用。MHTML 展示的是其中一种接线方式;下一节用网络请求对照,看什么时候不必采用 Frame Registry 与关联接口。
九、扩展视角:经典网络请求为什么不总用关联接口?
MHTML 采用 Frame Provider / Registry 递送关联端点,但不能因此认为所有 Mojo 接口都这样连接。接线方式由协议和执行上下文决定;关联接口也不是为了让通信变成双向。
网络加载是一个经典对照:工厂方法直接交付端点,控制、通知与响应体分别承担不同职责。
添加图片注释,不超过 140 字(可选)
图 14:URLLoader 负责控制,URLLoaderClient 负责通知,DataPipe 负责大块响应体。
1. Factory:方法参数已经说明接收端交给谁
URLLoaderFactory::CreateLoaderAndStart() 直接接收 loader 的接收端与 client 的调用端(services/network/public/mojom/url_loader_factory.mojom:77):
CreateLoaderAndStart(pending_receiver<URLLoader> loader,
int32 request_id,
uint32 options,
URLRequest request,
pending_remote<URLLoaderClient> client,
MutableNetworkTrafficAnnotationTag traffic_annotation);
| 链路 | 方向 | 内容 |
|---|---|---|
| URLLoader | 调用方 → 网络服务 | 控制加载 |
| URLLoaderClient | 网络服务 → 调用方 | 响应与完成通知 |
| DataPipe | producer → consumer | 响应体字节流 |
调用方交出端点,工厂协议就定义了对象创建与绑定,不需要再按接口名字找一个 binder。网络服务持有响应体 producer,并把 consumer 交给调用方。
这里参数中的 request_id 是网络业务请求编号,不是 Bindings 消息头中用于匹配 Mojo 响应的 request_id。
2. Broker:按名字请求服务,也可以使用普通 Pipe
例如 Renderer 请求 Browser 的音频服务,使用的是普通 BindNewPipeAndPassReceiver()(content/renderer/render_frame_impl.cc:4819):
blink::mojom::RendererAudioInputStreamFactory*
RenderFrameImpl::GetAudioInputStreamFactory() {
if (!audio_input_stream_factory_)
GetBrowserInterfaceBroker().GetInterface(
audio_input_stream_factory_.BindNewPipeAndPassReceiver(
agent_scheduling_group_->agent_group_scheduler()
.DefaultTaskRunner()));
return audio_input_stream_factory_.get();
}
Browser 的 BrowserInterfaceBrokerImpl::GetInterface() 从 GenericPendingReceiver 取得接口名,在需要时应用 binder policy,再查询 BinderMap(content/browser/browser_interface_broker_impl.h:57、:91)。
它与第四章相似之处是“已有入口递送新接收端”;不同之处是这里创建独立逻辑 MessagePipe,调用方向也是 Renderer → Browser。
3. 选择时先分开两个问题
| 问题 | 可选方式 |
|---|---|
| 新端点怎样交付、谁来绑定? | 显式 Factory 方法,或 Broker / Provider 请求入口 |
| 新接口是否需要共享既有 Pipe 的传输顺序? | 普通 Remote / Receiver,或 AssociatedRemote / AssociatedReceiver |
Factory / Broker 是交付方式,普通 / 关联接口是端点与排序选择;它们不是四个互斥选项。普通 Pipe 本来就是双向的,关联接口强调的是与既有接口共享 Pipe 和传输顺序。
读新接口时,先找到接收端如何交付,再看 Receiver 在哪里绑定,最后确认它使用普通还是关联端点;不必把 MHTML 的具体接线路径套到所有服务上。
十、结语:读懂 Mojo 的四个问题
读陌生 Mojo 接口时,沿四个问题找代码:
- 约定什么?找 mojom 方法、参数与响应。
- 谁实现?找对象实例化和 Receiver.Bind,不按文件名猜进程。
- 端点怎么送?找 factory 参数、Broker 或 Provider 的已有连接。
- 调用怎么走?追 Proxy → 逻辑 Pipe → 平台传输 → Stub → 本地实现。
核心分工始终不变:Registry 按名找接线回调,Provider 递送端点,Receiver 接上实现对象,Bindings 编解码与分发消息,Core / ipcz 管逻辑路由,Channel 管帧与平台 IO。