feat: MessagePorts in the main process (#22404)
This commit is contained in:
parent
c4c0888972
commit
b4d07f76d3
34 changed files with 1316 additions and 113 deletions
276
shell/browser/api/message_port.cc
Normal file
276
shell/browser/api/message_port.cc
Normal file
|
@ -0,0 +1,276 @@
|
|||
// Copyright (c) 2020 Slack Technologies, Inc.
|
||||
// Use of this source code is governed by the MIT license that can be
|
||||
// found in the LICENSE file.
|
||||
|
||||
#include "shell/browser/api/message_port.h"
|
||||
|
||||
#include <string>
|
||||
#include <unordered_set>
|
||||
#include <utility>
|
||||
|
||||
#include "base/strings/string_number_conversions.h"
|
||||
#include "gin/arguments.h"
|
||||
#include "gin/data_object_builder.h"
|
||||
#include "gin/handle.h"
|
||||
#include "gin/object_template_builder.h"
|
||||
#include "shell/common/gin_helper/dictionary.h"
|
||||
#include "shell/common/gin_helper/error_thrower.h"
|
||||
#include "shell/common/gin_helper/event_emitter_caller.h"
|
||||
#include "shell/common/node_includes.h"
|
||||
#include "shell/common/v8_value_serializer.h"
|
||||
#include "third_party/blink/public/common/messaging/transferable_message.h"
|
||||
#include "third_party/blink/public/common/messaging/transferable_message_mojom_traits.h"
|
||||
#include "third_party/blink/public/mojom/messaging/transferable_message.mojom.h"
|
||||
|
||||
namespace electron {
|
||||
|
||||
gin::WrapperInfo MessagePort::kWrapperInfo = {gin::kEmbedderNativeGin};
|
||||
|
||||
MessagePort::MessagePort() = default;
|
||||
MessagePort::~MessagePort() = default;
|
||||
|
||||
// static
|
||||
gin::Handle<MessagePort> MessagePort::Create(v8::Isolate* isolate) {
|
||||
return gin::CreateHandle(isolate, new MessagePort());
|
||||
}
|
||||
|
||||
void MessagePort::PostMessage(gin::Arguments* args) {
|
||||
if (!IsEntangled())
|
||||
return;
|
||||
DCHECK(!IsNeutered());
|
||||
|
||||
blink::TransferableMessage transferable_message;
|
||||
|
||||
v8::Local<v8::Value> message_value;
|
||||
if (!args->GetNext(&message_value)) {
|
||||
args->ThrowTypeError("Expected at least one argument to postMessage");
|
||||
return;
|
||||
}
|
||||
|
||||
electron::SerializeV8Value(args->isolate(), message_value,
|
||||
&transferable_message);
|
||||
|
||||
v8::Local<v8::Value> transferables;
|
||||
std::vector<gin::Handle<MessagePort>> wrapped_ports;
|
||||
if (args->GetNext(&transferables)) {
|
||||
if (!gin::ConvertFromV8(args->isolate(), transferables, &wrapped_ports)) {
|
||||
args->ThrowError();
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// Make sure we aren't connected to any of the passed-in ports.
|
||||
for (unsigned i = 0; i < wrapped_ports.size(); ++i) {
|
||||
if (wrapped_ports[i].get() == this) {
|
||||
gin_helper::ErrorThrower(args->isolate())
|
||||
.ThrowError("Port at index " + base::NumberToString(i) +
|
||||
" contains the source port.");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
bool threw_exception = false;
|
||||
transferable_message.ports = MessagePort::DisentanglePorts(
|
||||
args->isolate(), wrapped_ports, &threw_exception);
|
||||
if (threw_exception)
|
||||
return;
|
||||
|
||||
mojo::Message mojo_message = blink::mojom::TransferableMessage::WrapAsMessage(
|
||||
std::move(transferable_message));
|
||||
connector_->Accept(&mojo_message);
|
||||
}
|
||||
|
||||
void MessagePort::Start() {
|
||||
if (!IsEntangled())
|
||||
return;
|
||||
|
||||
if (started_)
|
||||
return;
|
||||
|
||||
started_ = true;
|
||||
if (HasPendingActivity())
|
||||
Pin();
|
||||
connector_->ResumeIncomingMethodCallProcessing();
|
||||
}
|
||||
|
||||
void MessagePort::Close() {
|
||||
if (closed_)
|
||||
return;
|
||||
if (!IsNeutered()) {
|
||||
connector_ = nullptr;
|
||||
Entangle(mojo::MessagePipe().handle0);
|
||||
}
|
||||
closed_ = true;
|
||||
if (!HasPendingActivity())
|
||||
Unpin();
|
||||
}
|
||||
|
||||
void MessagePort::Entangle(mojo::ScopedMessagePipeHandle handle) {
|
||||
DCHECK(handle.is_valid());
|
||||
DCHECK(!connector_);
|
||||
connector_ = std::make_unique<mojo::Connector>(
|
||||
std::move(handle), mojo::Connector::SINGLE_THREADED_SEND,
|
||||
base::ThreadTaskRunnerHandle::Get());
|
||||
connector_->PauseIncomingMethodCallProcessing();
|
||||
connector_->set_incoming_receiver(this);
|
||||
connector_->set_connection_error_handler(
|
||||
base::Bind(&MessagePort::Close, weak_factory_.GetWeakPtr()));
|
||||
if (HasPendingActivity())
|
||||
Pin();
|
||||
}
|
||||
|
||||
void MessagePort::Entangle(blink::MessagePortChannel channel) {
|
||||
Entangle(channel.ReleaseHandle());
|
||||
}
|
||||
|
||||
blink::MessagePortChannel MessagePort::Disentangle() {
|
||||
DCHECK(!IsNeutered());
|
||||
auto result = blink::MessagePortChannel(connector_->PassMessagePipe());
|
||||
connector_ = nullptr;
|
||||
if (!HasPendingActivity())
|
||||
Unpin();
|
||||
return result;
|
||||
}
|
||||
|
||||
bool MessagePort::HasPendingActivity() const {
|
||||
// The spec says that entangled message ports should always be treated as if
|
||||
// they have a strong reference.
|
||||
// We'll also stipulate that the queue needs to be open (if the app drops its
|
||||
// reference to the port before start()-ing it, then it's not really entangled
|
||||
// as it's unreachable).
|
||||
return started_ && IsEntangled();
|
||||
}
|
||||
|
||||
// static
|
||||
std::vector<gin::Handle<MessagePort>> MessagePort::EntanglePorts(
|
||||
v8::Isolate* isolate,
|
||||
std::vector<blink::MessagePortChannel> channels) {
|
||||
std::vector<gin::Handle<MessagePort>> wrapped_ports;
|
||||
for (auto& port : channels) {
|
||||
auto wrapped_port = MessagePort::Create(isolate);
|
||||
wrapped_port->Entangle(std::move(port));
|
||||
wrapped_ports.emplace_back(wrapped_port);
|
||||
}
|
||||
return wrapped_ports;
|
||||
}
|
||||
|
||||
// static
|
||||
std::vector<blink::MessagePortChannel> MessagePort::DisentanglePorts(
|
||||
v8::Isolate* isolate,
|
||||
const std::vector<gin::Handle<MessagePort>>& ports,
|
||||
bool* threw_exception) {
|
||||
if (!ports.size())
|
||||
return std::vector<blink::MessagePortChannel>();
|
||||
|
||||
std::unordered_set<MessagePort*> visited;
|
||||
|
||||
// Walk the incoming array - if there are any duplicate ports, or null ports
|
||||
// or cloned ports, throw an error (per section 8.3.3 of the HTML5 spec).
|
||||
for (unsigned i = 0; i < ports.size(); ++i) {
|
||||
auto* port = ports[i].get();
|
||||
if (!port || port->IsNeutered() || visited.find(port) != visited.end()) {
|
||||
std::string type;
|
||||
if (!port)
|
||||
type = "null";
|
||||
else if (port->IsNeutered())
|
||||
type = "already neutered";
|
||||
else
|
||||
type = "a duplicate";
|
||||
gin_helper::ErrorThrower(isolate).ThrowError(
|
||||
"Port at index " + base::NumberToString(i) + " is " + type + ".");
|
||||
*threw_exception = true;
|
||||
return std::vector<blink::MessagePortChannel>();
|
||||
}
|
||||
visited.insert(port);
|
||||
}
|
||||
|
||||
// Passed-in ports passed validity checks, so we can disentangle them.
|
||||
std::vector<blink::MessagePortChannel> channels;
|
||||
channels.reserve(ports.size());
|
||||
for (unsigned i = 0; i < ports.size(); ++i)
|
||||
channels.push_back(ports[i]->Disentangle());
|
||||
return channels;
|
||||
}
|
||||
|
||||
void MessagePort::Pin() {
|
||||
if (!pinned_.IsEmpty())
|
||||
return;
|
||||
v8::Isolate* isolate = v8::Isolate::GetCurrent();
|
||||
v8::Local<v8::Value> self;
|
||||
if (GetWrapper(isolate).ToLocal(&self)) {
|
||||
pinned_.Reset(isolate, self);
|
||||
}
|
||||
}
|
||||
|
||||
void MessagePort::Unpin() {
|
||||
pinned_.Reset();
|
||||
}
|
||||
|
||||
bool MessagePort::Accept(mojo::Message* mojo_message) {
|
||||
blink::TransferableMessage message;
|
||||
if (!blink::mojom::TransferableMessage::DeserializeFromMessage(
|
||||
std::move(*mojo_message), &message)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
v8::Isolate* isolate = v8::Isolate::GetCurrent();
|
||||
v8::HandleScope scope(isolate);
|
||||
|
||||
auto ports = EntanglePorts(isolate, std::move(message.ports));
|
||||
|
||||
v8::Local<v8::Value> message_value = DeserializeV8Value(isolate, message);
|
||||
|
||||
v8::Local<v8::Object> self;
|
||||
if (!GetWrapper(isolate).ToLocal(&self))
|
||||
return false;
|
||||
|
||||
auto event = gin::DataObjectBuilder(isolate)
|
||||
.Set("data", message_value)
|
||||
.Set("ports", ports)
|
||||
.Build();
|
||||
gin_helper::EmitEvent(isolate, self, "message", event);
|
||||
return true;
|
||||
}
|
||||
|
||||
gin::ObjectTemplateBuilder MessagePort::GetObjectTemplateBuilder(
|
||||
v8::Isolate* isolate) {
|
||||
return gin::Wrappable<MessagePort>::GetObjectTemplateBuilder(isolate)
|
||||
.SetMethod("postMessage", &MessagePort::PostMessage)
|
||||
.SetMethod("start", &MessagePort::Start)
|
||||
.SetMethod("close", &MessagePort::Close);
|
||||
}
|
||||
|
||||
const char* MessagePort::GetTypeName() {
|
||||
return "MessagePort";
|
||||
}
|
||||
|
||||
} // namespace electron
|
||||
|
||||
namespace {
|
||||
|
||||
using electron::MessagePort;
|
||||
|
||||
v8::Local<v8::Value> CreatePair(v8::Isolate* isolate) {
|
||||
auto port1 = MessagePort::Create(isolate);
|
||||
auto port2 = MessagePort::Create(isolate);
|
||||
mojo::MessagePipe pipe;
|
||||
port1->Entangle(std::move(pipe.handle0));
|
||||
port2->Entangle(std::move(pipe.handle1));
|
||||
return gin::DataObjectBuilder(isolate)
|
||||
.Set("port1", port1)
|
||||
.Set("port2", port2)
|
||||
.Build();
|
||||
}
|
||||
|
||||
void Initialize(v8::Local<v8::Object> exports,
|
||||
v8::Local<v8::Value> unused,
|
||||
v8::Local<v8::Context> context,
|
||||
void* priv) {
|
||||
v8::Isolate* isolate = context->GetIsolate();
|
||||
gin_helper::Dictionary dict(isolate, exports);
|
||||
dict.SetMethod("createPair", &CreatePair);
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
NODE_LINKED_MODULE_CONTEXT_AWARE(electron_browser_message_port, Initialize)
|
Loading…
Add table
Add a link
Reference in a new issue