../src/node_messaging.cc

Bug Summary

File:	out/../src/node_messaging.cc
Warning:	line 668, column 12 Potential leak of memory pointed to by 'port'

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name node_messaging.cc -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/maurizio/node-v18.6.0/out -resource-dir /usr/local/lib/clang/16.0.0 -D V8_DEPRECATION_WARNINGS -D V8_IMMINENT_DEPRECATION_WARNINGS -D _GLIBCXX_USE_CXX11_ABI=1 -D NODE_OPENSSL_CONF_NAME=nodejs_conf -D NODE_OPENSSL_HAS_QUIC -D __STDC_FORMAT_MACROS -D OPENSSL_NO_PINSHARED -D OPENSSL_THREADS -D NODE_ARCH="x64" -D NODE_PLATFORM="linux" -D NODE_WANT_INTERNALS=1 -D V8_DEPRECATION_WARNINGS=1 -D NODE_OPENSSL_SYSTEM_CERT_PATH="" -D NODE_USE_NODE_CODE_CACHE=1 -D HAVE_INSPECTOR=1 -D NODE_ENABLE_LARGE_CODE_PAGES=1 -D __POSIX__ -D NODE_USE_V8_PLATFORM=1 -D NODE_HAVE_I18N_SUPPORT=1 -D HAVE_OPENSSL=1 -D OPENSSL_API_COMPAT=0x10100000L -D UCONFIG_NO_SERVICE=1 -D U_ENABLE_DYLOAD=0 -D U_STATIC_IMPLEMENTATION=1 -D U_HAVE_STD_STRING=1 -D UCONFIG_NO_BREAK_ITERATION=0 -D _LARGEFILE_SOURCE -D _FILE_OFFSET_BITS=64 -D _POSIX_C_SOURCE=200112 -D NGHTTP2_STATICLIB -D NDEBUG -D OPENSSL_USE_NODELETE -D L_ENDIAN -D OPENSSL_BUILDING_OPENSSL -D AES_ASM -D BSAES_ASM -D CMLL_ASM -D ECP_NISTZ256_ASM -D GHASH_ASM -D KECCAK1600_ASM -D MD5_ASM -D OPENSSL_BN_ASM_GF2m -D OPENSSL_BN_ASM_MONT -D OPENSSL_BN_ASM_MONT5 -D OPENSSL_CPUID_OBJ -D OPENSSL_IA32_SSE2 -D PADLOCK_ASM -D POLY1305_ASM -D SHA1_ASM -D SHA256_ASM -D SHA512_ASM -D VPAES_ASM -D WHIRLPOOL_ASM -D X25519_ASM -D OPENSSL_PIC -D NGTCP2_STATICLIB -D NGHTTP3_STATICLIB -I ../src -I /home/maurizio/node-v18.6.0/out/Release/obj/gen -I /home/maurizio/node-v18.6.0/out/Release/obj/gen/include -I /home/maurizio/node-v18.6.0/out/Release/obj/gen/src -I ../deps/googletest/include -I ../deps/histogram/src -I ../deps/uvwasi/include -I ../deps/v8/include -I ../deps/icu-small/source/i18n -I ../deps/icu-small/source/common -I ../deps/zlib -I ../deps/llhttp/include -I ../deps/cares/include -I ../deps/uv/include -I ../deps/nghttp2/lib/includes -I ../deps/brotli/c/include -I ../deps/openssl/openssl/include -I ../deps/openssl/openssl/crypto/include -I ../deps/openssl/config/archs/linux-x86_64/asm/include -I ../deps/openssl/config/archs/linux-x86_64/asm -I ../deps/ngtcp2 -I ../deps/ngtcp2/ngtcp2/lib/includes -I ../deps/ngtcp2/ngtcp2/crypto/includes -I ../deps/ngtcp2/nghttp3/lib/includes -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/x86_64-redhat-linux -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/backward -internal-isystem /usr/local/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-unused-parameter -std=gnu++17 -fdeprecated-macro -fdebug-compilation-dir=/home/maurizio/node-v18.6.0/out -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-08-22-142216-507842-1 -x c++ ../src/node_messaging.cc

../src/node_messaging.cc

→

1#include "node_messaging.h"

3#include "async_wrap-inl.h"
4#include "debug_utils-inl.h"
5#include "memory_tracker-inl.h"
6#include "node_buffer.h"
7#include "node_contextify.h"
8#include "node_errors.h"
9#include "node_external_reference.h"
10#include "node_process-inl.h"
11#include "util-inl.h"

13using node::contextify::ContextifyContext;
14using node::errors::TryCatchScope;
15using v8::Array;
16using v8::ArrayBuffer;
17using v8::BackingStore;
18using v8::CompiledWasmModule;
19using v8::Context;
20using v8::EscapableHandleScope;
21using v8::Function;
22using v8::FunctionCallbackInfo;
23using v8::FunctionTemplate;
24using v8::Global;
25using v8::HandleScope;
26using v8::Isolate;
27using v8::Just;
28using v8::Local;
29using v8::Maybe;
30using v8::MaybeLocal;
31using v8::Nothing;
32using v8::Object;
33using v8::SharedArrayBuffer;
34using v8::String;
35using v8::Symbol;
36using v8::Value;
37using v8::ValueDeserializer;
38using v8::ValueSerializer;
39using v8::WasmModuleObject;

41namespace node {

43using BaseObjectList = std::vector<BaseObjectPtr<BaseObject>>;

45BaseObject::TransferMode BaseObject::GetTransferMode() const {
return BaseObject::TransferMode::kUntransferable;
47}

49std::unique_ptr<worker::TransferData> BaseObject::TransferForMessaging() {
return CloneForMessaging();
51}

53std::unique_ptr<worker::TransferData> BaseObject::CloneForMessaging() const {
return {};
55}

57Maybe<BaseObjectList> BaseObject::NestedTransferables() const {
return Just(BaseObjectList {});
59}

61Maybe<bool> BaseObject::FinalizeTransferRead(
  Local<Context> context, ValueDeserializer* deserializer) {
return Just(true);
64}

66namespace worker {

68Maybe<bool> TransferData::FinalizeTransferWrite(
  Local<Context> context, ValueSerializer* serializer) {
return Just(true);
71}

73Message::Message(MallocedBuffer<char>&& buffer)
  : main_message_buf_(std::move(buffer)) {}

76bool Message::IsCloseMessage() const {
return main_message_buf_.data == nullptr;
78}

80namespace {

82// This is used to tell V8 how to read transferred host objects, like other
83// `MessagePort`s and `SharedArrayBuffer`s, and make new JS objects out of them.
84class DeserializerDelegate : public ValueDeserializer::Delegate {
public:
DeserializerDelegate(
    Message* m,
    Environment* env,
    const std::vector<BaseObjectPtr<BaseObject>>& host_objects,
    const std::vector<Local<SharedArrayBuffer>>& shared_array_buffers,
    const std::vector<CompiledWasmModule>& wasm_modules)
    : host_objects_(host_objects),
      shared_array_buffers_(shared_array_buffers),
      wasm_modules_(wasm_modules) {}

MaybeLocal<Object> ReadHostObject(Isolate* isolate) override {
  // Identifying the index in the message's BaseObject array is sufficient.
  uint32_t id;
  if (!deserializer->ReadUint32(&id))
    return MaybeLocal<Object>();
  CHECK_LT(id, host_objects_.size())do { if (__builtin_expect(!!(!((id) < (host_objects_.size(
)))), 0)) { do { static const node::AssertionInfo args = { "../src/node_messaging.cc"
 ":" "101", "(id) < (host_objects_.size())", __PRETTY_FUNCTION__
 }; node::Assert(args); } while (0); } } while (0);
  return host_objects_[id]->object(isolate);
}

MaybeLocal<SharedArrayBuffer> GetSharedArrayBufferFromId(
    Isolate* isolate, uint32_t clone_id) override {
  CHECK_LT(clone_id, shared_array_buffers_.size())do { if (__builtin_expect(!!(!((clone_id) < (shared_array_buffers_
.size()))), 0)) { do { static const node::AssertionInfo args =
 { "../src/node_messaging.cc" ":" "107", "(clone_id) < (shared_array_buffers_.size())"
, __PRETTY_FUNCTION__ }; node::Assert(args); } while (0); } }
 while (0);
  return shared_array_buffers_[clone_id];
}

MaybeLocal<WasmModuleObject> GetWasmModuleFromId(
    Isolate* isolate, uint32_t transfer_id) override {
  CHECK_LT(transfer_id, wasm_modules_.size())do { if (__builtin_expect(!!(!((transfer_id) < (wasm_modules_
.size()))), 0)) { do { static const node::AssertionInfo args =
 { "../src/node_messaging.cc" ":" "113", "(transfer_id) < (wasm_modules_.size())"
, __PRETTY_FUNCTION__ }; node::Assert(args); } while (0); } }
 while (0);
  return WasmModuleObject::FromCompiledModule(
      isolate, wasm_modules_[transfer_id]);
}

ValueDeserializer* deserializer = nullptr;

private:
const std::vector<BaseObjectPtr<BaseObject>>& host_objects_;
const std::vector<Local<SharedArrayBuffer>>& shared_array_buffers_;
const std::vector<CompiledWasmModule>& wasm_modules_;
124};

126}  // anonymous namespace

128MaybeLocal<Value> Message::Deserialize(Environment* env,
                                     Local<Context> context,
                                     Local<Value>* port_list) {
Context::Scope context_scope(context);

CHECK(!IsCloseMessage())do { if (__builtin_expect(!!(!(!IsCloseMessage())), 0)) { do {
 static const node::AssertionInfo args = { "../src/node_messaging.cc"
 ":" "133", "!IsCloseMessage()", __PRETTY_FUNCTION__ }; node::
Assert(args); } while (0); } } while (0);
if (port_list != nullptr && !transferables_.empty()) {
  // Need to create this outside of the EscapableHandleScope, but inside
  // the Context::Scope.
  *port_list = Array::New(env->isolate());
}

EscapableHandleScope handle_scope(env->isolate());

// Create all necessary objects for transferables, e.g. MessagePort handles.
std::vector<BaseObjectPtr<BaseObject>> host_objects(transferables_.size());
auto cleanup = OnScopeLeave([&]() {
  for (BaseObjectPtr<BaseObject> object : host_objects) {
    if (!object) continue;

    // If the function did not finish successfully, host_objects will contain
    // a list of objects that will never be passed to JS. Therefore, we
    // destroy them here.
    object->Detach();
  }
});

for (uint32_t i = 0; i < transferables_.size(); ++i) {
  HandleScope handle_scope(env->isolate());
  TransferData* data = transferables_[i].get();
  host_objects[i] = data->Deserialize(
      env, context, std::move(transferables_[i]));
  if (!host_objects[i]) return {};
  if (port_list != nullptr) {
    // If we gather a list of all message ports, and this transferred object
    // is a message port, add it to that list. This is a bit of an odd case
    // of special handling for MessagePorts (as opposed to applying to all
    // transferables), but it's required for spec compliance.
    DCHECK((*port_list)->IsArray());
    Local<Array> port_list_array = port_list->As<Array>();
    Local<Object> obj = host_objects[i]->object();
    if (env->message_port_constructor_template()->HasInstance(obj)) {
      if (port_list_array->Set(context,
                               port_list_array->Length(),
                               obj).IsNothing()) {
        return {};
      }
    }
  }
}
transferables_.clear();

std::vector<Local<SharedArrayBuffer>> shared_array_buffers;
// Attach all transferred SharedArrayBuffers to their new Isolate.
for (uint32_t i = 0; i < shared_array_buffers_.size(); ++i) {
  Local<SharedArrayBuffer> sab =
      SharedArrayBuffer::New(env->isolate(), shared_array_buffers_[i]);
  shared_array_buffers.push_back(sab);
}

DeserializerDelegate delegate(
    this, env, host_objects, shared_array_buffers, wasm_modules_);
ValueDeserializer deserializer(
    env->isolate(),
    reinterpret_cast<const uint8_t*>(main_message_buf_.data),
    main_message_buf_.size,
    &delegate);
delegate.deserializer = &deserializer;

// Attach all transferred ArrayBuffers to their new Isolate.
for (uint32_t i = 0; i < array_buffers_.size(); ++i) {
  Local<ArrayBuffer> ab =
      ArrayBuffer::New(env->isolate(), std::move(array_buffers_[i]));
  deserializer.TransferArrayBuffer(i, ab);
}

if (deserializer.ReadHeader(context).IsNothing())
  return {};
Local<Value> return_value;
if (!deserializer.ReadValue(context).ToLocal(&return_value))
  return {};

for (BaseObjectPtr<BaseObject> base_object : host_objects) {
  if (base_object->FinalizeTransferRead(context, &deserializer).IsNothing())
    return {};
}

host_objects.clear();
return handle_scope.Escape(return_value);
217}

219void Message::AddSharedArrayBuffer(
  std::shared_ptr<BackingStore> backing_store) {
shared_array_buffers_.emplace_back(std::move(backing_store));
222}

224void Message::AddTransferable(std::unique_ptr<TransferData>&& data) {
transferables_.emplace_back(std::move(data));
226}

228uint32_t Message::AddWASMModule(CompiledWasmModule&& mod) {
wasm_modules_.emplace_back(std::move(mod));
return wasm_modules_.size() - 1;
231}

233namespace {

235MaybeLocal<Function> GetEmitMessageFunction(Local<Context> context) {
Isolate* isolate = context->GetIsolate();
Local<Object> per_context_bindings;
Local<Value> emit_message_val;
if (!GetPerContextExports(context).ToLocal(&per_context_bindings) ||
    !per_context_bindings->Get(context,
                              FIXED_ONE_BYTE_STRING(isolate, "emitMessage"))
        .ToLocal(&emit_message_val)) {
  return MaybeLocal<Function>();
}
CHECK(emit_message_val->IsFunction())do { if (__builtin_expect(!!(!(emit_message_val->IsFunction
())), 0)) { do { static const node::AssertionInfo args = { "../src/node_messaging.cc"
 ":" "245", "emit_message_val->IsFunction()", __PRETTY_FUNCTION__
 }; node::Assert(args); } while (0); } } while (0);
return emit_message_val.As<Function>();
247}

249MaybeLocal<Function> GetDOMException(Local<Context> context) {
Isolate* isolate = context->GetIsolate();
Local<Object> per_context_bindings;
Local<Value> domexception_ctor_val;
if (!GetPerContextExports(context).ToLocal(&per_context_bindings) ||
    !per_context_bindings->Get(context,
                              FIXED_ONE_BYTE_STRING(isolate, "DOMException"))
        .ToLocal(&domexception_ctor_val)) {
  return MaybeLocal<Function>();
}
CHECK(domexception_ctor_val->IsFunction())do { if (__builtin_expect(!!(!(domexception_ctor_val->IsFunction
())), 0)) { do { static const node::AssertionInfo args = { "../src/node_messaging.cc"
 ":" "259", "domexception_ctor_val->IsFunction()", __PRETTY_FUNCTION__
 }; node::Assert(args); } while (0); } } while (0);
Local<Function> domexception_ctor = domexception_ctor_val.As<Function>();
return domexception_ctor;
262}

264void ThrowDataCloneException(Local<Context> context, Local<String> message) {
Isolate* isolate = context->GetIsolate();
Local<Value> argv[] = {message,
                       FIXED_ONE_BYTE_STRING(isolate, "DataCloneError")};
Local<Value> exception;
Local<Function> domexception_ctor;
if (!GetDOMException(context).ToLocal(&domexception_ctor) ||
    !domexception_ctor->NewInstance(context, arraysize(argv), argv)
         .ToLocal(&exception)) {
  return;
}
isolate->ThrowException(exception);
276}

278// This tells V8 how to serialize objects that it does not understand
279// (e.g. C++ objects) into the output buffer, in a way that our own
280// DeserializerDelegate understands how to unpack.
281class SerializerDelegate : public ValueSerializer::Delegate {
public:
SerializerDelegate(Environment* env, Local<Context> context, Message* m)
    : env_(env), context_(context), msg_(m) {}

void ThrowDataCloneError(Local<String> message) override {
  ThrowDataCloneException(context_, message);
}

Maybe<bool> WriteHostObject(Isolate* isolate, Local<Object> object) override {
  if (env_->base_object_ctor_template()->HasInstance(object)) {
    return WriteHostObject(
        BaseObjectPtr<BaseObject> { Unwrap<BaseObject>(object) });
  }

  ThrowDataCloneError(env_->clone_unsupported_type_str());
  return Nothing<bool>();
}

Maybe<uint32_t> GetSharedArrayBufferId(
    Isolate* isolate,
    Local<SharedArrayBuffer> shared_array_buffer) override {
  uint32_t i;
  for (i = 0; i < seen_shared_array_buffers_.size(); ++i) {
    if (PersistentToLocal::Strong(seen_shared_array_buffers_[i]) ==
        shared_array_buffer) {
      return Just(i);
    }
  }

  seen_shared_array_buffers_.emplace_back(
    Global<SharedArrayBuffer> { isolate, shared_array_buffer });
  msg_->AddSharedArrayBuffer(shared_array_buffer->GetBackingStore());
  return Just(i);
}

Maybe<uint32_t> GetWasmModuleTransferId(
    Isolate* isolate, Local<WasmModuleObject> module) override {
  return Just(msg_->AddWASMModule(module->GetCompiledModule()));
}

Maybe<bool> Finish(Local<Context> context) {
  for (uint32_t i = 0; i < host_objects_.size(); i++) {
    BaseObjectPtr<BaseObject> host_object = std::move(host_objects_[i]);
    std::unique_ptr<TransferData> data;
    if (i < first_cloned_object_index_)
      data = host_object->TransferForMessaging();
    if (!data)
      data = host_object->CloneForMessaging();
    if (!data) return Nothing<bool>();
    if (data->FinalizeTransferWrite(context, serializer).IsNothing())
      return Nothing<bool>();
    msg_->AddTransferable(std::move(data));
  }
  return Just(true);
}

inline void AddHostObject(BaseObjectPtr<BaseObject> host_object) {
  // Make sure we have not started serializing the value itself yet.
  CHECK_EQ(first_cloned_object_index_, SIZE_MAX)do { if (__builtin_expect(!!(!((first_cloned_object_index_) ==
 ((18446744073709551615UL)))), 0)) { do { static const node::
AssertionInfo args = { "../src/node_messaging.cc" ":" "340", "(first_cloned_object_index_) == ((18446744073709551615UL))"
, __PRETTY_FUNCTION__ }; node::Assert(args); } while (0); } }
 while (0);
  host_objects_.emplace_back(std::move(host_object));
}

// Some objects in the transfer list may register sub-objects that can be
// transferred. This could e.g. be a public JS wrapper object, such as a
// FileHandle, that is registering its C++ handle for transfer.
inline Maybe<bool> AddNestedHostObjects() {
  for (size_t i = 0; i < host_objects_.size(); i++) {
    std::vector<BaseObjectPtr<BaseObject>> nested_transferables;
    if (!host_objects_[i]->NestedTransferables().To(&nested_transferables))
      return Nothing<bool>();
    for (auto nested_transferable : nested_transferables) {
      if (std::find(host_objects_.begin(),
                    host_objects_.end(),
                    nested_transferable) == host_objects_.end()) {
        AddHostObject(nested_transferable);
      }
    }
  }
  return Just(true);
}

ValueSerializer* serializer = nullptr;

private:
Maybe<bool> WriteHostObject(BaseObjectPtr<BaseObject> host_object) {
  BaseObject::TransferMode mode = host_object->GetTransferMode();
  if (mode == BaseObject::TransferMode::kUntransferable) {
    ThrowDataCloneError(env_->clone_unsupported_type_str());
    return Nothing<bool>();
  }

  for (uint32_t i = 0; i < host_objects_.size(); i++) {
    if (host_objects_[i] == host_object) {
      serializer->WriteUint32(i);
      return Just(true);
    }
  }

  if (mode == BaseObject::TransferMode::kTransferable) {
    THROW_ERR_MISSING_TRANSFERABLE_IN_TRANSFER_LIST(env_);
    return Nothing<bool>();
  }

  CHECK_EQ(mode, BaseObject::TransferMode::kCloneable)do { if (__builtin_expect(!!(!((mode) == (BaseObject::TransferMode
::kCloneable))), 0)) { do { static const node::AssertionInfo args
 = { "../src/node_messaging.cc" ":" "385", "(mode) == (BaseObject::TransferMode::kCloneable)"
, __PRETTY_FUNCTION__ }; node::Assert(args); } while (0); } }
 while (0);
  uint32_t index = host_objects_.size();
  if (first_cloned_object_index_ == SIZE_MAX(18446744073709551615UL))
    first_cloned_object_index_ = index;
  serializer->WriteUint32(index);
  host_objects_.push_back(host_object);
  return Just(true);
}

Environment* env_;
Local<Context> context_;
Message* msg_;
std::vector<Global<SharedArrayBuffer>> seen_shared_array_buffers_;
std::vector<BaseObjectPtr<BaseObject>> host_objects_;
size_t first_cloned_object_index_ = SIZE_MAX(18446744073709551615UL);

friend class worker::Message;
402};

404}  // anonymous namespace

406Maybe<bool> Message::Serialize(Environment* env,
                             Local<Context> context,
                             Local<Value> input,
                             const TransferList& transfer_list_v,
                             Local<Object> source_port) {
HandleScope handle_scope(env->isolate());
Context::Scope context_scope(context);

// Verify that we're not silently overwriting an existing message.
CHECK(main_message_buf_.is_empty())do { if (__builtin_expect(!!(!(main_message_buf_.is_empty()))
, 0)) { do { static const node::AssertionInfo args = { "../src/node_messaging.cc"
 ":" "415", "main_message_buf_.is_empty()", __PRETTY_FUNCTION__
 }; node::Assert(args); } while (0); } } while (0);

SerializerDelegate delegate(env, context, this);
ValueSerializer serializer(env->isolate(), &delegate);
delegate.serializer = &serializer;

std::vector<Local<ArrayBuffer>> array_buffers;
for (uint32_t i = 0; i < transfer_list_v.length(); ++i) {
  Local<Value> entry = transfer_list_v[i];
  if (entry->IsObject()) {
    // See https://github.com/nodejs/node/pull/30339#issuecomment-552225353
    // for details.
    bool untransferable;
    if (!entry.As<Object>()->HasPrivate(
            context,
            env->untransferable_object_private_symbol())
            .To(&untransferable)) {
      return Nothing<bool>();
    }
    if (untransferable) continue;
  }

  // Currently, we support ArrayBuffers and BaseObjects for which
  // GetTransferMode() does not return kUntransferable.
  if (entry->IsArrayBuffer()) {
    Local<ArrayBuffer> ab = entry.As<ArrayBuffer>();
    // If we cannot render the ArrayBuffer unusable in this Isolate,
    // copying the buffer will have to do.
    // Note that we can currently transfer ArrayBuffers even if they were
    // not allocated by Node’s ArrayBufferAllocator in the first place,
    // because we pass the underlying v8::BackingStore around rather than
    // raw data *and* an Isolate with a non-default ArrayBuffer allocator
    // is always going to outlive any Workers it creates, and so will its
    // allocator along with it.
    if (!ab->IsDetachable()) continue;
    if (std::find(array_buffers.begin(), array_buffers.end(), ab) !=
        array_buffers.end()) {
      ThrowDataCloneException(
          context,
          FIXED_ONE_BYTE_STRING(
              env->isolate(),
              "Transfer list contains duplicate ArrayBuffer"));
      return Nothing<bool>();
    }
    // We simply use the array index in the `array_buffers` list as the
    // ID that we write into the serialized buffer.
    uint32_t id = array_buffers.size();
    array_buffers.push_back(ab);
    serializer.TransferArrayBuffer(id, ab);
    continue;
  } else if (env->base_object_ctor_template()->HasInstance(entry)) {
    // Check if the source MessagePort is being transferred.
    if (!source_port.IsEmpty() && entry == source_port) {
      ThrowDataCloneException(
          context,
          FIXED_ONE_BYTE_STRING(env->isolate(),
                                "Transfer list contains source port"));
      return Nothing<bool>();
    }
    BaseObjectPtr<BaseObject> host_object {
        Unwrap<BaseObject>(entry.As<Object>()) };
    if (env->message_port_constructor_template()->HasInstance(entry) &&
        (!host_object ||
         static_cast<MessagePort*>(host_object.get())->IsDetached())) {
      ThrowDataCloneException(
          context,
          FIXED_ONE_BYTE_STRING(
              env->isolate(),
              "MessagePort in transfer list is already detached"));
      return Nothing<bool>();
    }
    if (std::find(delegate.host_objects_.begin(),
                  delegate.host_objects_.end(),
                  host_object) != delegate.host_objects_.end()) {
      ThrowDataCloneException(
          context,
          String::Concat(env->isolate(),
              FIXED_ONE_BYTE_STRING(
                env->isolate(),
                "Transfer list contains duplicate "),
              entry.As<Object>()->GetConstructorName()));
      return Nothing<bool>();
    }
    if (host_object && host_object->GetTransferMode() !=
            BaseObject::TransferMode::kUntransferable) {
      delegate.AddHostObject(host_object);
      continue;
    }
  }

  THROW_ERR_INVALID_TRANSFER_OBJECT(env);
  return Nothing<bool>();
}
if (delegate.AddNestedHostObjects().IsNothing())
  return Nothing<bool>();

serializer.WriteHeader();
if (serializer.WriteValue(context, input).IsNothing()) {
  return Nothing<bool>();
}

for (Local<ArrayBuffer> ab : array_buffers) {
  // If serialization succeeded, we render it inaccessible in this Isolate.
  std::shared_ptr<BackingStore> backing_store = ab->GetBackingStore();
  ab->Detach();

  array_buffers_.emplace_back(std::move(backing_store));
}

if (delegate.Finish(context).IsNothing())
  return Nothing<bool>();

// The serializer gave us a buffer allocated using `malloc()`.
std::pair<uint8_t*, size_t> data = serializer.Release();
CHECK_NOT_NULL(data.first)do { if (__builtin_expect(!!(!((data.first) != nullptr)), 0))
 { do { static const node::AssertionInfo args = { "../src/node_messaging.cc"
 ":" "529", "(data.first) != nullptr", __PRETTY_FUNCTION__ };
 node::Assert(args); } while (0); } } while (0);
main_message_buf_ =
    MallocedBuffer<char>(reinterpret_cast<char*>(data.first), data.second);
return Just(true);
533}

535void Message::MemoryInfo(MemoryTracker* tracker) const {
tracker->TrackField("array_buffers_", array_buffers_);
tracker->TrackField("shared_array_buffers", shared_array_buffers_);
tracker->TrackField("transferables", transferables_);
539}

541MessagePortData::MessagePortData(MessagePort* owner)
  : owner_(owner) {
543}

545MessagePortData::~MessagePortData() {
CHECK_NULL(owner_)do { if (__builtin_expect(!!(!((owner_) == nullptr)), 0)) { do
 { static const node::AssertionInfo args = { "../src/node_messaging.cc"
 ":" "546", "(owner_) == nullptr", __PRETTY_FUNCTION__ }; node
::Assert(args); } while (0); } } while (0);
Disentangle();
548}

550void MessagePortData::MemoryInfo(MemoryTracker* tracker) const {
Mutex::ScopedLock lock(mutex_);
tracker->TrackField("incoming_messages", incoming_messages_);
553}

555void MessagePortData::AddToIncomingQueue(std::shared_ptr<Message> message) {
// This function will be called by other threads.
Mutex::ScopedLock lock(mutex_);
incoming_messages_.emplace_back(std::move(message));

if (owner_ != nullptr) {
  Debug(owner_, "Adding message to incoming queue");
  owner_->TriggerAsync();
}
564}

566void MessagePortData::Entangle(MessagePortData* a, MessagePortData* b) {
auto group = std::make_shared<SiblingGroup>();
group->Entangle({a, b});
569}

571void MessagePortData::Disentangle() {
if (group_) {
  group_->Disentangle(this);
}
575}

577MessagePort::~MessagePort() {
if (data_) Detach();
579}

581MessagePort::MessagePort(Environment* env,
                       Local<Context> context,
                       Local<Object> wrap)
: HandleWrap(env,
             wrap,
             reinterpret_cast<uv_handle_t*>(&async_),
             AsyncWrap::PROVIDER_MESSAGEPORT),
  data_(new MessagePortData(this)) {
auto onmessage = [](uv_async_t* handle) {
  // Called when data has been put into the queue.
  MessagePort* channel = ContainerOf(&MessagePort::async_, handle);
  channel->OnMessage(MessageProcessingMode::kNormalOperation);
};

CHECK_EQ(uv_async_init(env->event_loop(),do { if (__builtin_expect(!!(!((uv_async_init(env->event_loop
(), &async_, onmessage)) == (0))), 0)) { do { static const
 node::AssertionInfo args = { "../src/node_messaging.cc" ":" "597"
, "(uv_async_init(env->event_loop(), &async_, onmessage)) == (0)"
, __PRETTY_FUNCTION__ }; node::Assert(args); } while (0); } }
 while (0)
                       &async_,do { if (__builtin_expect(!!(!((uv_async_init(env->event_loop
(), &async_, onmessage)) == (0))), 0)) { do { static const
 node::AssertionInfo args = { "../src/node_messaging.cc" ":" "597"
, "(uv_async_init(env->event_loop(), &async_, onmessage)) == (0)"
, __PRETTY_FUNCTION__ }; node::Assert(args); } while (0); } }
 while (0)
                       onmessage), 0)do { if (__builtin_expect(!!(!((uv_async_init(env->event_loop
(), &async_, onmessage)) == (0))), 0)) { do { static const
 node::AssertionInfo args = { "../src/node_messaging.cc" ":" "597"
, "(uv_async_init(env->event_loop(), &async_, onmessage)) == (0)"
, __PRETTY_FUNCTION__ }; node::Assert(args); } while (0); } }
 while (0);
// Reset later to indicate success of the constructor.
bool succeeded = false;
auto cleanup = OnScopeLeave([&]() { if (!succeeded) Close(); });

Local<Value> fn;
if (!wrap->Get(context, env->oninit_symbol()).ToLocal(&fn))
  return;

if (fn->IsFunction()) {
  Local<Function> init = fn.As<Function>();
  if (init->Call(context, wrap, 0, nullptr).IsEmpty())
    return;
}

Local<Function> emit_message_fn;
if (!GetEmitMessageFunction(context).ToLocal(&emit_message_fn))
  return;
emit_message_fn_.Reset(env->isolate(), emit_message_fn);

succeeded = true;
Debug(this, "Created message port");
619}

621bool MessagePort::IsDetached() const {
return data_ == nullptr || IsHandleClosing();
623}

625void MessagePort::TriggerAsync() {
if (IsHandleClosing()) return;
CHECK_EQ(uv_async_send(&async_), 0)do { if (__builtin_expect(!!(!((uv_async_send(&async_)) ==
 (0))), 0)) { do { static const node::AssertionInfo args = { "../src/node_messaging.cc"
 ":" "627", "(uv_async_send(&async_)) == (0)", __PRETTY_FUNCTION__
 }; node::Assert(args); } while (0); } } while (0);
628}

630void MessagePort::Close(v8::Local<v8::Value> close_callback) {
Debug(this, "Closing message port, data set = %d", static_cast<int>(!!data_));

if (data_) {
  // Wrap this call with accessing the mutex, so that TriggerAsync()
  // can check IsHandleClosing() without race conditions.
  Mutex::ScopedLock sibling_lock(data_->mutex_);
  HandleWrap::Close(close_callback);
} else {
  HandleWrap::Close(close_callback);
}
641}

643void MessagePort::New(const FunctionCallbackInfo<Value>& args) {
// This constructor just throws an error. Unfortunately, we can’t use V8’s
// ConstructorBehavior::kThrow, as that also removes the prototype from the
// class (i.e. makes it behave like an arrow function).
Environment* env = Environment::GetCurrent(args);
THROW_ERR_CONSTRUCT_CALL_INVALID(env);
649}

651MessagePort* MessagePort::New(
  Environment* env,
  Local<Context> context,
  std::unique_ptr<MessagePortData> data,
  std::shared_ptr<SiblingGroup> sibling_group) {
Context::Scope context_scope(context);
Local<FunctionTemplate> ctor_templ = GetMessagePortConstructorTemplate(env);

// Construct a new instance, then assign the listener instance and possibly
// the MessagePortData to it.
Local<Object> instance;
if (!ctor_templ->InstanceTemplate()->NewInstance(context).ToLocal(&instance))
4
←
Taking false branch→
  return nullptr;
MessagePort* port = new MessagePort(env, context, instance);
5
←
Memory is allocated→
CHECK_NOT_NULL(port)do { if (__builtin_expect(!!(!((port) != nullptr)), 0)) { do {
 static const node::AssertionInfo args = { "../src/node_messaging.cc"
 ":" "665", "(port) != nullptr", __PRETTY_FUNCTION__ }; node::
Assert(args); } while (0); } } while (0);
6
←
Taking false branch→
7
←
Loop condition is false.  Exiting loop→
if (port->IsHandleClosing()) {
8
←
Taking true branch→
  // Construction failed with an exception.
  return nullptr;
9
←
Potential leak of memory pointed to by 'port'
}

if (data) {
  CHECK(!sibling_group)do { if (__builtin_expect(!!(!(!sibling_group)), 0)) { do { static
 const node::AssertionInfo args = { "../src/node_messaging.cc"
 ":" "672", "!sibling_group", __PRETTY_FUNCTION__ }; node::Assert
(args); } while (0); } } while (0);
  port->Detach();
  port->data_ = std::move(data);

  // This lock is here to avoid race conditions with the `owner_` read
  // in AddToIncomingQueue(). (This would likely be unproblematic without it,
  // but it's better to be safe than sorry.)
  Mutex::ScopedLock lock(port->data_->mutex_);
  port->data_->owner_ = port;
  // If the existing MessagePortData object had pending messages, this is
  // the easiest way to run that queue.
  port->TriggerAsync();
} else if (sibling_group) {
  sibling_group->Entangle(port->data_.get());
}
return port;
688}

690MaybeLocal<Value> MessagePort::ReceiveMessage(Local<Context> context,
                                            MessageProcessingMode mode,
                                            Local<Value>* port_list) {
std::shared_ptr<Message> received;
{
  // Get the head of the message queue.
  Mutex::ScopedLock lock(data_->mutex_);

  Debug(this, "MessagePort has message");

  bool wants_message =
      receiving_messages_ ||
      mode == MessageProcessingMode::kForceReadMessages;
  // We have nothing to do if:
  // - There are no pending messages
  // - We are not intending to receive messages, and the message we would
  //   receive is not the final "close" message.
  if (data_->incoming_messages_.empty() ||
      (!wants_message &&
       !data_->incoming_messages_.front()->IsCloseMessage())) {
    return env()->no_message_symbol();
  }

  received = data_->incoming_messages_.front();
  data_->incoming_messages_.pop_front();
}

if (received->IsCloseMessage()) {
  Close();
  return env()->no_message_symbol();
}

if (!env()->can_call_into_js()) return MaybeLocal<Value>();

return received->Deserialize(env(), context, port_list);
725}

727void MessagePort::OnMessage(MessageProcessingMode mode) {
Debug(this, "Running MessagePort::OnMessage()");
HandleScope handle_scope(env()->isolate());
Local<Context> context =
    object(env()->isolate())->GetCreationContext().ToLocalChecked();

size_t processing_limit;
if (mode == MessageProcessingMode::kNormalOperation) {
  Mutex::ScopedLock(data_->mutex_);
  processing_limit = std::max(data_->incoming_messages_.size(),
                              static_cast<size_t>(1000));
} else {
  processing_limit = std::numeric_limits<size_t>::max();
}

// data_ can only ever be modified by the owner thread, so no need to lock.
// However, the message port may be transferred while it is processing
// messages, so we need to check that this handle still owns its `data_` field
// on every iteration.
while (data_) {
  if (processing_limit-- == 0) {
    // Prevent event loop starvation by only processing those messages without
    // interruption that were already present when the OnMessage() call was
    // first triggered, but at least 1000 messages because otherwise the
    // overhead of repeatedly triggering the uv_async_t instance becomes
    // noticeable, at least on Windows.
    // (That might require more investigation by somebody more familiar with
    // Windows.)
    TriggerAsync();
    return;
  }

  HandleScope handle_scope(env()->isolate());
  Context::Scope context_scope(context);
  Local<Function> emit_message = PersistentToLocal::Strong(emit_message_fn_);

  Local<Value> payload;
  Local<Value> port_list = Undefined(env()->isolate());
  Local<Value> message_error;
  Local<Value> argv[3];

  {
    // Catch any exceptions from parsing the message itself (not from
    // emitting it) as 'messageeror' events.
    TryCatchScope try_catch(env());
    if (!ReceiveMessage(context, mode, &port_list).ToLocal(&payload)) {
      if (try_catch.HasCaught() && !try_catch.HasTerminated())
        message_error = try_catch.Exception();
      goto reschedule;
    }
  }
  if (payload == env()->no_message_symbol()) break;

  if (!env()->can_call_into_js()) {
    Debug(this, "MessagePort drains queue because !can_call_into_js()");
    // In this case there is nothing to do but to drain the current queue.
    continue;
  }

  argv[0] = payload;
  argv[1] = port_list;
  argv[2] = env()->message_string();

  if (MakeCallback(emit_message, arraysize(argv), argv).IsEmpty()) {
  reschedule:
    if (!message_error.IsEmpty()) {
      argv[0] = message_error;
      argv[1] = Undefined(env()->isolate());
      argv[2] = env()->messageerror_string();
      USE(MakeCallback(emit_message, arraysize(argv), argv));
    }

    // Re-schedule OnMessage() execution in case of failure.
    if (data_)
      TriggerAsync();
    return;
  }
}
805}

807void MessagePort::OnClose() {
Debug(this, "MessagePort::OnClose()");
if (data_) {
  // Detach() returns move(data_).
  Detach()->Disentangle();
}
813}

815std::unique_ptr<MessagePortData> MessagePort::Detach() {
CHECK(data_)do { if (__builtin_expect(!!(!(data_)), 0)) { do { static const
 node::AssertionInfo args = { "../src/node_messaging.cc" ":" "816"
, "data_", __PRETTY_FUNCTION__ }; node::Assert(args); } while
 (0); } } while (0);
Mutex::ScopedLock lock(data_->mutex_);
data_->owner_ = nullptr;
return std::move(data_);
820}

822BaseObject::TransferMode MessagePort::GetTransferMode() const {
if (IsDetached())
  return BaseObject::TransferMode::kUntransferable;
return BaseObject::TransferMode::kTransferable;
826}

828std::unique_ptr<TransferData> MessagePort::TransferForMessaging() {
Close();
return Detach();
831}

833BaseObjectPtr<BaseObject> MessagePortData::Deserialize(
  Environment* env,
  Local<Context> context,
  std::unique_ptr<TransferData> self) {
return BaseObjectPtr<MessagePort> { MessagePort::New(
    env, context,
    static_unique_pointer_cast<MessagePortData>(std::move(self))) };
840}

842Maybe<bool> MessagePort::PostMessage(Environment* env,
                                   Local<Context> context,
                                   Local<Value> message_v,
                                   const TransferList& transfer_v) {
Isolate* isolate = env->isolate();
Local<Object> obj = object(isolate);

std::shared_ptr<Message> msg = std::make_shared<Message>();

// Per spec, we need to both check if transfer list has the source port, and
// serialize the input message, even if the MessagePort is closed or detached.

Maybe<bool> serialization_maybe =
    msg->Serialize(env, context, message_v, transfer_v, obj);
if (data_ == nullptr) {
  return serialization_maybe;
}
if (serialization_maybe.IsNothing()) {
  return Nothing<bool>();
}

std::string error;
Maybe<bool> res = data_->Dispatch(msg, &error);
if (res.IsNothing())
  return res;

if (!error.empty())
  ProcessEmitWarning(env, error.c_str());

return res;
872}

874Maybe<bool> MessagePortData::Dispatch(
  std::shared_ptr<Message> message,
  std::string* error) {
if (!group_) {
  if (error != nullptr)
    *error = "MessagePortData is not entangled.";
  return Nothing<bool>();
}
return group_->Dispatch(this, message, error);
883}

885static Maybe<bool> ReadIterable(Environment* env,
                              Local<Context> context,
                              // NOLINTNEXTLINE(runtime/references)
                              TransferList& transfer_list,
                              Local<Value> object) {
if (!object->IsObject()) return Just(false);

if (object->IsArray()) {
  Local<Array> arr = object.As<Array>();
  size_t length = arr->Length();
  transfer_list.AllocateSufficientStorage(length);
  for (size_t i = 0; i < length; i++) {
    if (!arr->Get(context, i).ToLocal(&transfer_list[i]))
      return Nothing<bool>();
  }
  return Just(true);
}

Isolate* isolate = env->isolate();
Local<Value> iterator_method;
if (!object.As<Object>()->Get(context, Symbol::GetIterator(isolate))
    .ToLocal(&iterator_method)) return Nothing<bool>();
if (!iterator_method->IsFunction()) return Just(false);

Local<Value> iterator;
if (!iterator_method.As<Function>()->Call(context, object, 0, nullptr)
    .ToLocal(&iterator)) return Nothing<bool>();
if (!iterator->IsObject()) return Just(false);

Local<Value> next;
if (!iterator.As<Object>()->Get(context, env->next_string()).ToLocal(&next))
  return Nothing<bool>();
if (!next->IsFunction()) return Just(false);

std::vector<Local<Value>> entries;
while (env->can_call_into_js()) {
  Local<Value> result;
  if (!next.As<Function>()->Call(context, iterator, 0, nullptr)
      .ToLocal(&result)) return Nothing<bool>();
  if (!result->IsObject()) return Just(false);

  Local<Value> done;
  if (!result.As<Object>()->Get(context, env->done_string()).ToLocal(&done))
    return Nothing<bool>();
  if (done->BooleanValue(isolate)) break;

  Local<Value> val;
  if (!result.As<Object>()->Get(context, env->value_string()).ToLocal(&val))
    return Nothing<bool>();
  entries.push_back(val);
}

transfer_list.AllocateSufficientStorage(entries.size());
std::copy(entries.begin(), entries.end(), &transfer_list[0]);
return Just(true);
940}

942void MessagePort::PostMessage(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
Local<Object> obj = args.This();
Local<Context> context = obj->GetCreationContext().ToLocalChecked();

if (args.Length() == 0) {
  return THROW_ERR_MISSING_ARGS(env, "Not enough arguments to "
                                     "MessagePort.postMessage");
}

if (!args[1]->IsNullOrUndefined() && !args[1]->IsObject()) {
  // Browsers ignore null or undefined, and otherwise accept an array or an
  // options object.
  return THROW_ERR_INVALID_ARG_TYPE(env,
      "Optional transferList argument must be an iterable");
}

TransferList transfer_list;
if (args[1]->IsObject()) {
  bool was_iterable;
  if (!ReadIterable(env, context, transfer_list, args[1]).To(&was_iterable))
    return;
  if (!was_iterable) {
    Local<Value> transfer_option;
    if (!args[1].As<Object>()->Get(context, env->transfer_string())
        .ToLocal(&transfer_option)) return;
    if (!transfer_option->IsUndefined()) {
      if (!ReadIterable(env, context, transfer_list, transfer_option)
          .To(&was_iterable)) return;
      if (!was_iterable) {
        return THROW_ERR_INVALID_ARG_TYPE(env,
            "Optional options.transfer argument must be an iterable");
      }
    }
  }
}

MessagePort* port = Unwrap<MessagePort>(args.This());
// Even if the backing MessagePort object has already been deleted, we still
// want to serialize the message to ensure spec-compliant behavior w.r.t.
// transfers.
if (port == nullptr || port->IsHandleClosing()) {
  Message msg;
  USE(msg.Serialize(env, context, args[0], transfer_list, obj));
  return;
}

Maybe<bool> res = port->PostMessage(env, context, args[0], transfer_list);
if (res.IsJust())
  args.GetReturnValue().Set(res.FromJust());
992}

994void MessagePort::Start() {
Debug(this, "Start receiving messages");
receiving_messages_ = true;
Mutex::ScopedLock lock(data_->mutex_);
if (!data_->incoming_messages_.empty())
  TriggerAsync();
1000}

1002void MessagePort::Stop() {
Debug(this, "Stop receiving messages");
receiving_messages_ = false;
1005}

1007void MessagePort::Start(const FunctionCallbackInfo<Value>& args) {
MessagePort* port;
ASSIGN_OR_RETURN_UNWRAP(&port, args.This())do { *&port = static_cast<typename std::remove_reference
<decltype(*&port)>::type>( BaseObject::FromJSObject
(args.This())); if (*&port == nullptr) return ; } while (
0);
if (!port->data_) {
  return;
}
port->Start();
1014}

1016void MessagePort::Stop(const FunctionCallbackInfo<Value>& args) {
MessagePort* port;
CHECK(args[0]->IsObject())do { if (__builtin_expect(!!(!(args[0]->IsObject())), 0)) {
 do { static const node::AssertionInfo args = { "../src/node_messaging.cc"
 ":" "1018", "args[0]->IsObject()", __PRETTY_FUNCTION__ };
 node::Assert(args); } while (0); } } while (0);
ASSIGN_OR_RETURN_UNWRAP(&port, args[0].As<Object>())do { *&port = static_cast<typename std::remove_reference
<decltype(*&port)>::type>( BaseObject::FromJSObject
(args[0].As<Object>())); if (*&port == nullptr) return
 ; } while (0);
if (!port->data_) {
  return;
}
port->Stop();
1024}

1026void MessagePort::CheckType(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
args.GetReturnValue().Set(
    GetMessagePortConstructorTemplate(env)->HasInstance(args[0]));
1030}

1032void MessagePort::Drain(const FunctionCallbackInfo<Value>& args) {
MessagePort* port;
ASSIGN_OR_RETURN_UNWRAP(&port, args[0].As<Object>())do { *&port = static_cast<typename std::remove_reference
<decltype(*&port)>::type>( BaseObject::FromJSObject
(args[0].As<Object>())); if (*&port == nullptr) return
 ; } while (0);
port->OnMessage(MessageProcessingMode::kForceReadMessages);
1036}

1038void MessagePort::ReceiveMessage(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
if (!args[0]->IsObject() ||
    !env->message_port_constructor_template()->HasInstance(args[0])) {
  return THROW_ERR_INVALID_ARG_TYPE(env,
      "The \"port\" argument must be a MessagePort instance");
}
MessagePort* port = Unwrap<MessagePort>(args[0].As<Object>());
if (port == nullptr) {
  // Return 'no messages' for a closed port.
  args.GetReturnValue().Set(
      Environment::GetCurrent(args)->no_message_symbol());
  return;
}

MaybeLocal<Value> payload = port->ReceiveMessage(
    port->object()->GetCreationContext().ToLocalChecked(),
    MessageProcessingMode::kForceReadMessages);
if (!payload.IsEmpty())
  args.GetReturnValue().Set(payload.ToLocalChecked());
1058}

1060void MessagePort::MoveToContext(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
if (!args[0]->IsObject() ||
    !env->message_port_constructor_template()->HasInstance(args[0])) {
  return THROW_ERR_INVALID_ARG_TYPE(env,
      "The \"port\" argument must be a MessagePort instance");
}
MessagePort* port = Unwrap<MessagePort>(args[0].As<Object>());
if (port == nullptr || port->IsHandleClosing()) {
  Isolate* isolate = env->isolate();
  THROW_ERR_CLOSED_MESSAGE_PORT(isolate);
  return;
}

Local<Value> context_arg = args[1];
ContextifyContext* context_wrapper;
if (!context_arg->IsObject() ||
    (context_wrapper = ContextifyContext::ContextFromContextifiedSandbox(
        env, context_arg.As<Object>())) == nullptr) {
  return THROW_ERR_INVALID_ARG_TYPE(env, "Invalid context argument");
}

std::unique_ptr<MessagePortData> data;
if (!port->IsDetached())
  data = port->Detach();

Context::Scope context_scope(context_wrapper->context());
MessagePort* target =
    MessagePort::New(env, context_wrapper->context(), std::move(data));
if (target != nullptr)
  args.GetReturnValue().Set(target->object());
1091}

1093void MessagePort::Entangle(MessagePort* a, MessagePort* b) {
MessagePortData::Entangle(a->data_.get(), b->data_.get());
1095}

1097void MessagePort::Entangle(MessagePort* a, MessagePortData* b) {
MessagePortData::Entangle(a->data_.get(), b);
1099}

1101void MessagePort::MemoryInfo(MemoryTracker* tracker) const {
tracker->TrackField("data", data_);
tracker->TrackField("emit_message_fn", emit_message_fn_);
1104}

1106Local<FunctionTemplate> GetMessagePortConstructorTemplate(Environment* env) {
// Factor generating the MessagePort JS constructor into its own piece
// of code, because it is needed early on in the child environment setup.
Local<FunctionTemplate> templ = env->message_port_constructor_template();
if (!templ.IsEmpty())
  return templ;

{
  Local<FunctionTemplate> m = env->NewFunctionTemplate(MessagePort::New);
  m->SetClassName(env->message_port_constructor_string());
  m->InstanceTemplate()->SetInternalFieldCount(
      MessagePort::kInternalFieldCount);
  m->Inherit(HandleWrap::GetConstructorTemplate(env));

  env->SetProtoMethod(m, "postMessage", MessagePort::PostMessage);
  env->SetProtoMethod(m, "start", MessagePort::Start);

  env->set_message_port_constructor_template(m);
}

return GetMessagePortConstructorTemplate(env);
1127}

1129JSTransferable::JSTransferable(Environment* env, Local<Object> obj)
  : BaseObject(env, obj) {
MakeWeak();
1132}

1134void JSTransferable::New(const FunctionCallbackInfo<Value>& args) {
CHECK(args.IsConstructCall())do { if (__builtin_expect(!!(!(args.IsConstructCall())), 0)) {
 do { static const node::AssertionInfo args = { "../src/node_messaging.cc"
 ":" "1135", "args.IsConstructCall()", __PRETTY_FUNCTION__ };
 node::Assert(args); } while (0); } } while (0);
new JSTransferable(Environment::GetCurrent(args), args.This());
1137}

1139JSTransferable::TransferMode JSTransferable::GetTransferMode() const {
// Implement `kClone in this ? kCloneable : kTransferable`.
HandleScope handle_scope(env()->isolate());
errors::TryCatchScope ignore_exceptions(env());

bool has_clone;
if (!object()->Has(env()->context(),
                   env()->messaging_clone_symbol()).To(&has_clone)) {
  return TransferMode::kUntransferable;
}

return has_clone ? TransferMode::kCloneable : TransferMode::kTransferable;
1151}

1153std::unique_ptr<TransferData> JSTransferable::TransferForMessaging() {
return TransferOrClone(TransferMode::kTransferable);
1155}

1157std::unique_ptr<TransferData> JSTransferable::CloneForMessaging() const {
return TransferOrClone(TransferMode::kCloneable);
1159}

1161std::unique_ptr<TransferData> JSTransferable::TransferOrClone(
  TransferMode mode) const {
// Call `this[symbol]()` where `symbol` is `kClone` or `kTransfer`,
// which should return an object with `data` and `deserializeInfo` properties;
// `data` is written to the serializer later, and `deserializeInfo` is stored
// on the `TransferData` instance as a string.
HandleScope handle_scope(env()->isolate());
Local<Context> context = env()->isolate()->GetCurrentContext();
Local<Symbol> method_name = mode == TransferMode::kCloneable ?
    env()->messaging_clone_symbol() : env()->messaging_transfer_symbol();

Local<Value> method;
if (!object()->Get(context, method_name).ToLocal(&method)) {
  return {};
}
if (method->IsFunction()) {
  Local<Value> result_v;
  if (!method.As<Function>()->Call(
          context, object(), 0, nullptr).ToLocal(&result_v)) {
    return {};
  }

  if (result_v->IsObject()) {
    Local<Object> result = result_v.As<Object>();
    Local<Value> data;
    Local<Value> deserialize_info;
    if (!result->Get(context, env()->data_string()).ToLocal(&data) ||
        !result->Get(context, env()->deserialize_info_string())
            .ToLocal(&deserialize_info)) {
      return {};
    }
    Utf8Value deserialize_info_str(env()->isolate(), deserialize_info);
    if (*deserialize_info_str == nullptr) return {};
    return std::make_unique<Data>(
        *deserialize_info_str, Global<Value>(env()->isolate(), data));
  }
}

if (mode == TransferMode::kTransferable)
  return TransferOrClone(TransferMode::kCloneable);
else
  return {};
1203}

1205Maybe<BaseObjectList>
1206JSTransferable::NestedTransferables() const {
// Call `this[kTransferList]()` and return the resulting list of BaseObjects.
HandleScope handle_scope(env()->isolate());
Local<Context> context = env()->isolate()->GetCurrentContext();
Local<Symbol> method_name = env()->messaging_transfer_list_symbol();

Local<Value> method;
if (!object()->Get(context, method_name).ToLocal(&method)) {
  return Nothing<BaseObjectList>();
}
if (!method->IsFunction()) return Just(BaseObjectList {});

Local<Value> list_v;
if (!method.As<Function>()->Call(
        context, object(), 0, nullptr).ToLocal(&list_v)) {
  return Nothing<BaseObjectList>();
}
if (!list_v->IsArray()) return Just(BaseObjectList {});
Local<Array> list = list_v.As<Array>();

BaseObjectList ret;
for (size_t i = 0; i < list->Length(); i++) {
  Local<Value> value;
  if (!list->Get(context, i).ToLocal(&value))
    return Nothing<BaseObjectList>();
  if (env()->base_object_ctor_template()->HasInstance(value))
    ret.emplace_back(Unwrap<BaseObject>(value));
}
return Just(ret);
1235}

1237Maybe<bool> JSTransferable::FinalizeTransferRead(
  Local<Context> context, ValueDeserializer* deserializer) {
// Call `this[kDeserialize](data)` where `data` comes from the return value
// of `this[kTransfer]()` or `this[kClone]()`.
HandleScope handle_scope(env()->isolate());
Local<Value> data;
if (!deserializer->ReadValue(context).ToLocal(&data)) return Nothing<bool>();

Local<Symbol> method_name = env()->messaging_deserialize_symbol();
Local<Value> method;
if (!object()->Get(context, method_name).ToLocal(&method)) {
  return Nothing<bool>();
}
if (!method->IsFunction()) return Just(true);

if (method.As<Function>()->Call(context, object(), 1, &data).IsEmpty()) {
  return Nothing<bool>();
}
return Just(true);
1256}

1258JSTransferable::Data::Data(std::string&& deserialize_info,
                         v8::Global<v8::Value>&& data)
  : deserialize_info_(std::move(deserialize_info)),
    data_(std::move(data)) {}

1263BaseObjectPtr<BaseObject> JSTransferable::Data::Deserialize(
  Environment* env,
  Local<Context> context,
  std::unique_ptr<TransferData> self) {
// Create the JS wrapper object that will later be filled with data passed to
// the `[kDeserialize]()` method on it. This split is necessary, because here
// we need to create an object with the right prototype and internal fields,
// but the actual JS data stored in the serialized data can only be read at
// the end of the stream, after the main message has been read.

if (context != env->context()) {
  THROW_ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE(env);
  return {};
}
HandleScope handle_scope(env->isolate());
Local<Value> info;
if (!ToV8Value(context, deserialize_info_).ToLocal(&info)) return {};

Local<Value> ret;
CHECK(!env->messaging_deserialize_create_object().IsEmpty())do { if (__builtin_expect(!!(!(!env->messaging_deserialize_create_object
().IsEmpty())), 0)) { do { static const node::AssertionInfo args
 = { "../src/node_messaging.cc" ":" "1282", "!env->messaging_deserialize_create_object().IsEmpty()"
, __PRETTY_FUNCTION__ }; node::Assert(args); } while (0); } }
 while (0);
if (!env->messaging_deserialize_create_object()->Call(
        context, Null(env->isolate()), 1, &info).ToLocal(&ret) ||
    !env->base_object_ctor_template()->HasInstance(ret)) {
  return {};
}

return BaseObjectPtr<BaseObject> { Unwrap<BaseObject>(ret) };
1290}

1292Maybe<bool> JSTransferable::Data::FinalizeTransferWrite(
  Local<Context> context, ValueSerializer* serializer) {
HandleScope handle_scope(context->GetIsolate());
auto ret = serializer->WriteValue(context, PersistentToLocal::Strong(data_));
data_.Reset();
return ret;
1298}

1300std::shared_ptr<SiblingGroup> SiblingGroup::Get(const std::string& name) {
Mutex::ScopedLock lock(SiblingGroup::groups_mutex_);
std::shared_ptr<SiblingGroup> group;
auto i = groups_.find(name);
if (i == groups_.end() || i->second.expired()) {
  group = std::make_shared<SiblingGroup>(name);
  groups_[name] = group;
} else {
  group = i->second.lock();
}
return group;
1311}

1313void SiblingGroup::CheckSiblingGroup(const std::string& name) {
Mutex::ScopedLock lock(SiblingGroup::groups_mutex_);
auto i = groups_.find(name);
if (i != groups_.end() && i->second.expired())
  groups_.erase(name);
1318}

1320SiblingGroup::SiblingGroup(const std::string& name)
  : name_(name) { }

1323SiblingGroup::~SiblingGroup() {
// If this is a named group, check to see if we can remove the group
if (!name_.empty())
  CheckSiblingGroup(name_);
1327}

1329Maybe<bool> SiblingGroup::Dispatch(
  MessagePortData* source,
  std::shared_ptr<Message> message,
  std::string* error) {

RwLock::ScopedReadLock lock(group_mutex_);

// The source MessagePortData is not part of this group.
if (ports_.find(source) == ports_.end()) {
  if (error != nullptr)
    *error = "Source MessagePort is not entangled with this group.";
  return Nothing<bool>();
}

// There are no destination ports.
if (size() <= 1)
  return Just(false);

// Transferables cannot be used when there is more
// than a single destination.
if (size() > 2 && message->has_transferables()) {
  if (error != nullptr)
    *error = "Transferables cannot be used with multiple destinations.";
  return Nothing<bool>();
}

for (MessagePortData* port : ports_) {
  if (port == source)
    continue;
  // This loop should only be entered if there's only a single destination
  for (const auto& transferable : message->transferables()) {
    if (port == transferable.get()) {
      if (error != nullptr) {
        *error = "The target port was posted to itself, and the "
                 "communication channel was lost";
      }
      return Just(true);
    }
  }
  port->AddToIncomingQueue(message);
}

return Just(true);
1372}

1374void SiblingGroup::Entangle(MessagePortData* port) {
Entangle({ port });
1376}

1378void SiblingGroup::Entangle(std::initializer_list<MessagePortData*> ports) {
RwLock::ScopedWriteLock lock(group_mutex_);
for (MessagePortData* data : ports) {
  ports_.insert(data);
  CHECK(!data->group_)do { if (__builtin_expect(!!(!(!data->group_)), 0)) { do {
 static const node::AssertionInfo args = { "../src/node_messaging.cc"
 ":" "1382", "!data->group_", __PRETTY_FUNCTION__ }; node::
Assert(args); } while (0); } } while (0);
  data->group_ = shared_from_this();
}
1385}

1387void SiblingGroup::Disentangle(MessagePortData* data) {
auto self = shared_from_this();  // Keep alive until end of function.
RwLock::ScopedWriteLock lock(group_mutex_);
ports_.erase(data);
data->group_.reset();

data->AddToIncomingQueue(std::make_shared<Message>());
// If this is an anonymous group and there's another port, close it.
if (size() == 1 && name_.empty())
  (*(ports_.begin()))->AddToIncomingQueue(std::make_shared<Message>());
1397}

1399SiblingGroup::Map SiblingGroup::groups_;
1400Mutex SiblingGroup::groups_mutex_;

1402namespace {

1404static void SetDeserializerCreateObjectFunction(
  const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
CHECK(args[0]->IsFunction())do { if (__builtin_expect(!!(!(args[0]->IsFunction())), 0)
) { do { static const node::AssertionInfo args = { "../src/node_messaging.cc"
 ":" "1407", "args[0]->IsFunction()", __PRETTY_FUNCTION__ }
; node::Assert(args); } while (0); } } while (0);
env->set_messaging_deserialize_create_object(args[0].As<Function>());
1409}

1411static void MessageChannel(const FunctionCallbackInfo<Value>& args) {
Environment* env = Environment::GetCurrent(args);
if (!args.IsConstructCall()) {
1
Taking false branch→
  THROW_ERR_CONSTRUCT_CALL_REQUIRED(env);
  return;
}

Local<Context> context = args.This()->GetCreationContext().ToLocalChecked();
Context::Scope context_scope(context);

MessagePort* port1 = MessagePort::New(env, context);
if (port1 == nullptr) return;
2
←
Taking false branch→
MessagePort* port2 = MessagePort::New(env, context);
3
←
Calling 'MessagePort::New'→
if (port2 == nullptr) {
  port1->Close();
  return;
}

MessagePort::Entangle(port1, port2);

args.This()->Set(context, env->port1_string(), port1->object())
    .Check();
args.This()->Set(context, env->port2_string(), port2->object())
    .Check();
1435}

1437static void BroadcastChannel(const FunctionCallbackInfo<Value>& args) {
CHECK(args[0]->IsString())do { if (__builtin_expect(!!(!(args[0]->IsString())), 0)) {
 do { static const node::AssertionInfo args = { "../src/node_messaging.cc"
 ":" "1438", "args[0]->IsString()", __PRETTY_FUNCTION__ };
 node::Assert(args); } while (0); } } while (0);
Environment* env = Environment::GetCurrent(args);
Context::Scope context_scope(env->context());
Utf8Value name(env->isolate(), args[0]);
MessagePort* port =
    MessagePort::New(env, env->context(), {}, SiblingGroup::Get(*name));
if (port != nullptr) {
  args.GetReturnValue().Set(port->object());
}
1447}

1449static void InitMessaging(Local<Object> target,
                        Local<Value> unused,
                        Local<Context> context,
                        void* priv) {
Environment* env = Environment::GetCurrent(context);

{
  env->SetConstructorFunction(
      target,
      "MessageChannel",
      env->NewFunctionTemplate(MessageChannel));
}

{
  Local<FunctionTemplate> t = env->NewFunctionTemplate(JSTransferable::New);
  t->Inherit(BaseObject::GetConstructorTemplate(env));
  t->InstanceTemplate()->SetInternalFieldCount(
      JSTransferable::kInternalFieldCount);
  env->SetConstructorFunction(target, "JSTransferable", t);
}

env->SetConstructorFunction(
    target,
    env->message_port_constructor_string(),
    GetMessagePortConstructorTemplate(env));

// These are not methods on the MessagePort prototype, because
// the browser equivalents do not provide them.
env->SetMethod(target, "stopMessagePort", MessagePort::Stop);
env->SetMethod(target, "checkMessagePort", MessagePort::CheckType);
env->SetMethod(target, "drainMessagePort", MessagePort::Drain);
env->SetMethod(target, "receiveMessageOnPort", MessagePort::ReceiveMessage);
env->SetMethod(target, "moveMessagePortToContext",
               MessagePort::MoveToContext);
env->SetMethod(target, "setDeserializerCreateObjectFunction",
               SetDeserializerCreateObjectFunction);
env->SetMethod(target, "broadcastChannel", BroadcastChannel);

{
  Local<Function> domexception = GetDOMException(context).ToLocalChecked();
  target
      ->Set(context,
            FIXED_ONE_BYTE_STRING(env->isolate(), "DOMException"),
            domexception)
      .Check();
}
1495}

1497static void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
registry->Register(MessageChannel);
registry->Register(BroadcastChannel);
registry->Register(JSTransferable::New);
registry->Register(MessagePort::New);
registry->Register(MessagePort::PostMessage);
registry->Register(MessagePort::Start);
registry->Register(MessagePort::Stop);
registry->Register(MessagePort::CheckType);
registry->Register(MessagePort::Drain);
registry->Register(MessagePort::ReceiveMessage);
registry->Register(MessagePort::MoveToContext);
registry->Register(SetDeserializerCreateObjectFunction);
1510}

1512}  // anonymous namespace

1514}  // namespace worker
1515}  // namespace node

1517NODE_MODULE_CONTEXT_AWARE_INTERNAL(messaging, node::worker::InitMessaging)static node::node_module _module = { 108, NM_F_INTERNAL, nullptr
, "../src/node_messaging.cc", nullptr, (node::addon_context_register_func
)(node::worker::InitMessaging), "messaging", nullptr, nullptr
}; void _register_messaging() { node_module_register(&_module
); }
1518NODE_MODULE_EXTERNAL_REFERENCE(messaging,void _register_external_reference_messaging( node::ExternalReferenceRegistry
* registry) { node::worker::RegisterExternalReferences(registry
); }
                             node::worker::RegisterExternalReferences)void _register_external_reference_messaging( node::ExternalReferenceRegistry
* registry) { node::worker::RegisterExternalReferences(registry
); }

←

../src/node_messaging.h

1	#ifndef SRC_NODE_MESSAGING_H_
2	#define SRC_NODE_MESSAGING_H_
3
4	#if defined(NODE_WANT_INTERNALS1) && NODE_WANT_INTERNALS1
5
6	#include "env.h"
7	#include "node_mutex.h"
8	#include "v8.h"
9	#include <deque>
10	#include <string>
11	#include <unordered_map>
12	#include <set>
13
14	namespace node {
15	namespace worker {
16
17	class MessagePortData;
18	class MessagePort;
19
20	typedef MaybeStackBuffer<v8::Local<v8::Value>, 8> TransferList;
21
22	// Used to represent the in-flight structure of an object that is being
23	// transferred or cloned using postMessage().
24	class TransferData : public MemoryRetainer {
25	public:
26	// Deserialize this object on the receiving end after a .postMessage() call.
27	// - `context` may not be the same as `env->context()`. This method should
28	// not produce JS objects coming from Contexts other than `context`.
29	// - `self` is a unique_ptr for the object that this is being called on.
30	// - The return value is treated like a `Maybe`, i.e. if `nullptr` is
31	// returned, any further deserialization of the message is stopped and
32	// control is returned to the event loop or JS as soon as possible.
33	virtual BaseObjectPtr<BaseObject> Deserialize(
34	Environment* env,
35	v8::Local<v8::Context> context,
36	std::unique_ptr<TransferData> self) = 0;
37	// FinalizeTransferWrite() is the counterpart to
38	// BaseObject::FinalizeTransferRead(). It is called right after the transfer
39	// data was created, and defaults to doing nothing. After this function,
40	// this object should not hold any more Isolate-specific data.
41	virtual v8::Maybe<bool> FinalizeTransferWrite(
42	v8::Local<v8::Context> context, v8::ValueSerializer* serializer);
43	};
44
45	// Represents a single communication message.
46	class Message : public MemoryRetainer {
47	public:
48	// Create a Message with a specific underlying payload, in the format of the
49	// V8 ValueSerializer API. If `payload` is empty, this message indicates
50	// that the receiving message port should close itself.
51	explicit Message(MallocedBuffer<char>&& payload = MallocedBuffer<char>());
52	~Message() = default;
53
54	Message(Message&& other) = default;
55	Message& operator=(Message&& other) = default;
56	Message& operator=(const Message&) = delete;
57	Message(const Message&) = delete;
58
59	// Whether this is a message indicating that the port is to be closed.
60	// This is the last message to be received by a MessagePort.
61	bool IsCloseMessage() const;
62
63	// Deserialize the contained JS value. May only be called once, and only
64	// after Serialize() has been called (e.g. by another thread).
65	v8::MaybeLocal<v8::Value> Deserialize(
66	Environment* env,
67	v8::Local<v8::Context> context,
68	v8::Local<v8::Value>* port_list = nullptr);
69
70	// Serialize a JS value, and optionally transfer objects, into this message.
71	// The Message object retains ownership of all transferred objects until
72	// deserialization.
73	// The source_port parameter, if provided, will make Serialize() throw a
74	// "DataCloneError" DOMException if source_port is found in transfer_list.
75	v8::Maybe<bool> Serialize(Environment* env,
76	v8::Local<v8::Context> context,
77	v8::Local<v8::Value> input,
78	const TransferList& transfer_list,
79	v8::Local<v8::Object> source_port =
80	v8::Local<v8::Object>());
81
82	// Internal method of Message that is called when a new SharedArrayBuffer
83	// object is encountered in the incoming value's structure.
84	void AddSharedArrayBuffer(std::shared_ptr<v8::BackingStore> backing_store);
85	// Internal method of Message that is called once serialization finishes
86	// and that transfers ownership of `data` to this message.
87	void AddTransferable(std::unique_ptr<TransferData>&& data);
88	// Internal method of Message that is called when a new WebAssembly.Module
89	// object is encountered in the incoming value's structure.
90	uint32_t AddWASMModule(v8::CompiledWasmModule&& mod);
91
92	// The host objects that will be transferred, as recorded by Serialize()
93	// (e.g. MessagePorts).
94	// Used for warning user about posting the target MessagePort to itself,
95	// which will as a side effect destroy the communication channel.
96	const std::vector<std::unique_ptr<TransferData>>& transferables() const {
97	return transferables_;
98	}
99	bool has_transferables() const {
100	return !transferables_.empty() \|\| !array_buffers_.empty();
101	}
102
103	void MemoryInfo(MemoryTracker* tracker) const override;
104
105	SET_MEMORY_INFO_NAME(Message)inline std::string MemoryInfoName() const override { return "Message" ; }
106	SET_SELF_SIZE(Message)inline size_t SelfSize() const override { return sizeof(Message ); }
107
108	private:
109	MallocedBuffer<char> main_message_buf_;
110	// TODO(addaleax): Make this a std::variant to save storage size in the common
111	// case (which is that all of these vectors are empty) once that is available
112	// with C++17.
113	std::vector<std::shared_ptr<v8::BackingStore>> array_buffers_;
114	std::vector<std::shared_ptr<v8::BackingStore>> shared_array_buffers_;
115	std::vector<std::unique_ptr<TransferData>> transferables_;
116	std::vector<v8::CompiledWasmModule> wasm_modules_;
117
118	friend class MessagePort;
119	};
120
121	class SiblingGroup final : public std::enable_shared_from_this<SiblingGroup> {
122	public:
123	// Named SiblingGroup, Used for one-to-many BroadcastChannels.
124	static std::shared_ptr<SiblingGroup> Get(const std::string& name);
125
126	// Anonymous SiblingGroup, Used for one-to-one MessagePort pairs.
127	SiblingGroup() = default;
128	explicit SiblingGroup(const std::string& name);
129	~SiblingGroup();
130
131	// Dispatches the Message to the collection of associated
132	// ports. If there is more than one destination port and
133	// the Message contains transferables, Dispatch will fail.
134	// Returns Just(true) if successful and the message was
135	// dispatched to at least one destination. Returns Just(false)
136	// if there were no destinations. Returns Nothing<bool>()
137	// if there was an error. If error is not nullptr, it will
138	// be set to an error message or warning message as appropriate.
139	v8::Maybe<bool> Dispatch(
140	MessagePortData* source,
141	std::shared_ptr<Message> message,
142	std::string* error = nullptr);
143
144	void Entangle(MessagePortData* data);
145	void Entangle(std::initializer_list<MessagePortData*> data);
146	void Disentangle(MessagePortData* data);
147
148	const std::string& name() const { return name_; }
149
150	size_t size() const { return ports_.size(); }
151
152	private:
153	const std::string name_;
154	RwLock group_mutex_; // Protects ports_.
155	std::set<MessagePortData*> ports_;
156
157	static void CheckSiblingGroup(const std::string& name);
158
159	using Map =
160	std::unordered_map<std::string, std::weak_ptr<SiblingGroup>>;
161
162	static Mutex groups_mutex_;
163	static Map groups_;
164	};
165
166	// This contains all data for a `MessagePort` instance that is not tied to
167	// a specific Environment/Isolate/event loop, for easier transfer between those.
168	class MessagePortData : public TransferData {
169	public:
170	explicit MessagePortData(MessagePort* owner);
171	~MessagePortData() override;
172
173	MessagePortData(MessagePortData&& other) = delete;
174	MessagePortData& operator=(MessagePortData&& other) = delete;
175	MessagePortData(const MessagePortData& other) = delete;
176	MessagePortData& operator=(const MessagePortData& other) = delete;
177
178	// Add a message to the incoming queue and notify the receiver.
179	// This may be called from any thread.
180	void AddToIncomingQueue(std::shared_ptr<Message> message);
181	v8::Maybe<bool> Dispatch(
182	std::shared_ptr<Message> message,
183	std::string* error = nullptr);
184
185	// Turns `a` and `b` into siblings, i.e. connects the sending side of one
186	// to the receiving side of the other. This is not thread-safe.
187	static void Entangle(MessagePortData* a, MessagePortData* b);
188
189	// Removes any possible sibling. This is thread-safe (it acquires both
190	// `sibling_mutex_` and `mutex_`), and has to be because it is called once
191	// the corresponding JS handle handle wants to close
192	// which can happen on either side of a worker.
193	void Disentangle();
194
195	void MemoryInfo(MemoryTracker* tracker) const override;
196	BaseObjectPtr<BaseObject> Deserialize(
197	Environment* env,
198	v8::Local<v8::Context> context,
199	std::unique_ptr<TransferData> self) override;
200
201	SET_MEMORY_INFO_NAME(MessagePortData)inline std::string MemoryInfoName() const override { return "MessagePortData" ; }
202	SET_SELF_SIZE(MessagePortData)inline size_t SelfSize() const override { return sizeof(MessagePortData ); }
203
204	private:
205	// This mutex protects all fields below it, with the exception of
206	// sibling_.
207	mutable Mutex mutex_;
208	// TODO(addaleax): Make this a std::variant<std::shared_ptr, std::unique_ptr>
209	// once that is available with C++17, because std::shared_ptr comes with
210	// overhead that is only necessary for BroadcastChannel.
211	std::deque<std::shared_ptr<Message>> incoming_messages_;
212	MessagePort* owner_ = nullptr;
213	std::shared_ptr<SiblingGroup> group_;
214	friend class MessagePort;
215	friend class SiblingGroup;
216	};
217
218	// A message port that receives messages from other threads, including
219	// the uv_async_t handle that is used to notify the current event loop of
220	// new incoming messages.
221	class MessagePort : public HandleWrap {
222	private:
223	// Create a new MessagePort. The `context` argument specifies the Context
224	// instance that is used for creating the values emitted from this port.
225	// This is called by MessagePort::New(), which is the public API used for
226	// creating MessagePort instances.
227	MessagePort(Environment* env,
228	v8::Local<v8::Context> context,
229	v8::Local<v8::Object> wrap);
230
231	public:
232	~MessagePort() override;
233
234	// Create a new message port instance, optionally over an existing
235	// `MessagePortData` object.
236	static MessagePort* New(Environment* env,
237	v8::Local<v8::Context> context,
238	std::unique_ptr<MessagePortData> data = {},
239	std::shared_ptr<SiblingGroup> sibling_group = {});
240
241	// Send a message, i.e. deliver it into the sibling's incoming queue.
242	// If this port is closed, or if there is no sibling, this message is
243	// serialized with transfers, then silently discarded.
244	v8::Maybe<bool> PostMessage(Environment* env,
245	v8::Local<v8::Context> context,
246	v8::Local<v8::Value> message,
247	const TransferList& transfer);
248
249	// Start processing messages on this port as a receiving end.
250	void Start();
251	// Stop processing messages on this port as a receiving end.
252	void Stop();
253
254	/* constructor */
255	static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
256	/* prototype methods */
257	static void PostMessage(const v8::FunctionCallbackInfo<v8::Value>& args);
258	static void Start(const v8::FunctionCallbackInfo<v8::Value>& args);
259	static void Stop(const v8::FunctionCallbackInfo<v8::Value>& args);
260	static void CheckType(const v8::FunctionCallbackInfo<v8::Value>& args);
261	static void Drain(const v8::FunctionCallbackInfo<v8::Value>& args);
262	static void ReceiveMessage(const v8::FunctionCallbackInfo<v8::Value>& args);
263
264	/* static */
265	static void MoveToContext(const v8::FunctionCallbackInfo<v8::Value>& args);
266
267	// Turns `a` and `b` into siblings, i.e. connects the sending side of one
268	// to the receiving side of the other. This is not thread-safe.
269	static void Entangle(MessagePort* a, MessagePort* b);
270	static void Entangle(MessagePort* a, MessagePortData* b);
271
272	// Detach this port's data for transferring. After this, the MessagePortData
273	// is no longer associated with this handle, although it can still receive
274	// messages.
275	std::unique_ptr<MessagePortData> Detach();
276
277	void Close(
278	v8::Local<v8::Value> close_callback = v8::Local<v8::Value>()) override;
279
280	// Returns true if either data_ has been freed, or if the handle is being
281	// closed. Equivalent to the [[Detached]] internal slot in the HTML Standard.
282	//
283	// If checking if a JavaScript MessagePort object is detached, this method
284	// alone is often not enough, since the backing C++ MessagePort object may
285	// have been deleted already. For all intents and purposes, an object with a
286	// NULL pointer to the C++ MessagePort object is also detached.
287	inline bool IsDetached() const;
288
289	TransferMode GetTransferMode() const override;
290	std::unique_ptr<TransferData> TransferForMessaging() override;
291
292	void MemoryInfo(MemoryTracker* tracker) const override;
293	SET_MEMORY_INFO_NAME(MessagePort)inline std::string MemoryInfoName() const override { return "MessagePort" ; }
294	SET_SELF_SIZE(MessagePort)inline size_t SelfSize() const override { return sizeof(MessagePort ); }
295
296	private:
297	enum class MessageProcessingMode {
298	kNormalOperation,
299	kForceReadMessages
300	};
301
302	void OnClose() override;
303	void OnMessage(MessageProcessingMode mode);
304	void TriggerAsync();
305	v8::MaybeLocal<v8::Value> ReceiveMessage(
306	v8::Local<v8::Context> context,
307	MessageProcessingMode mode,
308	v8::Local<v8::Value>* port_list = nullptr);
309
310	std::unique_ptr<MessagePortData> data_ = nullptr;
311	bool receiving_messages_ = false;
312	uv_async_t async_;
313	v8::Global<v8::Function> emit_message_fn_;
314
315	friend class MessagePortData;
316	};
317
318	// Provide a base class from which JS classes that should be transferable or
319	// cloneable by postMesssage() can inherit.
320	// See e.g. FileHandle in internal/fs/promises.js for an example.
321	class JSTransferable : public BaseObject {
322	public:
323	JSTransferable(Environment* env, v8::Local<v8::Object> obj);
324	static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
325
326	TransferMode GetTransferMode() const override;
327	std::unique_ptr<TransferData> TransferForMessaging() override;
328	std::unique_ptr<TransferData> CloneForMessaging() const override;
329	v8::Maybe<std::vector<BaseObjectPtr<BaseObject>>>
330	NestedTransferables() const override;
331	v8::Maybe<bool> FinalizeTransferRead(
332	v8::Local<v8::Context> context,
333	v8::ValueDeserializer* deserializer) override;
334
335	SET_NO_MEMORY_INFO()inline void MemoryInfo(node::MemoryTracker* tracker) const override {}
336	SET_MEMORY_INFO_NAME(JSTransferable)inline std::string MemoryInfoName() const override { return "JSTransferable" ; }
337	SET_SELF_SIZE(JSTransferable)inline size_t SelfSize() const override { return sizeof(JSTransferable ); }
338
339	private:
340	std::unique_ptr<TransferData> TransferOrClone(TransferMode mode) const;
341
342	class Data : public TransferData {
343	public:
344	Data(std::string&& deserialize_info, v8::Global<v8::Value>&& data);
345
346	BaseObjectPtr<BaseObject> Deserialize(
347	Environment* env,
348	v8::Local<v8::Context> context,
349	std::unique_ptr<TransferData> self) override;
350	v8::Maybe<bool> FinalizeTransferWrite(
351	v8::Local<v8::Context> context,
352	v8::ValueSerializer* serializer) override;
353
354	SET_NO_MEMORY_INFO()inline void MemoryInfo(node::MemoryTracker* tracker) const override {}
355	SET_MEMORY_INFO_NAME(JSTransferableTransferData)inline std::string MemoryInfoName() const override { return "JSTransferableTransferData" ; }
356	SET_SELF_SIZE(Data)inline size_t SelfSize() const override { return sizeof(Data) ; }
357
358	private:
359	std::string deserialize_info_;
360	v8::Global<v8::Value> data_;
361	};
362	};
363
364	v8::Local<v8::FunctionTemplate> GetMessagePortConstructorTemplate(
365	Environment* env);
366
367	} // namespace worker
368	} // namespace node
369
370	#endif // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
371
372
373	#endif // SRC_NODE_MESSAGING_H_