Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

53 files changed, 4135 insertions, 0 deletions

diff --git a/dom/messagechannel/MessageChannel.cpp b/dom/messagechannel/MessageChannel.cpp
new file mode 100644
index 0000000000..bf95613082
--- /dev/null
+++ b/dom/messagechannel/MessageChannel.cpp
@@ -0,0 +1,89 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "MessageChannel.h"
+
+#include "mozilla/dom/MessageChannelBinding.h"
+#include "mozilla/dom/MessagePort.h"
+#include "mozilla/dom/Navigator.h"
+#include "mozilla/dom/WorkerRunnable.h"
+#include "mozilla/dom/Document.h"
+#include "nsIGlobalObject.h"
+#include "nsServiceManagerUtils.h"
+
+namespace mozilla::dom {
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(MessageChannel, mGlobal, mPort1, mPort2)
+NS_IMPL_CYCLE_COLLECTING_ADDREF(MessageChannel)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(MessageChannel)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(MessageChannel)
+  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+MessageChannel::MessageChannel(nsIGlobalObject* aGlobal) : mGlobal(aGlobal) {
+  MOZ_ASSERT(aGlobal);
+}
+
+MessageChannel::~MessageChannel() = default;
+
+JSObject* MessageChannel::WrapObject(JSContext* aCx,
+                                     JS::Handle<JSObject*> aGivenProto) {
+  return MessageChannel_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+/* static */
+already_AddRefed<MessageChannel> MessageChannel::Constructor(
+    const GlobalObject& aGlobal, ErrorResult& aRv) {
+  nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
+  return Constructor(global, aRv);
+}
+
+/* static */
+already_AddRefed<MessageChannel> MessageChannel::Constructor(
+    nsIGlobalObject* aGlobal, ErrorResult& aRv) {
+  MOZ_ASSERT(aGlobal);
+
+  nsID portUUID1;
+  aRv = nsID::GenerateUUIDInPlace(portUUID1);
+  if (aRv.Failed()) {
+    return nullptr;
+  }
+
+  nsID portUUID2;
+  aRv = nsID::GenerateUUIDInPlace(portUUID2);
+  if (aRv.Failed()) {
+    return nullptr;
+  }
+
+  RefPtr<MessageChannel> channel = new MessageChannel(aGlobal);
+
+  channel->mPort1 = MessagePort::Create(aGlobal, portUUID1, portUUID2, aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return nullptr;
+  }
+
+  channel->mPort2 = MessagePort::Create(aGlobal, portUUID2, portUUID1, aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return nullptr;
+  }
+
+  channel->mPort1->UnshippedEntangle(channel->mPort2);
+  channel->mPort2->UnshippedEntangle(channel->mPort1);
+
+  // MessagePorts should not work if created from a disconnected window.
+  nsCOMPtr<nsPIDOMWindowInner> window = do_QueryInterface(aGlobal);
+  if (window && !window->GetDocShell()) {
+    // The 2 ports are entangled. We can close one of them to close the other
+    // too.
+    channel->mPort1->CloseForced();
+  }
+
+  return channel.forget();
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/messagechannel/MessageChannel.h b/dom/messagechannel/MessageChannel.h
new file mode 100644
index 0000000000..a618bd4abd
--- /dev/null
+++ b/dom/messagechannel/MessageChannel.h
@@ -0,0 +1,58 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_dom_MessageChannel_h
+#define mozilla_dom_MessageChannel_h
+
+#include "mozilla/Attributes.h"
+#include "mozilla/dom/BindingDeclarations.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsWrapperCache.h"
+#include "nsCOMPtr.h"
+
+class nsIGlobalObject;
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+
+class MessagePort;
+
+class MessageChannel final : public nsISupports, public nsWrapperCache {
+ public:
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(MessageChannel)
+
+  nsIGlobalObject* GetParentObject() const { return mGlobal; }
+
+  virtual JSObject* WrapObject(JSContext* aCx,
+                               JS::Handle<JSObject*> aGivenProto) override;
+
+  static already_AddRefed<MessageChannel> Constructor(
+      const GlobalObject& aGlobal, ErrorResult& aRv);
+
+  static already_AddRefed<MessageChannel> Constructor(nsIGlobalObject* aGlobal,
+                                                      ErrorResult& aRv);
+
+  MessagePort* Port1() const { return mPort1; }
+
+  MessagePort* Port2() const { return mPort2; }
+
+ private:
+  explicit MessageChannel(nsIGlobalObject* aGlobal);
+  ~MessageChannel();
+
+  nsCOMPtr<nsIGlobalObject> mGlobal;
+
+  RefPtr<MessagePort> mPort1;
+  RefPtr<MessagePort> mPort2;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_MessageChannel_h
diff --git a/dom/messagechannel/MessagePort.cpp b/dom/messagechannel/MessagePort.cpp
new file mode 100644
index 0000000000..736909bc2d
--- /dev/null
+++ b/dom/messagechannel/MessagePort.cpp
@@ -0,0 +1,874 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "MessagePort.h"
+
+#include "MessageEvent.h"
+#include "MessagePortChild.h"
+#include "mozilla/dom/BlobBinding.h"
+#include "mozilla/dom/Event.h"
+#include "mozilla/dom/File.h"
+#include "mozilla/dom/MessageChannel.h"
+#include "mozilla/dom/MessageEventBinding.h"
+#include "mozilla/dom/MessagePortBinding.h"
+#include "mozilla/dom/MessagePortChild.h"
+#include "mozilla/dom/PMessagePort.h"
+#include "mozilla/dom/RootedDictionary.h"
+#include "mozilla/dom/ScriptSettings.h"
+#include "mozilla/dom/StructuredCloneTags.h"
+#include "mozilla/dom/WorkerCommon.h"
+#include "mozilla/dom/WorkerRef.h"
+#include "mozilla/dom/WorkerScope.h"
+#include "mozilla/ipc/BackgroundChild.h"
+#include "mozilla/dom/RefMessageBodyService.h"
+#include "mozilla/dom/SharedMessageBody.h"
+#include "mozilla/ipc/PBackgroundChild.h"
+#include "mozilla/MessagePortTimelineMarker.h"
+#include "mozilla/ScopeExit.h"
+#include "mozilla/TimelineConsumers.h"
+#include "mozilla/TimelineMarker.h"
+#include "mozilla/Unused.h"
+#include "nsContentUtils.h"
+#include "nsGlobalWindow.h"
+#include "nsPresContext.h"
+
+#ifdef XP_WIN
+#  undef PostMessage
+#endif
+
+namespace mozilla::dom {
+
+void UniqueMessagePortId::ForceClose() {
+  if (!mIdentifier.neutered()) {
+    MessagePort::ForceClose(mIdentifier);
+    mIdentifier.neutered() = true;
+  }
+}
+
+class PostMessageRunnable final : public CancelableRunnable {
+  friend class MessagePort;
+
+ public:
+  PostMessageRunnable(MessagePort* aPort, SharedMessageBody* aData)
+      : CancelableRunnable("dom::PostMessageRunnable"),
+        mPort(aPort),
+        mData(aData) {
+    MOZ_ASSERT(aPort);
+    MOZ_ASSERT(aData);
+  }
+
+  NS_IMETHOD
+  Run() override {
+    NS_ASSERT_OWNINGTHREAD(Runnable);
+
+    // The port can be cycle collected while this runnable is pending in
+    // the event queue.
+    if (!mPort) {
+      return NS_OK;
+    }
+
+    MOZ_ASSERT(mPort->mPostMessageRunnable == this);
+
+    DispatchMessage();
+
+    // We must check if we were waiting for this message in order to shutdown
+    // the port.
+    mPort->UpdateMustKeepAlive();
+
+    mPort->mPostMessageRunnable = nullptr;
+    mPort->Dispatch();
+
+    return NS_OK;
+  }
+
+  nsresult Cancel() override {
+    NS_ASSERT_OWNINGTHREAD(Runnable);
+
+    mPort = nullptr;
+    mData = nullptr;
+    return NS_OK;
+  }
+
+ private:
+  void DispatchMessage() const {
+    NS_ASSERT_OWNINGTHREAD(Runnable);
+
+    if (NS_FAILED(mPort->CheckCurrentGlobalCorrectness())) {
+      return;
+    }
+
+    nsCOMPtr<nsIGlobalObject> globalObject = mPort->GetParentObject();
+
+    AutoJSAPI jsapi;
+    if (!globalObject || !jsapi.Init(globalObject)) {
+      NS_WARNING("Failed to initialize AutoJSAPI object.");
+      return;
+    }
+
+    JSContext* cx = jsapi.cx();
+
+    IgnoredErrorResult rv;
+    JS::Rooted<JS::Value> value(cx);
+
+    UniquePtr<AbstractTimelineMarker> start;
+    UniquePtr<AbstractTimelineMarker> end;
+    bool isTimelineRecording = !TimelineConsumers::IsEmpty();
+
+    if (isTimelineRecording) {
+      start = MakeUnique<MessagePortTimelineMarker>(
+          ProfileTimelineMessagePortOperationType::DeserializeData,
+          MarkerTracingType::START);
+    }
+
+    mData->Read(cx, &value, mPort->mRefMessageBodyService,
+                SharedMessageBody::ReadMethod::StealRefMessageBody, rv);
+
+    if (isTimelineRecording) {
+      end = MakeUnique<MessagePortTimelineMarker>(
+          ProfileTimelineMessagePortOperationType::DeserializeData,
+          MarkerTracingType::END);
+      TimelineConsumers::AddMarkerForAllObservedDocShells(start);
+      TimelineConsumers::AddMarkerForAllObservedDocShells(end);
+    }
+
+    if (NS_WARN_IF(rv.Failed())) {
+      JS_ClearPendingException(cx);
+      mPort->DispatchError();
+      return;
+    }
+
+    // Create the event
+    nsCOMPtr<mozilla::dom::EventTarget> eventTarget =
+        do_QueryInterface(mPort->GetOwner());
+    RefPtr<MessageEvent> event =
+        new MessageEvent(eventTarget, nullptr, nullptr);
+
+    Sequence<OwningNonNull<MessagePort>> ports;
+    if (!mData->TakeTransferredPortsAsSequence(ports)) {
+      mPort->DispatchError();
+      return;
+    }
+
+    event->InitMessageEvent(nullptr, u"message"_ns, CanBubble::eNo,
+                            Cancelable::eNo, value, u""_ns, u""_ns, nullptr,
+                            ports);
+    event->SetTrusted(true);
+
+    mPort->DispatchEvent(*event);
+  }
+
+ private:
+  ~PostMessageRunnable() = default;
+
+  RefPtr<MessagePort> mPort;
+  RefPtr<SharedMessageBody> mData;
+};
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(MessagePort)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(MessagePort,
+                                                DOMEventTargetHelper)
+  if (tmp->mPostMessageRunnable) {
+    NS_IMPL_CYCLE_COLLECTION_UNLINK(mPostMessageRunnable->mPort);
+  }
+
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mMessagesForTheOtherPort);
+
+  tmp->CloseForced();
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(MessagePort,
+                                                  DOMEventTargetHelper)
+  if (tmp->mPostMessageRunnable) {
+    NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPostMessageRunnable->mPort);
+  }
+
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mUnshippedEntangledPort);
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(MessagePort)
+NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
+
+NS_IMPL_ADDREF_INHERITED(MessagePort, DOMEventTargetHelper)
+NS_IMPL_RELEASE_INHERITED(MessagePort, DOMEventTargetHelper)
+
+MessagePort::MessagePort(nsIGlobalObject* aGlobal, State aState)
+    : DOMEventTargetHelper(aGlobal),
+      mRefMessageBodyService(RefMessageBodyService::GetOrCreate()),
+      mState(aState),
+      mMessageQueueEnabled(false),
+      mIsKeptAlive(false),
+      mHasBeenTransferredOrClosed(false) {
+  MOZ_ASSERT(aGlobal);
+
+  mIdentifier = MakeUnique<MessagePortIdentifier>();
+  mIdentifier->neutered() = true;
+  mIdentifier->sequenceId() = 0;
+}
+
+MessagePort::~MessagePort() {
+  CloseForced();
+  MOZ_ASSERT(!mActor);
+  if (mActor) {
+    mActor->SetPort(nullptr);
+    mActor = nullptr;
+  }
+  MOZ_ASSERT(!mWorkerRef);
+}
+
+/* static */
+already_AddRefed<MessagePort> MessagePort::Create(nsIGlobalObject* aGlobal,
+                                                  const nsID& aUUID,
+                                                  const nsID& aDestinationUUID,
+                                                  ErrorResult& aRv) {
+  MOZ_ASSERT(aGlobal);
+
+  RefPtr<MessagePort> mp = new MessagePort(aGlobal, eStateUnshippedEntangled);
+  mp->Initialize(aUUID, aDestinationUUID, 1 /* 0 is an invalid sequence ID */,
+                 false /* Neutered */, aRv);
+  return mp.forget();
+}
+
+/* static */
+already_AddRefed<MessagePort> MessagePort::Create(
+    nsIGlobalObject* aGlobal, UniqueMessagePortId& aIdentifier,
+    ErrorResult& aRv) {
+  MOZ_ASSERT(aGlobal);
+
+  RefPtr<MessagePort> mp = new MessagePort(aGlobal, eStateEntangling);
+  mp->Initialize(aIdentifier.uuid(), aIdentifier.destinationUuid(),
+                 aIdentifier.sequenceId(), aIdentifier.neutered(), aRv);
+  aIdentifier.neutered() = true;
+  return mp.forget();
+}
+
+void MessagePort::UnshippedEntangle(MessagePort* aEntangledPort) {
+  MOZ_DIAGNOSTIC_ASSERT(aEntangledPort);
+  MOZ_DIAGNOSTIC_ASSERT(!mUnshippedEntangledPort);
+
+  mUnshippedEntangledPort = aEntangledPort;
+}
+
+void MessagePort::Initialize(const nsID& aUUID, const nsID& aDestinationUUID,
+                             uint32_t aSequenceID, bool aNeutered,
+                             ErrorResult& aRv) {
+  MOZ_ASSERT(mIdentifier);
+  mIdentifier->uuid() = aUUID;
+  mIdentifier->destinationUuid() = aDestinationUUID;
+  mIdentifier->sequenceId() = aSequenceID;
+
+  if (aNeutered) {
+    // If this port is neutered we don't want to keep it alive artificially nor
+    // we want to add listeners or WorkerRefs.
+    mState = eStateDisentangled;
+    return;
+  }
+
+  if (mState == eStateEntangling) {
+    if (!ConnectToPBackground()) {
+      aRv.Throw(NS_ERROR_FAILURE);
+      return;
+    }
+  } else {
+    MOZ_ASSERT(mState == eStateUnshippedEntangled);
+  }
+
+  // The port has to keep itself alive until it's entangled.
+  UpdateMustKeepAlive();
+
+  if (WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate()) {
+    RefPtr<MessagePort> self = this;
+
+    // When the callback is executed, we cannot process messages anymore because
+    // we cannot dispatch new runnables. Let's force a Close().
+    RefPtr<StrongWorkerRef> strongWorkerRef = StrongWorkerRef::Create(
+        workerPrivate, "MessagePort", [self]() { self->CloseForced(); });
+    if (NS_WARN_IF(!strongWorkerRef)) {
+      // The worker is shutting down.
+      CloseForced();
+      aRv.Throw(NS_ERROR_FAILURE);
+      return;
+    }
+
+    MOZ_ASSERT(!mWorkerRef);
+    mWorkerRef = std::move(strongWorkerRef);
+  }
+}
+
+JSObject* MessagePort::WrapObject(JSContext* aCx,
+                                  JS::Handle<JSObject*> aGivenProto) {
+  return MessagePort_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+void MessagePort::PostMessage(JSContext* aCx, JS::Handle<JS::Value> aMessage,
+                              const Sequence<JSObject*>& aTransferable,
+                              ErrorResult& aRv) {
+  // We *must* clone the data here, or the JS::Value could be modified
+  // by script
+
+  // Here we want to check if the transerable object list contains
+  // this port.
+  for (uint32_t i = 0; i < aTransferable.Length(); ++i) {
+    JS::Rooted<JSObject*> object(aCx, aTransferable[i]);
+    if (!object) {
+      continue;
+    }
+
+    MessagePort* port = nullptr;
+    nsresult rv = UNWRAP_OBJECT(MessagePort, &object, port);
+    if (NS_SUCCEEDED(rv) && port == this) {
+      aRv.Throw(NS_ERROR_DOM_DATA_CLONE_ERR);
+      return;
+    }
+  }
+
+  JS::Rooted<JS::Value> transferable(aCx, JS::UndefinedValue());
+
+  aRv = nsContentUtils::CreateJSValueFromSequenceOfObject(aCx, aTransferable,
+                                                          &transferable);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
+  }
+
+  Maybe<nsID> agentClusterId;
+  nsCOMPtr<nsIGlobalObject> global = GetOwnerGlobal();
+  if (global) {
+    agentClusterId = global->GetAgentClusterId();
+  }
+
+  RefPtr<SharedMessageBody> data = new SharedMessageBody(
+      StructuredCloneHolder::TransferringSupported, agentClusterId);
+
+  UniquePtr<AbstractTimelineMarker> start;
+  UniquePtr<AbstractTimelineMarker> end;
+  bool isTimelineRecording = !TimelineConsumers::IsEmpty();
+
+  if (isTimelineRecording) {
+    start = MakeUnique<MessagePortTimelineMarker>(
+        ProfileTimelineMessagePortOperationType::SerializeData,
+        MarkerTracingType::START);
+  }
+
+  data->Write(aCx, aMessage, transferable, mIdentifier->uuid(),
+              mRefMessageBodyService, aRv);
+
+  if (isTimelineRecording) {
+    end = MakeUnique<MessagePortTimelineMarker>(
+        ProfileTimelineMessagePortOperationType::SerializeData,
+        MarkerTracingType::END);
+    TimelineConsumers::AddMarkerForAllObservedDocShells(start);
+    TimelineConsumers::AddMarkerForAllObservedDocShells(end);
+  }
+
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
+  }
+
+  // This message has to be ignored.
+  if (mState > eStateEntangled) {
+    return;
+  }
+
+  // If we are unshipped we are connected to the other port on the same thread.
+  if (mState == eStateUnshippedEntangled) {
+    MOZ_DIAGNOSTIC_ASSERT(mUnshippedEntangledPort);
+    mUnshippedEntangledPort->mMessages.AppendElement(data);
+    mUnshippedEntangledPort->Dispatch();
+    return;
+  }
+
+  // Not entangled yet, but already closed/disentangled.
+  if (mState == eStateEntanglingForDisentangle ||
+      mState == eStateEntanglingForClose) {
+    return;
+  }
+
+  RemoveDocFromBFCache();
+
+  // Not entangled yet.
+  if (mState == eStateEntangling) {
+    mMessagesForTheOtherPort.AppendElement(data);
+    return;
+  }
+
+  MOZ_ASSERT(mActor);
+  MOZ_ASSERT(mMessagesForTheOtherPort.IsEmpty());
+
+  AutoTArray<RefPtr<SharedMessageBody>, 1> array;
+  array.AppendElement(data);
+
+  AutoTArray<MessageData, 1> messages;
+  // note: `messages` will borrow the underlying buffer, but this is okay
+  // because reverse destruction order means `messages` will be destroyed prior
+  // to `array`/`data`.
+  SharedMessageBody::FromSharedToMessagesChild(mActor->Manager(), array,
+                                               messages);
+  mActor->SendPostMessages(messages);
+}
+
+void MessagePort::PostMessage(JSContext* aCx, JS::Handle<JS::Value> aMessage,
+                              const StructuredSerializeOptions& aOptions,
+                              ErrorResult& aRv) {
+  PostMessage(aCx, aMessage, aOptions.mTransfer, aRv);
+}
+
+void MessagePort::Start() {
+  if (mMessageQueueEnabled) {
+    return;
+  }
+
+  mMessageQueueEnabled = true;
+  Dispatch();
+}
+
+void MessagePort::Dispatch() {
+  if (!mMessageQueueEnabled || mMessages.IsEmpty() || mPostMessageRunnable) {
+    return;
+  }
+
+  switch (mState) {
+    case eStateUnshippedEntangled:
+      // Everything is fine here. We have messages because the other
+      // port populates our queue directly.
+      break;
+
+    case eStateEntangling:
+      // Everything is fine here as well. We have messages because the other
+      // port populated our queue directly when we were in the
+      // eStateUnshippedEntangled state.
+      break;
+
+    case eStateEntanglingForDisentangle:
+      // Here we don't want to ship messages because these messages must be
+      // delivered by the cloned version of this one. They will be sent in the
+      // SendDisentangle().
+      return;
+
+    case eStateEntanglingForClose:
+      // We still want to deliver messages if we are closing. These messages
+      // are here from the previous eStateUnshippedEntangled state.
+      break;
+
+    case eStateEntangled:
+      // This port is up and running.
+      break;
+
+    case eStateDisentangling:
+      // If we are in the process to disentangle the port, we cannot dispatch
+      // messages. They will be sent to the cloned version of this port via
+      // SendDisentangle();
+      return;
+
+    case eStateDisentangled:
+      MOZ_CRASH("This cannot happen.");
+      // It cannot happen because Disentangle should take off all the pending
+      // messages.
+      break;
+
+    case eStateDisentangledForClose:
+      // If we are here is because the port has been closed. We can still
+      // process the pending messages.
+      break;
+  }
+
+  RefPtr<SharedMessageBody> data = mMessages.ElementAt(0);
+  mMessages.RemoveElementAt(0);
+
+  mPostMessageRunnable = new PostMessageRunnable(this, data);
+
+  nsCOMPtr<nsIGlobalObject> global = GetOwnerGlobal();
+  if (NS_IsMainThread() && global) {
+    MOZ_ALWAYS_SUCCEEDS(
+        global->Dispatch(TaskCategory::Other, do_AddRef(mPostMessageRunnable)));
+    return;
+  }
+
+  MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(mPostMessageRunnable));
+}
+
+void MessagePort::Close() {
+  mHasBeenTransferredOrClosed = true;
+  CloseInternal(true /* aSoftly */);
+}
+
+void MessagePort::CloseForced() { CloseInternal(false /* aSoftly */); }
+
+void MessagePort::CloseInternal(bool aSoftly) {
+  // If we have some messages to send but we don't want a 'soft' close, we have
+  // to flush them now.
+  if (!aSoftly) {
+    mMessages.Clear();
+  }
+
+  // Let's inform the RefMessageBodyService that any our shared messages are
+  // now invalid.
+  mRefMessageBodyService->ForgetPort(mIdentifier->uuid());
+
+  if (mState == eStateUnshippedEntangled) {
+    MOZ_DIAGNOSTIC_ASSERT(mUnshippedEntangledPort);
+
+    // This avoids loops.
+    RefPtr<MessagePort> port = std::move(mUnshippedEntangledPort);
+
+    mState = eStateDisentangledForClose;
+    port->CloseInternal(aSoftly);
+
+    UpdateMustKeepAlive();
+    return;
+  }
+
+  // Not entangled yet, we have to wait.
+  if (mState == eStateEntangling) {
+    mState = eStateEntanglingForClose;
+    return;
+  }
+
+  // Not entangled but already cloned or closed
+  if (mState == eStateEntanglingForDisentangle ||
+      mState == eStateEntanglingForClose) {
+    return;
+  }
+
+  // Maybe we were already closing the port but softly. In this case we call
+  // UpdateMustKeepAlive() to consider the empty pending message queue.
+  if (mState == eStateDisentangledForClose && !aSoftly) {
+    UpdateMustKeepAlive();
+    return;
+  }
+
+  if (mState > eStateEntangled) {
+    return;
+  }
+
+  // We don't care about stopping the sending of messages because from now all
+  // the incoming messages will be ignored.
+  mState = eStateDisentangledForClose;
+
+  MOZ_ASSERT(mActor);
+
+  mActor->SendClose();
+  mActor->SetPort(nullptr);
+  mActor = nullptr;
+
+  UpdateMustKeepAlive();
+}
+
+EventHandlerNonNull* MessagePort::GetOnmessage() {
+  return GetEventHandler(nsGkAtoms::onmessage);
+}
+
+void MessagePort::SetOnmessage(EventHandlerNonNull* aCallback) {
+  SetEventHandler(nsGkAtoms::onmessage, aCallback);
+
+  // When using onmessage, the call to start() is implied.
+  Start();
+}
+
+// This method is called when the PMessagePortChild actor is entangled to
+// another actor. It receives a list of messages to be dispatch. It can be that
+// we were waiting for this entangling step in order to disentangle the port or
+// to close it.
+void MessagePort::Entangled(nsTArray<MessageData>& aMessages) {
+  MOZ_ASSERT(mState == eStateEntangling ||
+             mState == eStateEntanglingForDisentangle ||
+             mState == eStateEntanglingForClose);
+
+  State oldState = mState;
+  mState = eStateEntangled;
+
+  // If we have pending messages, these have to be sent.
+  if (!mMessagesForTheOtherPort.IsEmpty()) {
+    {
+      nsTArray<MessageData> messages;
+      SharedMessageBody::FromSharedToMessagesChild(
+          mActor->Manager(), mMessagesForTheOtherPort, messages);
+      mActor->SendPostMessages(messages);
+    }
+    // Because `messages` borrow the underlying JSStructuredCloneData buffers,
+    // only clear after `messages` have gone out of scope.
+    mMessagesForTheOtherPort.Clear();
+  }
+
+  // We must convert the messages into SharedMessageBodys to avoid leaks.
+  FallibleTArray<RefPtr<SharedMessageBody>> data;
+  if (NS_WARN_IF(
+          !SharedMessageBody::FromMessagesToSharedChild(aMessages, data))) {
+    DispatchError();
+    return;
+  }
+
+  // If the next step is to close the port, we do it ignoring the received
+  // messages.
+  if (oldState == eStateEntanglingForClose) {
+    CloseForced();
+    return;
+  }
+
+  mMessages.AppendElements(data);
+
+  // We were waiting for the entangling callback in order to disentangle this
+  // port immediately after.
+  if (oldState == eStateEntanglingForDisentangle) {
+    StartDisentangling();
+    return;
+  }
+
+  Dispatch();
+}
+
+void MessagePort::StartDisentangling() {
+  MOZ_ASSERT(mActor);
+  MOZ_ASSERT(mState == eStateEntangled);
+
+  mState = eStateDisentangling;
+
+  // Sending this message we communicate to the parent actor that we don't want
+  // to receive any new messages. It is possible that a message has been
+  // already sent but not received yet. So we have to collect all of them and
+  // we send them in the SendDispatch() request.
+  mActor->SendStopSendingData();
+}
+
+void MessagePort::MessagesReceived(nsTArray<MessageData>& aMessages) {
+  MOZ_ASSERT(mState == eStateEntangled || mState == eStateDisentangling ||
+             // This last step can happen only if Close() has been called
+             // manually. At this point SendClose() is sent but we can still
+             // receive something until the Closing request is processed.
+             mState == eStateDisentangledForClose);
+  MOZ_ASSERT(mMessagesForTheOtherPort.IsEmpty());
+
+  RemoveDocFromBFCache();
+
+  FallibleTArray<RefPtr<SharedMessageBody>> data;
+  if (NS_WARN_IF(
+          !SharedMessageBody::FromMessagesToSharedChild(aMessages, data))) {
+    DispatchError();
+    return;
+  }
+
+  mMessages.AppendElements(data);
+
+  if (mState == eStateEntangled) {
+    Dispatch();
+  }
+}
+
+void MessagePort::StopSendingDataConfirmed() {
+  MOZ_ASSERT(mState == eStateDisentangling);
+  MOZ_ASSERT(mActor);
+
+  Disentangle();
+}
+
+void MessagePort::Disentangle() {
+  MOZ_ASSERT(mState == eStateDisentangling);
+  MOZ_ASSERT(mActor);
+
+  mState = eStateDisentangled;
+
+  {
+    nsTArray<MessageData> messages;
+    SharedMessageBody::FromSharedToMessagesChild(mActor->Manager(), mMessages,
+                                                 messages);
+    mActor->SendDisentangle(messages);
+  }
+
+  // Let's inform the RefMessageBodyService that any our shared messages are
+  // now invalid.
+  mRefMessageBodyService->ForgetPort(mIdentifier->uuid());
+
+  // Only clear mMessages after the MessageData instances have gone out of scope
+  // because they borrow mMessages' underlying JSStructuredCloneDatas.
+  mMessages.Clear();
+
+  mActor->SetPort(nullptr);
+  mActor = nullptr;
+
+  UpdateMustKeepAlive();
+}
+
+void MessagePort::CloneAndDisentangle(UniqueMessagePortId& aIdentifier) {
+  MOZ_ASSERT(mIdentifier);
+  MOZ_ASSERT(!mHasBeenTransferredOrClosed);
+
+  mHasBeenTransferredOrClosed = true;
+
+  // We can clone a port that has already been transfered. In this case, on the
+  // otherside will have a neutered port. Here we set neutered to true so that
+  // we are safe in case a early return.
+  aIdentifier.neutered() = true;
+
+  if (mState > eStateEntangled) {
+    return;
+  }
+
+  // We already have a 'next step'. We have to consider this port as already
+  // cloned/closed/disentangled.
+  if (mState == eStateEntanglingForDisentangle ||
+      mState == eStateEntanglingForClose) {
+    return;
+  }
+
+  aIdentifier.uuid() = mIdentifier->uuid();
+  aIdentifier.destinationUuid() = mIdentifier->destinationUuid();
+  aIdentifier.sequenceId() = mIdentifier->sequenceId() + 1;
+  aIdentifier.neutered() = false;
+
+  // We have to entangle first.
+  if (mState == eStateUnshippedEntangled) {
+    MOZ_ASSERT(mUnshippedEntangledPort);
+    MOZ_ASSERT(mMessagesForTheOtherPort.IsEmpty());
+
+    RefPtr<MessagePort> port = std::move(mUnshippedEntangledPort);
+
+    // Disconnect the entangled port and connect it to PBackground.
+    if (!port->ConnectToPBackground()) {
+      // We are probably shutting down. We cannot proceed.
+      mState = eStateDisentangled;
+      UpdateMustKeepAlive();
+      return;
+    }
+
+    // In this case, we don't need to be connected to the PBackground service.
+    if (mMessages.IsEmpty()) {
+      aIdentifier.sequenceId() = mIdentifier->sequenceId();
+
+      mState = eStateDisentangled;
+      UpdateMustKeepAlive();
+      return;
+    }
+
+    // Register this component to PBackground.
+    if (!ConnectToPBackground()) {
+      // We are probably shutting down. We cannot proceed.
+      return;
+    }
+
+    mState = eStateEntanglingForDisentangle;
+    return;
+  }
+
+  // Not entangled yet, we have to wait.
+  if (mState == eStateEntangling) {
+    mState = eStateEntanglingForDisentangle;
+    return;
+  }
+
+  MOZ_ASSERT(mState == eStateEntangled);
+  StartDisentangling();
+}
+
+void MessagePort::Closed() {
+  if (mState >= eStateDisentangled) {
+    return;
+  }
+
+  mState = eStateDisentangledForClose;
+
+  if (mActor) {
+    mActor->SetPort(nullptr);
+    mActor = nullptr;
+  }
+
+  UpdateMustKeepAlive();
+}
+
+bool MessagePort::ConnectToPBackground() {
+  RefPtr<MessagePort> self = this;
+  auto raii = MakeScopeExit([self] {
+    self->mState = eStateDisentangled;
+    self->UpdateMustKeepAlive();
+  });
+
+  mozilla::ipc::PBackgroundChild* actorChild =
+      mozilla::ipc::BackgroundChild::GetOrCreateForCurrentThread();
+  if (NS_WARN_IF(!actorChild)) {
+    return false;
+  }
+
+  PMessagePortChild* actor = actorChild->SendPMessagePortConstructor(
+      mIdentifier->uuid(), mIdentifier->destinationUuid(),
+      mIdentifier->sequenceId());
+  if (NS_WARN_IF(!actor)) {
+    return false;
+  }
+
+  mActor = static_cast<MessagePortChild*>(actor);
+  MOZ_ASSERT(mActor);
+
+  mActor->SetPort(this);
+  mState = eStateEntangling;
+
+  raii.release();
+  return true;
+}
+
+void MessagePort::UpdateMustKeepAlive() {
+  if (mState >= eStateDisentangled && mMessages.IsEmpty() && mIsKeptAlive) {
+    mIsKeptAlive = false;
+
+    // The DTOR of this WorkerRef will release the worker for us.
+    mWorkerRef = nullptr;
+
+    Release();
+    return;
+  }
+
+  if (mState < eStateDisentangled && !mIsKeptAlive) {
+    mIsKeptAlive = true;
+    AddRef();
+  }
+}
+
+void MessagePort::DisconnectFromOwner() {
+  CloseForced();
+  DOMEventTargetHelper::DisconnectFromOwner();
+}
+
+void MessagePort::RemoveDocFromBFCache() {
+  if (!NS_IsMainThread()) {
+    return;
+  }
+
+  if (nsPIDOMWindowInner* window = GetOwner()) {
+    window->RemoveFromBFCacheSync();
+  }
+}
+
+/* static */
+void MessagePort::ForceClose(const MessagePortIdentifier& aIdentifier) {
+  mozilla::ipc::PBackgroundChild* actorChild =
+      mozilla::ipc::BackgroundChild::GetOrCreateForCurrentThread();
+  if (NS_WARN_IF(!actorChild)) {
+    MOZ_CRASH("Failed to create a PBackgroundChild actor!");
+  }
+
+  Unused << actorChild->SendMessagePortForceClose(aIdentifier.uuid(),
+                                                  aIdentifier.destinationUuid(),
+                                                  aIdentifier.sequenceId());
+}
+
+void MessagePort::DispatchError() {
+  nsCOMPtr<nsIGlobalObject> globalObject = GetParentObject();
+
+  AutoJSAPI jsapi;
+  if (!globalObject || !jsapi.Init(globalObject)) {
+    NS_WARNING("Failed to initialize AutoJSAPI object.");
+    return;
+  }
+
+  RootedDictionary<MessageEventInit> init(jsapi.cx());
+  init.mBubbles = false;
+  init.mCancelable = false;
+
+  RefPtr<Event> event =
+      MessageEvent::Constructor(this, u"messageerror"_ns, init);
+  event->SetTrusted(true);
+
+  DispatchEvent(*event);
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/messagechannel/MessagePort.h b/dom/messagechannel/MessagePort.h
new file mode 100644
index 0000000000..b0365e6b81
--- /dev/null
+++ b/dom/messagechannel/MessagePort.h
@@ -0,0 +1,233 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_dom_MessagePort_h
+#define mozilla_dom_MessagePort_h
+
+#include "mozilla/Attributes.h"
+#include "mozilla/DOMEventTargetHelper.h"
+#include "mozilla/dom/DOMTypes.h"
+#include "mozilla/UniquePtr.h"
+#include "nsTArray.h"
+
+#ifdef XP_WIN
+#  undef PostMessage
+#endif
+
+class nsIGlobalObject;
+
+namespace mozilla::dom {
+
+class MessageData;
+class MessagePortChild;
+class PostMessageRunnable;
+class RefMessageBodyService;
+class SharedMessageBody;
+class StrongWorkerRef;
+struct StructuredSerializeOptions;
+
+// A class to hold a MessagePortIdentifier from
+// MessagePort::CloneAndDistentangle() and close if neither passed to
+// MessagePort::Create() nor release()ed to send via IPC.
+// When the `neutered` field of the MessagePortIdentifier is false, a close is
+// required.
+// This does not derive from MessagePortIdentifier because
+// MessagePortIdentifier is final and because use of UniqueMessagePortId as a
+// MessagePortIdentifier is intentionally prevented without release of
+// ownership.
+class UniqueMessagePortId final {
+ public:
+  UniqueMessagePortId() { mIdentifier.neutered() = true; }
+  explicit UniqueMessagePortId(const MessagePortIdentifier& aIdentifier)
+      : mIdentifier(aIdentifier) {}
+  UniqueMessagePortId(UniqueMessagePortId&& aOther) noexcept
+      : mIdentifier(aOther.mIdentifier) {
+    aOther.mIdentifier.neutered() = true;
+  }
+  ~UniqueMessagePortId() { ForceClose(); };
+  void ForceClose();
+
+  [[nodiscard]] MessagePortIdentifier release() {
+    MessagePortIdentifier id = mIdentifier;
+    mIdentifier.neutered() = true;
+    return id;
+  }
+  // const member accessors are not required because a const
+  // UniqueMessagePortId is not useful.
+  nsID& uuid() { return mIdentifier.uuid(); }
+  nsID& destinationUuid() { return mIdentifier.destinationUuid(); }
+  uint32_t& sequenceId() { return mIdentifier.sequenceId(); }
+  bool& neutered() { return mIdentifier.neutered(); }
+
+  UniqueMessagePortId(const UniqueMessagePortId& aOther) = delete;
+  void operator=(const UniqueMessagePortId& aOther) = delete;
+
+ private:
+  MessagePortIdentifier mIdentifier;
+};
+
+class MessagePort final : public DOMEventTargetHelper {
+  friend class PostMessageRunnable;
+
+ public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(MessagePort, DOMEventTargetHelper)
+
+  static already_AddRefed<MessagePort> Create(nsIGlobalObject* aGlobal,
+                                              const nsID& aUUID,
+                                              const nsID& aDestinationUUID,
+                                              ErrorResult& aRv);
+
+  static already_AddRefed<MessagePort> Create(nsIGlobalObject* aGlobal,
+                                              UniqueMessagePortId& aIdentifier,
+                                              ErrorResult& aRv);
+
+  // For IPC.
+  static void ForceClose(const MessagePortIdentifier& aIdentifier);
+
+  virtual JSObject* WrapObject(JSContext* aCx,
+                               JS::Handle<JSObject*> aGivenProto) override;
+
+  void PostMessage(JSContext* aCx, JS::Handle<JS::Value> aMessage,
+                   const Sequence<JSObject*>& aTransferable, ErrorResult& aRv);
+
+  void PostMessage(JSContext* aCx, JS::Handle<JS::Value> aMessage,
+                   const StructuredSerializeOptions& aOptions,
+                   ErrorResult& aRv);
+
+  void Start();
+
+  void Close();
+
+  EventHandlerNonNull* GetOnmessage();
+
+  void SetOnmessage(EventHandlerNonNull* aCallback);
+
+  IMPL_EVENT_HANDLER(messageerror)
+
+  // Non WebIDL methods
+
+  void UnshippedEntangle(MessagePort* aEntangledPort);
+
+  bool CanBeCloned() const { return !mHasBeenTransferredOrClosed; }
+
+  void CloneAndDisentangle(UniqueMessagePortId& aIdentifier);
+
+  void CloseForced();
+
+  // These methods are useful for MessagePortChild
+
+  void Entangled(nsTArray<MessageData>& aMessages);
+  void MessagesReceived(nsTArray<MessageData>& aMessages);
+  void StopSendingDataConfirmed();
+  void Closed();
+
+ private:
+  enum State {
+    // When a port is created by a MessageChannel it is entangled with the
+    // other. They both run on the same thread, same event loop and the
+    // messages are added to the queues without using PBackground actors.
+    // When one of the port is shipped, the state is changed to
+    // StateEntangling.
+    eStateUnshippedEntangled,
+
+    // If the port is closed or cloned when we are in this state, we go in one
+    // of the following 2 steps. EntanglingForClose or ForDisentangle.
+    eStateEntangling,
+
+    // We are not fully entangled yet but are already disentangled.
+    eStateEntanglingForDisentangle,
+
+    // We are not fully entangled yet but are already closed.
+    eStateEntanglingForClose,
+
+    // When entangled() is received we send all the messages in the
+    // mMessagesForTheOtherPort to the actor and we change the state to
+    // StateEntangled. At this point the port is entangled with the other. We
+    // send and receive messages.
+    // If the port queue is not enabled, the received messages are stored in
+    // the mMessages.
+    eStateEntangled,
+
+    // When the port is cloned or disentangled we want to stop receiving
+    // messages. We call 'SendStopSendingData' to the actor and we wait for an
+    // answer. All the messages received between now and the
+    // 'StopSendingDataComfirmed are queued in the mMessages but not
+    // dispatched.
+    eStateDisentangling,
+
+    // When 'StopSendingDataConfirmed' is received, we can disentangle the port
+    // calling SendDisentangle in the actor because we are 100% sure that we
+    // don't receive any other message, so nothing will be lost.
+    // Disentangling the port we send all the messages from the mMessages
+    // though the actor.
+    eStateDisentangled,
+
+    // We are here if Close() has been called. We are disentangled but we can
+    // still send pending messages.
+    eStateDisentangledForClose
+  };
+
+  explicit MessagePort(nsIGlobalObject* aGlobal, State aState);
+  ~MessagePort();
+
+  void DisconnectFromOwner() override;
+
+  void Initialize(const nsID& aUUID, const nsID& aDestinationUUID,
+                  uint32_t aSequenceID, bool aNeutered, ErrorResult& aRv);
+
+  bool ConnectToPBackground();
+
+  // Dispatch events from the Message Queue using a nsRunnable.
+  void Dispatch();
+
+  void DispatchError();
+
+  void StartDisentangling();
+  void Disentangle();
+
+  void RemoveDocFromBFCache();
+
+  void CloseInternal(bool aSoftly);
+
+  // This method is meant to keep alive the MessagePort when this object is
+  // creating the actor and until the actor is entangled.
+  // We release the object when the port is closed or disentangled.
+  void UpdateMustKeepAlive();
+
+  bool IsCertainlyAliveForCC() const override { return mIsKeptAlive; }
+
+  RefPtr<StrongWorkerRef> mWorkerRef;
+
+  RefPtr<PostMessageRunnable> mPostMessageRunnable;
+
+  RefPtr<MessagePortChild> mActor;
+
+  RefPtr<MessagePort> mUnshippedEntangledPort;
+
+  RefPtr<RefMessageBodyService> mRefMessageBodyService;
+
+  nsTArray<RefPtr<SharedMessageBody>> mMessages;
+  nsTArray<RefPtr<SharedMessageBody>> mMessagesForTheOtherPort;
+
+  UniquePtr<MessagePortIdentifier> mIdentifier;
+
+  State mState;
+
+  bool mMessageQueueEnabled;
+
+  bool mIsKeptAlive;
+
+  // mHasBeenTransferredOrClosed is used to know if this port has been manually
+  // closed or transferred via postMessage. Note that if the entangled port is
+  // closed, this port is closed as well (see mState) but, just because close()
+  // has not been called directly, by spec, this port can still be transferred.
+  bool mHasBeenTransferredOrClosed;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // mozilla_dom_MessagePort_h
diff --git a/dom/messagechannel/MessagePortChild.cpp b/dom/messagechannel/MessagePortChild.cpp
new file mode 100644
index 0000000000..2c5e270e68
--- /dev/null
+++ b/dom/messagechannel/MessagePortChild.cpp
@@ -0,0 +1,46 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "MessagePortChild.h"
+#include "MessagePort.h"
+#include "mozilla/dom/MessageEvent.h"
+#include "mozilla/ipc/PBackgroundChild.h"
+
+namespace mozilla::dom {
+
+MessagePortChild::MessagePortChild() : mPort(nullptr) {}
+
+mozilla::ipc::IPCResult MessagePortChild::RecvStopSendingDataConfirmed() {
+  MOZ_ASSERT(mPort);
+  mPort->StopSendingDataConfirmed();
+  MOZ_ASSERT(!mPort);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult MessagePortChild::RecvEntangled(
+    nsTArray<MessageData>&& aMessages) {
+  if (mPort) {
+    mPort->Entangled(aMessages);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult MessagePortChild::RecvReceiveData(
+    nsTArray<MessageData>&& aMessages) {
+  if (mPort) {
+    mPort->MessagesReceived(aMessages);
+  }
+  return IPC_OK();
+}
+
+void MessagePortChild::ActorDestroy(ActorDestroyReason aWhy) {
+  if (mPort) {
+    mPort->Closed();
+    MOZ_ASSERT(!mPort);
+  }
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/messagechannel/MessagePortChild.h b/dom/messagechannel/MessagePortChild.h
new file mode 100644
index 0000000000..74f3683f52
--- /dev/null
+++ b/dom/messagechannel/MessagePortChild.h
@@ -0,0 +1,45 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_dom_MessagePortChild_h
+#define mozilla_dom_MessagePortChild_h
+
+#include "mozilla/Assertions.h"
+#include "mozilla/dom/PMessagePortChild.h"
+#include "nsISupportsImpl.h"
+
+namespace mozilla::dom {
+
+class MessagePort;
+
+class MessagePortChild final : public PMessagePortChild {
+  friend class PMessagePortChild;
+
+ public:
+  NS_INLINE_DECL_REFCOUNTING(MessagePortChild)
+
+  MessagePortChild();
+
+  void SetPort(MessagePort* aPort) { mPort = aPort; }
+
+ private:
+  ~MessagePortChild() { MOZ_ASSERT(!mPort); }
+
+  mozilla::ipc::IPCResult RecvEntangled(nsTArray<MessageData>&& aMessages);
+
+  mozilla::ipc::IPCResult RecvReceiveData(nsTArray<MessageData>&& aMessages);
+
+  mozilla::ipc::IPCResult RecvStopSendingDataConfirmed();
+
+  virtual void ActorDestroy(ActorDestroyReason aWhy) override;
+
+  // This is a raw pointer because this child is owned by this MessagePort.
+  MessagePort* mPort;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // mozilla_dom_MessagePortChild_h
diff --git a/dom/messagechannel/MessagePortParent.cpp b/dom/messagechannel/MessagePortParent.cpp
new file mode 100644
index 0000000000..846f1c2cda
--- /dev/null
+++ b/dom/messagechannel/MessagePortParent.cpp
@@ -0,0 +1,178 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "MessagePortParent.h"
+#include "MessagePortService.h"
+#include "mozilla/dom/RefMessageBodyService.h"
+#include "mozilla/dom/SharedMessageBody.h"
+#include "mozilla/Unused.h"
+
+namespace mozilla::dom {
+
+MessagePortParent::MessagePortParent(const nsID& aUUID)
+    : mService(MessagePortService::GetOrCreate()),
+      mUUID(aUUID),
+      mEntangled(false),
+      mCanSendData(true) {
+  MOZ_ASSERT(mService);
+}
+
+MessagePortParent::~MessagePortParent() {
+  MOZ_ASSERT(!mService);
+  MOZ_ASSERT(!mEntangled);
+}
+
+bool MessagePortParent::Entangle(const nsID& aDestinationUUID,
+                                 const uint32_t& aSequenceID) {
+  if (!mService) {
+    NS_WARNING("Entangle is called after a shutdown!");
+    return false;
+  }
+
+  MOZ_ASSERT(!mEntangled);
+
+  return mService->RequestEntangling(this, aDestinationUUID, aSequenceID);
+}
+
+mozilla::ipc::IPCResult MessagePortParent::RecvPostMessages(
+    nsTArray<MessageData>&& aMessages) {
+  if (!mService) {
+    NS_WARNING("PostMessages is called after a shutdown!");
+    // This implies most probably that CloseAndDelete() has been already called
+    // such that we have no better option than to silently ignore this call.
+    return IPC_OK();
+  }
+
+  if (!mEntangled) {
+    // If we were shut down, the above condition already bailed out. So this
+    // should actually never happen and returning a failure is fine.
+    return IPC_FAIL(this, "RecvPostMessages not entangled");
+  }
+
+  // This converts the object in a data struct where we have BlobImpls.
+  FallibleTArray<RefPtr<SharedMessageBody>> messages;
+  if (NS_WARN_IF(!SharedMessageBody::FromMessagesToSharedParent(aMessages,
+                                                                messages))) {
+    // FromMessagesToSharedParent() returns false only if the array allocation
+    // failed.
+    // See bug 1750497 for further discussion if this is the wanted behavior.
+    return IPC_FAIL(this, "SharedMessageBody::FromMessagesToSharedParent");
+  }
+
+  if (messages.IsEmpty()) {
+    // An empty payload can be safely ignored.
+    return IPC_OK();
+  }
+
+  if (!mService->PostMessages(this, std::move(messages))) {
+    // TODO: Verify if all failure conditions of PostMessages() merit an
+    // IPC_FAIL. See bug 1750499.
+    return IPC_FAIL(this, "RecvPostMessages->PostMessages");
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult MessagePortParent::RecvDisentangle(
+    nsTArray<MessageData>&& aMessages) {
+  if (!mService) {
+    NS_WARNING("Entangle is called after a shutdown!");
+    // This implies most probably that CloseAndDelete() has been already called
+    // such that we can silently ignore this call.
+    return IPC_OK();
+  }
+
+  if (!mEntangled) {
+    // If we were shut down, the above condition already bailed out. So this
+    // should actually never happen and returning a failure is fine.
+    return IPC_FAIL(this, "RecvDisentangle not entangled");
+  }
+
+  // This converts the object in a data struct where we have BlobImpls.
+  FallibleTArray<RefPtr<SharedMessageBody>> messages;
+  if (NS_WARN_IF(!SharedMessageBody::FromMessagesToSharedParent(aMessages,
+                                                                messages))) {
+    // TODO: Verify if failed allocations merit an IPC_FAIL. See bug 1750497.
+    return IPC_FAIL(this, "SharedMessageBody::FromMessagesToSharedParent");
+  }
+
+  if (!mService->DisentanglePort(this, std::move(messages))) {
+    // TODO: Verify if all failure conditions of DisentanglePort() merit an
+    // IPC_FAIL. See bug 1750501.
+    return IPC_FAIL(this, "RecvDisentangle->DisentanglePort");
+  }
+
+  CloseAndDelete();
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult MessagePortParent::RecvStopSendingData() {
+  if (!mEntangled) {
+    return IPC_OK();
+  }
+
+  mCanSendData = false;
+  Unused << SendStopSendingDataConfirmed();
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult MessagePortParent::RecvClose() {
+  if (mService) {
+    MOZ_ASSERT(mEntangled);
+
+    if (!mService->ClosePort(this)) {
+      return IPC_FAIL(this, "RecvClose->ClosePort");
+    }
+
+    Close();
+  }
+
+  MOZ_ASSERT(!mEntangled);
+
+  Unused << Send__delete__(this);
+  return IPC_OK();
+}
+
+void MessagePortParent::ActorDestroy(ActorDestroyReason aWhy) {
+  if (mService && mEntangled) {
+    // When the last parent is deleted, this service is freed but this cannot
+    // be done when the hashtables are written by CloseAll.
+    RefPtr<MessagePortService> kungFuDeathGrip = mService;
+    kungFuDeathGrip->ParentDestroy(this);
+  }
+}
+
+bool MessagePortParent::Entangled(nsTArray<MessageData>&& aMessages) {
+  MOZ_ASSERT(!mEntangled);
+  mEntangled = true;
+  return SendEntangled(aMessages);
+}
+
+void MessagePortParent::CloseAndDelete() {
+  Close();
+  Unused << Send__delete__(this);
+}
+
+void MessagePortParent::Close() {
+  mService = nullptr;
+  mEntangled = false;
+}
+
+/* static */
+bool MessagePortParent::ForceClose(const nsID& aUUID,
+                                   const nsID& aDestinationUUID,
+                                   const uint32_t& aSequenceID) {
+  MessagePortService* service = MessagePortService::Get();
+  if (!service) {
+    NS_WARNING(
+        "The service must exist if we want to close an existing MessagePort.");
+    // There is nothing to close so we are ok.
+    return true;
+  }
+
+  return service->ForceClose(aUUID, aDestinationUUID, aSequenceID);
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/messagechannel/MessagePortParent.h b/dom/messagechannel/MessagePortParent.h
new file mode 100644
index 0000000000..13c92a1ef6
--- /dev/null
+++ b/dom/messagechannel/MessagePortParent.h
@@ -0,0 +1,61 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_dom_MessagePortParent_h
+#define mozilla_dom_MessagePortParent_h
+
+#include "mozilla/WeakPtr.h"
+#include "mozilla/dom/PMessagePortParent.h"
+#include "mozilla/dom/quota/CheckedUnsafePtr.h"
+
+namespace mozilla::dom {
+
+class MessagePortService;
+
+class MessagePortParent final
+    : public PMessagePortParent,
+      public SupportsWeakPtr,
+      public SupportsCheckedUnsafePtr<CheckIf<DiagnosticAssertEnabled>> {
+  friend class PMessagePortParent;
+
+ public:
+  explicit MessagePortParent(const nsID& aUUID);
+  ~MessagePortParent();
+
+  bool Entangle(const nsID& aDestinationUUID, const uint32_t& aSequenceID);
+
+  bool Entangled(nsTArray<MessageData>&& aMessages);
+
+  void Close();
+  void CloseAndDelete();
+
+  bool CanSendData() const { return mCanSendData; }
+
+  const nsID& ID() const { return mUUID; }
+
+  static bool ForceClose(const nsID& aUUID, const nsID& aDestinationUUID,
+                         const uint32_t& aSequenceID);
+
+ private:
+  mozilla::ipc::IPCResult RecvPostMessages(nsTArray<MessageData>&& aMessages);
+
+  mozilla::ipc::IPCResult RecvDisentangle(nsTArray<MessageData>&& aMessages);
+
+  mozilla::ipc::IPCResult RecvStopSendingData();
+
+  mozilla::ipc::IPCResult RecvClose();
+
+  virtual void ActorDestroy(ActorDestroyReason aWhy) override;
+
+  RefPtr<MessagePortService> mService;
+  const nsID mUUID;
+  bool mEntangled;
+  bool mCanSendData;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // mozilla_dom_MessagePortParent_h
diff --git a/dom/messagechannel/MessagePortService.cpp b/dom/messagechannel/MessagePortService.cpp
new file mode 100644
index 0000000000..3b45102e75
--- /dev/null
+++ b/dom/messagechannel/MessagePortService.cpp
@@ -0,0 +1,404 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "MessagePortService.h"
+#include "MessagePortParent.h"
+#include "mozilla/dom/RefMessageBodyService.h"
+#include "mozilla/dom/SharedMessageBody.h"
+#include "mozilla/dom/quota/CheckedUnsafePtr.h"
+#include "mozilla/ipc/BackgroundParent.h"
+#include "mozilla/StaticPtr.h"
+#include "mozilla/Unused.h"
+#include "mozilla/WeakPtr.h"
+#include "nsTArray.h"
+
+using mozilla::ipc::AssertIsOnBackgroundThread;
+
+namespace mozilla::dom {
+
+namespace {
+
+StaticRefPtr<MessagePortService> gInstance;
+
+void AssertIsInMainProcess() {
+  MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_Default);
+}
+
+}  // namespace
+
+struct MessagePortService::NextParent {
+  uint32_t mSequenceID;
+  // MessagePortParent keeps the service alive, and we don't want a cycle.
+  WeakPtr<MessagePortParent> mParent;
+};
+
+}  // namespace mozilla::dom
+
+namespace mozilla::dom {
+
+class MessagePortService::MessagePortServiceData final {
+ public:
+  explicit MessagePortServiceData(const nsID& aDestinationUUID)
+      : mDestinationUUID(aDestinationUUID),
+        mSequenceID(1),
+        mParent(nullptr)
+        // By default we don't know the next parent.
+        ,
+        mWaitingForNewParent(true),
+        mNextStepCloseAll(false) {
+    MOZ_COUNT_CTOR(MessagePortServiceData);
+  }
+
+  MessagePortServiceData(const MessagePortServiceData& aOther) = delete;
+  MessagePortServiceData& operator=(const MessagePortServiceData&) = delete;
+
+  MOZ_COUNTED_DTOR(MessagePortServiceData)
+
+  nsID mDestinationUUID;
+
+  uint32_t mSequenceID;
+  CheckedUnsafePtr<MessagePortParent> mParent;
+
+  FallibleTArray<NextParent> mNextParents;
+  FallibleTArray<RefPtr<SharedMessageBody>> mMessages;
+
+  bool mWaitingForNewParent;
+  bool mNextStepCloseAll;
+};
+
+/* static */
+MessagePortService* MessagePortService::Get() {
+  AssertIsInMainProcess();
+  AssertIsOnBackgroundThread();
+
+  return gInstance;
+}
+
+/* static */
+MessagePortService* MessagePortService::GetOrCreate() {
+  AssertIsInMainProcess();
+  AssertIsOnBackgroundThread();
+
+  if (!gInstance) {
+    gInstance = new MessagePortService();
+  }
+
+  return gInstance;
+}
+
+bool MessagePortService::RequestEntangling(MessagePortParent* aParent,
+                                           const nsID& aDestinationUUID,
+                                           const uint32_t& aSequenceID) {
+  MOZ_ASSERT(aParent);
+  MessagePortServiceData* data;
+
+  // If we don't have a MessagePortServiceData, we must create 2 of them for
+  // both ports.
+  if (!mPorts.Get(aParent->ID(), &data)) {
+    // Create the MessagePortServiceData for the destination.
+    if (mPorts.Get(aDestinationUUID, nullptr)) {
+      MOZ_ASSERT(false, "The creation of the 2 ports should be in sync.");
+      return false;
+    }
+
+    mPorts.InsertOrUpdate(aDestinationUUID,
+                          MakeUnique<MessagePortServiceData>(aParent->ID()));
+
+    data = mPorts
+               .InsertOrUpdate(
+                   aParent->ID(),
+                   MakeUnique<MessagePortServiceData>(aDestinationUUID))
+               .get();
+  }
+
+  // This is a security check.
+  if (!data->mDestinationUUID.Equals(aDestinationUUID)) {
+    MOZ_ASSERT(false, "DestinationUUIDs do not match!");
+    CloseAll(aParent->ID());
+    return false;
+  }
+
+  if (aSequenceID < data->mSequenceID) {
+    MOZ_ASSERT(false, "Invalid sequence ID!");
+    CloseAll(aParent->ID());
+    return false;
+  }
+
+  if (aSequenceID == data->mSequenceID) {
+    if (data->mParent) {
+      MOZ_ASSERT(false, "Two ports cannot have the same sequenceID.");
+      CloseAll(aParent->ID());
+      return false;
+    }
+
+    // We activate this port, sending all the messages.
+    data->mParent = aParent;
+    data->mWaitingForNewParent = false;
+
+    // We want to ensure we clear data->mMessages even if we early return, while
+    // also ensuring that its contents remain alive until after array's contents
+    // are destroyed because of JSStructuredCloneData borrowing.  So we use
+    // Move to initialize things swapped and do it before we declare `array` so
+    // that reverse destruction order works for us.
+    FallibleTArray<RefPtr<SharedMessageBody>> messages(
+        std::move(data->mMessages));
+    nsTArray<MessageData> array;
+    if (!SharedMessageBody::FromSharedToMessagesParent(aParent->Manager(),
+                                                       messages, array)) {
+      CloseAll(aParent->ID());
+      return false;
+    }
+
+    // We can entangle the port.
+    if (!aParent->Entangled(std::move(array))) {
+      CloseAll(aParent->ID());
+      return false;
+    }
+
+    // If we were waiting for this parent in order to close this channel, this
+    // is the time to do it.
+    if (data->mNextStepCloseAll) {
+      CloseAll(aParent->ID());
+    }
+
+    return true;
+  }
+
+  // This new parent will be the next one when a Disentangle request is
+  // received from the current parent.
+  auto nextParent = data->mNextParents.AppendElement(mozilla::fallible);
+  if (!nextParent) {
+    CloseAll(aParent->ID());
+    return false;
+  }
+
+  nextParent->mSequenceID = aSequenceID;
+  nextParent->mParent = aParent;
+
+  return true;
+}
+
+bool MessagePortService::DisentanglePort(
+    MessagePortParent* aParent,
+    FallibleTArray<RefPtr<SharedMessageBody>> aMessages) {
+  MessagePortServiceData* data;
+  if (!mPorts.Get(aParent->ID(), &data)) {
+    MOZ_ASSERT(false, "Unknown MessagePortParent should not happen.");
+    return false;
+  }
+
+  if (data->mParent != aParent) {
+    MOZ_ASSERT(
+        false,
+        "DisentanglePort() should be called just from the correct parent.");
+    return false;
+  }
+
+  // Let's put the messages in the correct order. |aMessages| contains the
+  // unsent messages so they have to go first.
+  if (!aMessages.AppendElements(std::move(data->mMessages),
+                                mozilla::fallible)) {
+    return false;
+  }
+
+  ++data->mSequenceID;
+
+  // If we don't have a parent, we have to store the pending messages and wait.
+  uint32_t index = 0;
+  MessagePortParent* nextParent = nullptr;
+  for (; index < data->mNextParents.Length(); ++index) {
+    if (data->mNextParents[index].mSequenceID == data->mSequenceID) {
+      nextParent = data->mNextParents[index].mParent;
+      break;
+    }
+  }
+
+  // We didn't find the parent.
+  if (!nextParent) {
+    data->mMessages = std::move(aMessages);
+    data->mWaitingForNewParent = true;
+    data->mParent = nullptr;
+    return true;
+  }
+
+  data->mParent = nextParent;
+  data->mNextParents.RemoveElementAt(index);
+
+  nsTArray<MessageData> array;
+  if (!SharedMessageBody::FromSharedToMessagesParent(data->mParent->Manager(),
+                                                     aMessages, array)) {
+    return false;
+  }
+
+  Unused << data->mParent->Entangled(std::move(array));
+  return true;
+}
+
+bool MessagePortService::ClosePort(MessagePortParent* aParent) {
+  MessagePortServiceData* data;
+  if (!mPorts.Get(aParent->ID(), &data)) {
+    MOZ_ASSERT(false, "Unknown MessagePortParent should not happend.");
+    return false;
+  }
+
+  if (data->mParent != aParent) {
+    MOZ_ASSERT(false,
+               "ClosePort() should be called just from the correct parent.");
+    return false;
+  }
+
+  if (!data->mNextParents.IsEmpty()) {
+    MOZ_ASSERT(false,
+               "ClosePort() should be called when there are not next parents.");
+    return false;
+  }
+
+  // We don't want to send a message to this parent.
+  data->mParent = nullptr;
+
+  CloseAll(aParent->ID());
+  return true;
+}
+
+void MessagePortService::CloseAll(const nsID& aUUID, bool aForced) {
+  MessagePortServiceData* data;
+  if (!mPorts.Get(aUUID, &data)) {
+    MaybeShutdown();
+    return;
+  }
+
+  if (data->mParent) {
+    data->mParent->Close();
+    data->mParent = nullptr;
+  }
+
+  for (const auto& nextParent : data->mNextParents) {
+    MessagePortParent* const parent = nextParent.mParent;
+    if (parent) {
+      parent->CloseAndDelete();
+    }
+  }
+  data->mNextParents.Clear();
+
+  nsID destinationUUID = data->mDestinationUUID;
+
+  // If we have informations about the other port and that port has some
+  // pending messages to deliver but the parent has not processed them yet,
+  // because its entangling request didn't arrive yet), we cannot close this
+  // channel.
+  MessagePortServiceData* destinationData;
+  if (!aForced && mPorts.Get(destinationUUID, &destinationData) &&
+      !destinationData->mMessages.IsEmpty() &&
+      destinationData->mWaitingForNewParent) {
+    MOZ_ASSERT(!destinationData->mNextStepCloseAll);
+    destinationData->mNextStepCloseAll = true;
+    return;
+  }
+
+  mPorts.Remove(aUUID);
+
+  CloseAll(destinationUUID, aForced);
+
+  // CloseAll calls itself recursively and it can happen that it deletes
+  // itself. Before continuing we must check if we are still alive.
+  if (!gInstance) {
+    return;
+  }
+
+  MOZ_ASSERT(!mPorts.Contains(aUUID));
+
+  MaybeShutdown();
+}
+
+// This service can be dismissed when there are not active ports.
+void MessagePortService::MaybeShutdown() {
+  if (mPorts.Count() == 0) {
+    gInstance = nullptr;
+  }
+}
+
+bool MessagePortService::PostMessages(
+    MessagePortParent* aParent,
+    FallibleTArray<RefPtr<SharedMessageBody>> aMessages) {
+  MessagePortServiceData* data;
+  if (!mPorts.Get(aParent->ID(), &data)) {
+    MOZ_ASSERT(false, "Unknown MessagePortParent should not happend.");
+    return false;
+  }
+
+  if (data->mParent != aParent) {
+    MOZ_ASSERT(false,
+               "PostMessages() should be called just from the correct parent.");
+    return false;
+  }
+
+  MOZ_ALWAYS_TRUE(mPorts.Get(data->mDestinationUUID, &data));
+
+  if (!data->mMessages.AppendElements(std::move(aMessages),
+                                      mozilla::fallible)) {
+    return false;
+  }
+
+  // If the parent can send data to the child, let's proceed.
+  if (data->mParent && data->mParent->CanSendData()) {
+    {
+      nsTArray<MessageData> messages;
+      if (!SharedMessageBody::FromSharedToMessagesParent(
+              data->mParent->Manager(), data->mMessages, messages)) {
+        return false;
+      }
+
+      Unused << data->mParent->SendReceiveData(messages);
+    }
+    // `messages` borrows the underlying JSStructuredCloneData so we need to
+    // avoid destroying the `mMessages` until after we've destroyed `messages`.
+    data->mMessages.Clear();
+  }
+
+  return true;
+}
+
+void MessagePortService::ParentDestroy(MessagePortParent* aParent) {
+  // This port has already been destroyed.
+  MessagePortServiceData* data;
+  if (!mPorts.Get(aParent->ID(), &data)) {
+    return;
+  }
+
+  if (data->mParent != aParent) {
+    // We don't want to send a message to this parent.
+    for (uint32_t i = 0; i < data->mNextParents.Length(); ++i) {
+      if (aParent == data->mNextParents[i].mParent) {
+        data->mNextParents.RemoveElementAt(i);
+        break;
+      }
+    }
+  }
+
+  CloseAll(aParent->ID());
+}
+
+bool MessagePortService::ForceClose(const nsID& aUUID,
+                                    const nsID& aDestinationUUID,
+                                    const uint32_t& aSequenceID) {
+  MessagePortServiceData* data;
+  if (!mPorts.Get(aUUID, &data)) {
+    NS_WARNING("Unknown MessagePort in ForceClose()");
+    // There is nothing to close so we are ok.
+    return true;
+  }
+
+  if (!data->mDestinationUUID.Equals(aDestinationUUID) ||
+      data->mSequenceID != aSequenceID) {
+    NS_WARNING("DestinationUUID and/or sequenceID do not match.");
+    return false;
+  }
+
+  CloseAll(aUUID, true);
+  return true;
+}
+
+}  // namespace mozilla::dom
diff --git a/dom/messagechannel/MessagePortService.h b/dom/messagechannel/MessagePortService.h
new file mode 100644
index 0000000000..c98900f366
--- /dev/null
+++ b/dom/messagechannel/MessagePortService.h
@@ -0,0 +1,60 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#ifndef mozilla_dom_MessagePortService_h
+#define mozilla_dom_MessagePortService_h
+
+#include "nsClassHashtable.h"
+#include "nsHashKeys.h"
+#include "nsISupportsImpl.h"
+
+namespace mozilla::dom {
+
+class MessagePortParent;
+class SharedMessageBody;
+
+class MessagePortService final {
+ public:
+  NS_INLINE_DECL_REFCOUNTING(MessagePortService)
+
+  // Needs to be public for the MOZ_DECLARE_RELOCATE_USING_MOVE_CONSTRUCTOR
+  // macro.
+  struct NextParent;
+
+  static MessagePortService* Get();
+  static MessagePortService* GetOrCreate();
+
+  bool RequestEntangling(MessagePortParent* aParent,
+                         const nsID& aDestinationUUID,
+                         const uint32_t& aSequenceID);
+
+  bool DisentanglePort(MessagePortParent* aParent,
+                       FallibleTArray<RefPtr<SharedMessageBody>> aMessages);
+
+  bool ClosePort(MessagePortParent* aParent);
+
+  bool PostMessages(MessagePortParent* aParent,
+                    FallibleTArray<RefPtr<SharedMessageBody>> aMessages);
+
+  void ParentDestroy(MessagePortParent* aParent);
+
+  bool ForceClose(const nsID& aUUID, const nsID& aDestinationUUID,
+                  const uint32_t& aSequenceID);
+
+ private:
+  ~MessagePortService() = default;
+
+  void CloseAll(const nsID& aUUID, bool aForced = false);
+  void MaybeShutdown();
+
+  class MessagePortServiceData;
+
+  nsClassHashtable<nsIDHashKey, MessagePortServiceData> mPorts;
+};
+
+}  // namespace mozilla::dom
+
+#endif  // mozilla_dom_MessagePortService_h
diff --git a/dom/messagechannel/PMessagePort.ipdl b/dom/messagechannel/PMessagePort.ipdl
new file mode 100644
index 0000000000..599e442df3
--- /dev/null
+++ b/dom/messagechannel/PMessagePort.ipdl
@@ -0,0 +1,47 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+include protocol PBackground;
+
+include DOMTypes;
+include ProtocolTypes;
+
+namespace mozilla {
+namespace dom {
+
+// This protocol is used for the MessageChannel/MessagePort API
+[ManualDealloc]
+protocol PMessagePort
+{
+  manager PBackground;
+
+  /* Many of these methods are used just for the shutdown sequence. The
+     correct sequence for the child actor is:
+     1. SendStopSendingData();
+     2. RecvStopSendingDataConfirmed();
+     3. SendClose();
+     4. Recv__delete__(); */
+
+  /* When the port is transferred the sequence is:
+     1. SendStopSendingData();
+     2. RecvStopSendingDataConfirmed();
+     3. SendDisentangle();
+     4. Recv__delete__(); */
+
+parent:
+  async PostMessages(MessageData[] messages);
+  async Disentangle(MessageData[] messages);
+  async StopSendingData();
+  async Close();
+
+child:
+  async Entangled(MessageData[] messages);
+  async ReceiveData(MessageData[] messages);
+  async StopSendingDataConfirmed();
+
+  async __delete__();
+};
+
+} // namespace dom
+} // namespace mozilla
diff --git a/dom/messagechannel/moz.build b/dom/messagechannel/moz.build
new file mode 100644
index 0000000000..d2726be851
--- /dev/null
+++ b/dom/messagechannel/moz.build
@@ -0,0 +1,38 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+with Files("**"):
+    BUG_COMPONENT = ("Core", "DOM: postMessage")
+
+TEST_DIRS += ["tests"]
+
+EXPORTS.mozilla.dom += [
+    "MessageChannel.h",
+    "MessagePort.h",
+    "MessagePortChild.h",
+    "MessagePortParent.h",
+]
+
+UNIFIED_SOURCES += [
+    "MessageChannel.cpp",
+    "MessagePort.cpp",
+    "MessagePortChild.cpp",
+    "MessagePortParent.cpp",
+    "MessagePortService.cpp",
+]
+
+IPDL_SOURCES += [
+    "PMessagePort.ipdl",
+]
+
+LOCAL_INCLUDES += [
+    "../base",
+    "../events",
+]
+
+include("/ipc/chromium/chromium-config.mozbuild")
+
+FINAL_LIBRARY = "xul"
diff --git a/dom/messagechannel/tests/chrome.ini b/dom/messagechannel/tests/chrome.ini
new file mode 100644
index 0000000000..9ec2edcb4d
--- /dev/null
+++ b/dom/messagechannel/tests/chrome.ini
@@ -0,0 +1,12 @@
+[DEFAULT]
+support-files =
+  iframe_messageChannel_chrome.html
+  mm_messageChannelParent.xhtml
+  mm_messageChannelParentNotRemote.xhtml
+  mm_messageChannelParent.js
+  mm_messageChannel.js
+
+[test_messageChannel.xhtml]
+[test_messageChannelWithMessageManager.xhtml]
+skip-if = os == 'android'
+[test_messageChannelWithMessageManagerNotRemote.xhtml]
diff --git a/dom/messagechannel/tests/iframe_messageChannel_chrome.html b/dom/messagechannel/tests/iframe_messageChannel_chrome.html
new file mode 100644
index 0000000000..5fcd43a34c
--- /dev/null
+++ b/dom/messagechannel/tests/iframe_messageChannel_chrome.html
@@ -0,0 +1,11 @@
+<!DOCTYPE HTML>
+<html>
+<body>
+  <script type="application/javascript">
+
+window.addEventListener('message', receiveMessage);
+function receiveMessage(evt) {
+  evt.data.postMessage("Hello world");
+}
+  </script>
+</body>
diff --git a/dom/messagechannel/tests/iframe_messageChannel_cloning.html b/dom/messagechannel/tests/iframe_messageChannel_cloning.html
new file mode 100644
index 0000000000..3012f9a845
--- /dev/null
+++ b/dom/messagechannel/tests/iframe_messageChannel_cloning.html
@@ -0,0 +1,21 @@
+<!DOCTYPE HTML>
+<html>
+<body>
+  <script type="application/javascript">
+
+  function ok(a, msg) {
+    window.parent.postMessage({ status: a ? "OK" : "KO", message: msg }, "*");
+  }
+
+  window.addEventListener('message', receiveMessage);
+  function receiveMessage(evt) {
+    ok (evt.data, "Data received");
+    ok (evt.data.port instanceof MessagePort, "Data contains a MessagePort");
+
+    var a = new MessageChannel();
+    window.parent.postMessage({ status: "FINISH", port: a.port2 }, '*', [a.port2]);
+  }
+
+  </script>
+</body>
+</html>
diff --git a/dom/messagechannel/tests/iframe_messageChannel_pingpong.html b/dom/messagechannel/tests/iframe_messageChannel_pingpong.html
new file mode 100644
index 0000000000..c4decd35a7
--- /dev/null
+++ b/dom/messagechannel/tests/iframe_messageChannel_pingpong.html
@@ -0,0 +1,32 @@
+<!DOCTYPE HTML>
+<html>
+<body>
+  <script type="application/javascript">
+
+  function ok(what, msg) {
+    window.parent.postMessage({type: what ? 'OK' : 'KO', msg }, '*');
+  }
+
+  window.addEventListener('message', receiveMessage);
+  function receiveMessage(evt) {
+    if (evt.data.type == 'PORT') {
+      var port = evt.data.port;
+      var counter = 0;
+      port.onmessage = function(event) {
+        if (counter++ == 0) {
+          ok(!(event.data % 2), "The number " + event.data + " has been received correctly by the iframe");
+
+          window.parent.postMessage({ type: 'PORT', port }, '*', [port]);
+        }
+        else {
+          ok(false, "Wrong message!");
+        }
+      }
+    } else {
+      ok(false, "Unknown message");
+    }
+  }
+
+  </script>
+</body>
+</html>
diff --git a/dom/messagechannel/tests/iframe_messageChannel_post.html b/dom/messagechannel/tests/iframe_messageChannel_post.html
new file mode 100644
index 0000000000..846b247f0b
--- /dev/null
+++ b/dom/messagechannel/tests/iframe_messageChannel_post.html
@@ -0,0 +1,23 @@
+<!DOCTYPE HTML>
+<html>
+<body>
+  <script type="application/javascript">
+
+  var port;
+
+  window.addEventListener('message', receiveMessage);
+  function receiveMessage(evt) {
+    port = evt.data.port;
+
+    port.addEventListener('message', receivePostMessage);
+    function receivePostMessage(event) {
+      port.postMessage(event.data);
+    }
+    port.start();
+
+    window.parent.postMessage({ status: "READY" }, '*');
+  }
+
+  </script>
+</body>
+</html>
diff --git a/dom/messagechannel/tests/iframe_messageChannel_sharedWorker2.html b/dom/messagechannel/tests/iframe_messageChannel_sharedWorker2.html
new file mode 100644
index 0000000000..b96026955d
--- /dev/null
+++ b/dom/messagechannel/tests/iframe_messageChannel_sharedWorker2.html
@@ -0,0 +1,13 @@
+<!DOCTYPE HTML>
+<html>
+<body>
+  <script type="application/javascript">
+
+  var a = new SharedWorker('sharedWorker2_messageChannel.js');
+  a.port.onmessage = function(evt) {
+    evt.ports[0].postMessage("Hello from the iframe!");
+  }
+
+  </script>
+</body>
+</html>
diff --git a/dom/messagechannel/tests/iframe_messageChannel_transferable.html b/dom/messagechannel/tests/iframe_messageChannel_transferable.html
new file mode 100644
index 0000000000..0a00add71f
--- /dev/null
+++ b/dom/messagechannel/tests/iframe_messageChannel_transferable.html
@@ -0,0 +1,24 @@
+<!DOCTYPE HTML>
+<html>
+<body>
+  <script type="application/javascript">
+
+  function ok(what, msg) {
+    window.parent.postMessage({type: what ? 'OK' : 'KO', msg }, '*');
+  }
+
+  window.addEventListener('message', receiveMessage);
+  function receiveMessage(evt) {
+    ok(evt.ports.length == 1, "Port transferred!");
+
+    var a = new MessageChannel();
+    ok(a, "MessageChannel created");
+    evt.ports[0].postMessage('hello world!', [a.port2]);
+    a.port1.onmessage = function(event) {
+      event.target.postMessage(event.data);
+    }
+  }
+
+  </script>
+</body>
+</html>
diff --git a/dom/messagechannel/tests/mm_messageChannel.js b/dom/messagechannel/tests/mm_messageChannel.js
new file mode 100644
index 0000000000..3bd0f5be47
--- /dev/null
+++ b/dom/messagechannel/tests/mm_messageChannel.js
@@ -0,0 +1,76 @@
+/* eslint-env mozilla/frame-script */
+
+function debug(msg) {
+  dump("[mmMessageChannelChild]" + msg + "\n");
+}
+
+/**
+ * Preparation Test
+ */
+let port;
+let toString = Object.prototype.toString;
+
+(function prepare() {
+  debug("Script loaded.");
+  addTestReceiver();
+  sendAsyncMessage("mmMessagePort:finishScriptLoad");
+})();
+
+function ok(condition, message) {
+  debug("condition: " + condition + ", " + message + "\n");
+  if (!condition) {
+    sendAsyncMessage("mmMessagePort:fail", { message });
+    throw "failed check: " + message;
+  }
+}
+
+function is(a, b, message) {
+  ok(a === b, message);
+}
+
+/**
+ * Testing codes.
+ */
+function addTestReceiver() {
+  addMessageListener("BasicTest:PortCreated", basicTest);
+  addMessageListener("CloseTest:PortCreated", closeTest);
+  addMessageListener("EmptyTest:PortCreated", emptyTest);
+  addMessageListener("NotTransferableTest:PortCreated", notTransferableTest);
+}
+
+function basicTest(msg) {
+  port = msg.ports[0];
+  is(toString.call(port), "[object MessagePort]", "created MessagePort.");
+
+  port.onmessage = message => {
+    is(message.data, "BasicTest:StartTest", "Replied message is correct.");
+    port.postMessage("BasicTest:TestOK");
+  };
+
+  sendAsyncMessage("BasicTest:FinishPrepare", { message: "OK" });
+}
+
+function closeTest(msg) {
+  port = msg.ports[0];
+  is(toString.call(port), "[object MessagePort]", "created MessagePort.");
+
+  port.onmessage = message => {
+    ok(message.data, "CloseTest:StartTest", "Replied message is correct.");
+    port.postMessage("CloseTest:TestOK");
+  };
+
+  port.close();
+
+  sendAsyncMessage("CloseTest:FinishPrepare", { message: "OK" });
+}
+
+function emptyTest(msg) {
+  let portSize = msg.ports.length;
+  is(portSize, 0, "transfered port size is zero.");
+
+  sendAsyncMessage("EmptyTest:FinishPrepare", { message: "OK" });
+}
+
+function notTransferableTest(msg) {
+  sendAsyncMessage("NotTransferableTest:FinishPrepare", { message: "OK" });
+}
diff --git a/dom/messagechannel/tests/mm_messageChannelParent.js b/dom/messagechannel/tests/mm_messageChannelParent.js
new file mode 100644
index 0000000000..a5595722a2
--- /dev/null
+++ b/dom/messagechannel/tests/mm_messageChannelParent.js
@@ -0,0 +1,144 @@
+let port;
+let mm;
+
+function info(message) {
+  return window.arguments[0].info(message);
+}
+
+function ok(condition, message) {
+  return window.arguments[0].ok(condition, message);
+}
+
+function is(v1, v2, message) {
+  return window.arguments[0].is(v1, v2, message);
+}
+
+function todo_is(v1, v2, message) {
+  return window.arguments[0].todo_is(v1, v2, message);
+}
+
+function cleanUp() {
+  window.arguments[0].setTimeout(function () {
+    this.done();
+  }, 0);
+  window.close();
+}
+
+function debug(msg) {
+  dump("[mmMessageChannelParent]" + msg + "\n");
+}
+
+let tests = [basic_test, close_test, empty_transferable, not_transferable];
+
+// Test Routine
+function run_tests() {
+  let test = tests.shift();
+  if (test === undefined) {
+    cleanUp();
+    return;
+  }
+
+  test(function () {
+    setTimeout(run_tests, 0);
+  });
+}
+
+// Basic communication test.
+function basic_test(finish) {
+  ok(mm, "basic_test");
+
+  let finishPrepare = msg => {
+    is(msg.data.message, "OK", "");
+    ok(port, "");
+    port.onmessage = message => {
+      is(message.data, "BasicTest:TestOK", "");
+      finish();
+    };
+    port.postMessage("BasicTest:StartTest");
+    mm.removeMessageListener("BasicTest:FinishPrepare", finishPrepare);
+  };
+
+  let channel = new MessageChannel();
+  port = channel.port2;
+  mm.addMessageListener("BasicTest:FinishPrepare", finishPrepare);
+  mm.sendAsyncMessage("BasicTest:PortCreated", {}, [channel.port1]);
+}
+
+// Communicate with closed port.
+function close_test(finish) {
+  ok(mm, "close_test");
+
+  let finishPrepare = msg => {
+    is(msg.data.message, "OK", "");
+    ok(port, "");
+
+    port.onmessage = message => {
+      ok(false, "Port is alive.");
+      finish();
+    };
+
+    port.postMessage("CloseTest:StartTest");
+    mm.removeMessageListener("CloseTest:FinishPrepare", finishPrepare);
+    finish();
+  };
+
+  let channel = new MessageChannel();
+  port = channel.port2;
+  mm.addMessageListener("CloseTest:FinishPrepare", finishPrepare);
+  mm.sendAsyncMessage("CloseTest:PortCreated", {}, [channel.port1]);
+}
+
+// Empty transferable object
+function empty_transferable(finish) {
+  ok(mm, "empty_transferable");
+
+  let finishPrepare = msg => {
+    ok(true, "Same basic test.");
+    mm.removeMessageListener("EmptyTest:FinishPrepare", finishPrepare);
+    finish();
+  };
+
+  mm.addMessageListener("EmptyTest:FinishPrepare", finishPrepare);
+  mm.sendAsyncMessage("EmptyTest:PortCreated", {}, []);
+}
+
+// Not transferable object.
+function not_transferable(finish) {
+  ok(mm, "not_transferable");
+
+  let finishPrepare = msg => {
+    ok(true, "Same basic test.");
+    finish();
+  };
+
+  mm.addMessageListener("NotTransferableTest:FinishPrepare", finishPrepare);
+  mm.sendAsyncMessage("NotTransferableTest:PortCreated", {}, [""]);
+}
+
+/*
+ * Test preparation
+ */
+function finishLoad(msg) {
+  run_tests();
+}
+
+function prepare_test() {
+  debug("start run_tests()");
+  var node = document.getElementById("messagechannel_remote");
+  mm = node.messageManager; //Services.ppmm.getChildAt(1);
+  ok(mm, "created MessageManager.");
+
+  mm.addMessageListener("mmMessagePort:finishScriptLoad", finishLoad);
+  mm.addMessageListener("mmMessagePort:fail", failed_test);
+  //mm.loadProcessScript("chrome://mochitests/content/chrome/dom/messagechannel/tests/mm_messageChannel.js", true);
+  mm.loadFrameScript(
+    "chrome://mochitests/content/chrome/dom/messagechannel/tests/mm_messageChannel.js",
+    true
+  );
+  ok(true, "Loaded");
+}
+
+function failed_test() {
+  debug("failed test in child process");
+  ok(false, "");
+}
diff --git a/dom/messagechannel/tests/mm_messageChannelParent.xhtml b/dom/messagechannel/tests/mm_messageChannelParent.xhtml
new file mode 100644
index 0000000000..5f5c5ae5be
--- /dev/null
+++ b/dom/messagechannel/tests/mm_messageChannelParent.xhtml
@@ -0,0 +1,12 @@
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/css" href="chrome://global/skin"?>
+<?xml-stylesheet type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"?>
+<window title="Test MessageChannel API with nsFrameMessageManager(bug 1174624)"
+        xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+        onload="prepare_test()">
+
+  <!-- test code goes here -->
+  <script type="application/javascript"
+          src="chrome://mochitests/content/chrome/dom/messagechannel/tests/mm_messageChannelParent.js"></script>
+  <browser type="content" src="about:blank" id="messagechannel_remote" remote="true"/>
+</window>
diff --git a/dom/messagechannel/tests/mm_messageChannelParentNotRemote.xhtml b/dom/messagechannel/tests/mm_messageChannelParentNotRemote.xhtml
new file mode 100644
index 0000000000..cb3b55dea7
--- /dev/null
+++ b/dom/messagechannel/tests/mm_messageChannelParentNotRemote.xhtml
@@ -0,0 +1,12 @@
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/css" href="chrome://global/skin"?>
+<?xml-stylesheet type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"?>
+<window title="Test MessageChannel API with nsFrameMessageManager(bug 1174624)"
+        xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
+        onload="prepare_test()">
+
+  <!-- test code goes here -->
+  <script type="application/javascript"
+          src="chrome://mochitests/content/chrome/dom/messagechannel/tests/mm_messageChannelParent.js"></script>
+  <browser type="content" src="about:blank" id="messagechannel_remote"/>
+</window>
diff --git a/dom/messagechannel/tests/mochitest.ini b/dom/messagechannel/tests/mochitest.ini
new file mode 100644
index 0000000000..d4d81552d6
--- /dev/null
+++ b/dom/messagechannel/tests/mochitest.ini
@@ -0,0 +1,34 @@
+[DEFAULT]
+support-files =
+  iframe_messageChannel_cloning.html
+  iframe_messageChannel_pingpong.html
+  iframe_messageChannel_post.html
+  iframe_messageChannel_transferable.html
+  worker_messageChannel.js
+  worker_messageChannel_any.js
+  sharedWorker_messageChannel.js
+  sharedWorker2_messageChannel.js
+  iframe_messageChannel_sharedWorker2.html
+  !/dom/events/test/event_leak_utils.js
+
+[test_event_listener_leaks.html]
+skip-if = 
+  os == "win" && processor == "aarch64" #bug 1535784
+  os == "linux" && bits == 64 # Bug 1777087
+[test_messageChannel.html]
+[test_messageChannel_cloning.html]
+[test_messageChannel_pingpong.html]
+[test_messageChannel_post.html]
+[test_messageChannel_start.html]
+[test_messageChannel_transferable.html]
+[test_messageChannel_unshipped.html]
+[test_messageChannel_worker.html]
+[test_messageChannel_selfTransferring.html]
+[test_messageChannel_sharedWorker.html]
+[test_messageChannel_sharedWorker2.html]
+[test_messageChannel_any.html]
+[test_messageChannel_forceClose.html]
+[test_messageChannel_bug1178076.html]
+[test_messageChannel_bug1224825.html]
+[test_messageChannel_worker_forceClose.html]
+[test_removedWindow.html]
diff --git a/dom/messagechannel/tests/moz.build b/dom/messagechannel/tests/moz.build
new file mode 100644
index 0000000000..6cf89eae3b
--- /dev/null
+++ b/dom/messagechannel/tests/moz.build
@@ -0,0 +1,10 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+MOCHITEST_MANIFESTS += ["mochitest.ini"]
+MOCHITEST_CHROME_MANIFESTS += ["chrome.ini"]
+
+XPCSHELL_TESTS_MANIFESTS += ["unit/xpcshell.ini"]
diff --git a/dom/messagechannel/tests/sharedWorker2_messageChannel.js b/dom/messagechannel/tests/sharedWorker2_messageChannel.js
new file mode 100644
index 0000000000..d5084fe766
--- /dev/null
+++ b/dom/messagechannel/tests/sharedWorker2_messageChannel.js
@@ -0,0 +1,9 @@
+/* eslint-env worker */
+
+var mc = new MessageChannel();
+var i = 0;
+
+onconnect = function (evt) {
+  dump("CONNECTING: " + i + "\n");
+  evt.ports[0].postMessage(42, [mc["port" + ++i]]);
+};
diff --git a/dom/messagechannel/tests/sharedWorker_messageChannel.js b/dom/messagechannel/tests/sharedWorker_messageChannel.js
new file mode 100644
index 0000000000..874860e99f
--- /dev/null
+++ b/dom/messagechannel/tests/sharedWorker_messageChannel.js
@@ -0,0 +1,10 @@
+/* eslint-env worker */
+
+onconnect = function (evt) {
+  var mc = new MessageChannel();
+
+  evt.ports[0].postMessage(42, [mc.port2]);
+  mc.port1.onmessage = function (e) {
+    mc.port1.postMessage(e.data);
+  };
+};
diff --git a/dom/messagechannel/tests/test_event_listener_leaks.html b/dom/messagechannel/tests/test_event_listener_leaks.html
new file mode 100644
index 0000000000..93ed5215d3
--- /dev/null
+++ b/dom/messagechannel/tests/test_event_listener_leaks.html
@@ -0,0 +1,50 @@
+<!--
+  Any copyright is dedicated to the Public Domain.
+  http://creativecommons.org/publicdomain/zero/1.0/
+-->
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Bug 1450358 - Test MessageChannel event listener leak conditions</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="text/javascript" src="/tests/dom/events/test/event_leak_utils.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<script class="testbody" type="text/javascript">
+// Manipulate MessageChannel objects in the frame's context.
+// Its important here that we create a listener callback from
+// the DOM objects back to the frame's global in order to
+// exercise the leak condition.
+async function useMessagePort(contentWindow) {
+  contentWindow.messageCount = 0;
+
+  let mc = new contentWindow.MessageChannel
+  mc.port1.postMessage("foo");
+
+  await new Promise(resolve => {
+    mc.port2.onmessage = e => {
+      contentWindow.messageCount += 1;
+      resolve();
+    };
+  });
+
+  is(contentWindow.messageCount, 1, "message should be received");
+}
+
+async function runTest() {
+  try {
+    await checkForEventListenerLeaks("MessageChannel", useMessagePort);
+  } catch (e) {
+    ok(false, e);
+  } finally {
+    SimpleTest.finish();
+  }
+}
+
+SimpleTest.waitForExplicitFinish();
+addEventListener("load", runTest, { once: true });
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/messagechannel/tests/test_messageChannel.html b/dom/messagechannel/tests/test_messageChannel.html
new file mode 100644
index 0000000000..ce6774d33c
--- /dev/null
+++ b/dom/messagechannel/tests/test_messageChannel.html
@@ -0,0 +1,43 @@
+
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=677638
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 677638 - basic support</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=677638">Mozilla Bug 677638</a>
+<p id="display"></p>
+<div id="content" style="display: none">
+  <iframe name="x" id="x"></iframe>
+  <iframe name="y" id="y"></iframe>
+</div>
+<pre id="test">
+</pre>
+  <script type="application/javascript">
+
+  /** Test for Bug 677638 **/
+  var a = new MessageChannel();
+  ok(a, "MessageChannel created");
+
+  var port1 = a.port1;
+  ok(port1, "MessageChannel.port1 exists");
+  is(port1, a.port1, "MessageChannel.port1 is port1");
+
+  var port2 = a.port2;
+  ok(port2, "MessageChannel.port1 exists");
+  is(port2, a.port2, "MessageChannel.port2 is port2");
+
+  [ 'postMessage', 'start', 'close' ].forEach(function(e) {
+    ok(e in port1, "MessagePort1." + e + " exists");
+    ok(e in port2, "MessagePort2." + e + " exists");
+  });
+
+  </script>
+</body>
+</html>
diff --git a/dom/messagechannel/tests/test_messageChannel.xhtml b/dom/messagechannel/tests/test_messageChannel.xhtml
new file mode 100644
index 0000000000..e51359d67d
--- /dev/null
+++ b/dom/messagechannel/tests/test_messageChannel.xhtml
@@ -0,0 +1,38 @@
+<?xml version="1.0"?>
+<?xml-stylesheet type="text/css" href="chrome://global/skin"?>
+<?xml-stylesheet type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"?>
+<window title="Test for MessageChannel API"
+        xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"/>
+
+  <!-- test results are displayed in the html:body -->
+  <body xmlns="http://www.w3.org/1999/xhtml" id="body">
+  </body>
+
+  <!-- test code goes here -->
+  <script type="application/javascript"><![CDATA[
+
+  ok("MessageChannel" in window, "Should MessageChannel exist?");
+
+  var channel = new MessageChannel();
+  ok(channel, "MessageChannel is created");
+
+  channel.port1.onmessage = function(evt) {
+    ok(true, "message received!");
+    SimpleTest.finish();
+  }
+
+  var ifr = document.createXULElement('browser');
+  ifr.setAttribute("src", "iframe_messageChannel_chrome.html");
+  ifr.setAttribute("flex", "1");
+  ifr.addEventListener('load', function() {
+    ifr.contentWindow.postMessage(channel.port2, '*', [channel.port2]);
+  });
+
+  var body = document.getElementById("body");
+  body.appendChild(ifr);
+
+  SimpleTest.waitForExplicitFinish();
+
+  ]]></script>
+</window>
diff --git a/dom/messagechannel/tests/test_messageChannelWithMessageManager.xhtml b/dom/messagechannel/tests/test_messageChannelWithMessageManager.xhtml
new file mode 100644
index 0000000000..b95a85645c
--- /dev/null
+++ b/dom/messagechannel/tests/test_messageChannelWithMessageManager.xhtml
@@ -0,0 +1,27 @@
+<?xml version="1.0"?>
+<?xml-stylesheet href="chrome://global/skin" type="text/css"?>
+<?xml-stylesheet href="chrome://mochikit/content/tests/SimpleTest/test.css"
+                 type="text/css"?>
+<window title="Test MessageChannel API with nsFrameMessageManager(bug 1174624)"
+  xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+
+  <!-- test results are displayed in the html:body -->
+  <body xmlns="http://www.w3.org/1999/xhtml">
+  </body>
+
+  <!-- test code goes here -->
+  <script type="application/javascript"><![CDATA[
+
+  SimpleTest.waitForExplicitFinish();
+
+  function done() {
+    info("done called");
+    SimpleTest.finish();
+  }
+
+  addLoadEvent(function() {
+    window.openDialog("mm_messageChannelParent.xhtml", "", "chrome,noopener", window);
+  });
+  ]]></script>
+</window>
diff --git a/dom/messagechannel/tests/test_messageChannelWithMessageManagerNotRemote.xhtml b/dom/messagechannel/tests/test_messageChannelWithMessageManagerNotRemote.xhtml
new file mode 100644
index 0000000000..e87fd4d873
--- /dev/null
+++ b/dom/messagechannel/tests/test_messageChannelWithMessageManagerNotRemote.xhtml
@@ -0,0 +1,27 @@
+<?xml version="1.0"?>
+<?xml-stylesheet href="chrome://global/skin" type="text/css"?>
+<?xml-stylesheet href="chrome://mochikit/content/tests/SimpleTest/test.css"
+                 type="text/css"?>
+<window title="Test MessageChannel API with nsFrameMessageManager(bug 1174624)"
+  xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+
+  <!-- test results are displayed in the html:body -->
+  <body xmlns="http://www.w3.org/1999/xhtml">
+  </body>
+
+  <!-- test code goes here -->
+  <script type="application/javascript"><![CDATA[
+
+  SimpleTest.waitForExplicitFinish();
+
+  function done() {
+    info("done called");
+    SimpleTest.finish();
+  }
+
+  addLoadEvent(function() {
+    window.openDialog("mm_messageChannelParentNotRemote.xhtml", "", "chrome,noopener", window);
+  });
+  ]]></script>
+</window>
diff --git a/dom/messagechannel/tests/test_messageChannel_any.html b/dom/messagechannel/tests/test_messageChannel_any.html
new file mode 100644
index 0000000000..ff83c55288
--- /dev/null
+++ b/dom/messagechannel/tests/test_messageChannel_any.html
@@ -0,0 +1,115 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=677638
+-->
+<head>
+  <meta charset="utf-8">
+  <title>MessagePort/Channel any content</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=677638">Mozilla Bug 677638</a>
+<div id="content"></div>
+<pre id="test">
+</pre>
+  <script type="application/javascript">
+
+var tests = [
+ 'hello world',
+ 123,
+ null,
+ true,
+ new Date(),
+ [ 1, 'test', true, new Date() ],
+ { a: true, b:  null, c: new Date(), d: [ true, false, {} ] },
+ new Blob([123], { type: 'plain/text' })
+];
+
+var currentTest = null;
+
+function getType(a) {
+  if (a === null || a === undefined)
+    return 'null';
+
+  if (Array.isArray(a))
+    return 'array';
+
+  if (typeof a == 'object')
+    return 'object';
+
+  return 'primitive';
+}
+
+function compare(a, b) {
+  is (getType(a), getType(b), 'Type matches');
+
+  var type = getType(a);
+  if (type == 'array') {
+    is (a.length, b.length, 'Array.length matches');
+    for (var i = 0; i < a.length; ++i) {
+      compare(a[i], b[i]);
+    }
+
+    return;
+  }
+
+  if (type == 'object') {
+    ok (a !== b, 'They should not match');
+
+    var aProps = [];
+    for (var p in a) aProps.push(p);
+
+    var bProps = [];
+    for (var p in b) bProps.push(p);
+
+    is (aProps.length, bProps.length, 'Props match');
+    is (aProps.sort().toString(), bProps.sort().toString(), 'Prop names match');
+
+    for (var p in a) {
+      compare(a[p], b[p]);
+    }
+
+    return;
+  }
+
+  if (type != 'null') {
+    is (a, b, 'Same value');
+  }
+}
+
+function runTest() {
+  var mc = new MessageChannel('foobar');
+  ok(mc, "MessageChannel can be created");
+
+  mc.port1.onmessage = function(event) {
+    compare(event.data, currentTest);
+    next();
+  }
+
+  function next() {
+    if (!tests.length) {
+      SimpleTest.finish();
+      return;
+    }
+
+    currentTest = tests.shift();
+    mc.port1.postMessage(currentTest);
+  }
+
+  var worker = new Worker("worker_messageChannel_any.js");
+  worker.onmessage = function(event) {
+    if (event.data == "READY") {
+      next();
+    }
+  };
+
+  worker.postMessage(mc.port2, [mc.port2]);
+}
+
+SimpleTest.waitForExplicitFinish();
+runTest();
+  </script>
+</body>
+</html>
diff --git a/dom/messagechannel/tests/test_messageChannel_bug1178076.html b/dom/messagechannel/tests/test_messageChannel_bug1178076.html
new file mode 100644
index 0000000000..e8d4d3b9fb
--- /dev/null
+++ b/dom/messagechannel/tests/test_messageChannel_bug1178076.html
@@ -0,0 +1,38 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1178076
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 1178076</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1178076">Mozilla Bug 1178076</a>
+<div id="content"></div>
+<pre id="test">
+</pre>
+  <script type="application/javascript">
+
+  function runTest() {
+    onmessage = function(e) {
+      is(e.ports.length, 1, "A port has been received!");
+      var port = e.ports[0];
+      ok(port instanceof MessagePort, "This is a port.");
+      SimpleTest.finish();
+    }
+
+    // In this test we want to see if we leak a neutered port closing port1
+    // and sending port2 to the same window. This operation doesn't involve IPC.
+    var mc = new MessageChannel();
+    mc.port1.close();
+    postMessage(42, '*', [mc.port2]);
+  }
+
+  SimpleTest.waitForExplicitFinish();
+  runTest();
+  </script>
+</body>
+</html>
diff --git a/dom/messagechannel/tests/test_messageChannel_bug1224825.html b/dom/messagechannel/tests/test_messageChannel_bug1224825.html
new file mode 100644
index 0000000000..90b1b51076
--- /dev/null
+++ b/dom/messagechannel/tests/test_messageChannel_bug1224825.html
@@ -0,0 +1,94 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1224825
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 1224825</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1224825">Mozilla Bug 1224825</a>
+<div id="content"></div>
+<pre id="test">
+</pre>
+  <script type="application/javascript">
+
+var MAX = 100;
+
+function test_fullDeliveredMessages() {
+  var worker = new Worker('data:javascript,onmessage = function(e) { e.ports[0].onmessage = function(evt) { postMessage(evt.data);}}');
+
+  var count = 0;
+  worker.onmessage = function(e) {
+    is(e.data, count, "Correct value expected!");
+    ok(count < MAX,"No count > MAX messages!");
+    if (++count == MAX) {
+
+      SimpleTest.requestFlakyTimeout("Testing an event not happening");
+      setTimeout(function() {
+        runTests();
+      }, 200);
+
+      info("All the messages correctly received");
+    }
+  }
+
+  var mc = new MessageChannel();
+  worker.postMessage(42, [mc.port2]);
+
+  for (var i = 0; i < MAX; ++i) {
+    mc.port1.postMessage(i);
+  }
+
+  mc.port1.close();
+
+  for (var i = 0; i < MAX * 2; ++i) {
+    mc.port1.postMessage(i);
+  }
+}
+
+function test_closeInBetween() {
+  var mc = new MessageChannel();
+
+  for (var i = 0; i < MAX; ++i) {
+    mc.port1.postMessage(i);
+  }
+
+  mc.port1.onmessage = function(e) {
+    ok (e.data < MAX/2, "Correct message received from port1:" + e.data);
+  }
+
+  mc.port2.onmessage = function(e) {
+    ok (e.data < MAX, "Correct message received from port2:" + e.data);
+    if (e.data == MAX/2) {
+      mc.port2.close();
+    }
+
+    mc.port2.postMessage(e.data);
+
+    if (e.data == MAX - 1) {
+      runTests();
+    }
+  }
+}
+
+var tests = [ test_fullDeliveredMessages, test_closeInBetween ];
+
+function runTests() {
+  if (!tests.length) {
+    SimpleTest.finish();
+    return;
+  }
+
+  var test = tests.shift();
+  test();
+}
+
+SimpleTest.waitForExplicitFinish();
+runTests();
+  </script>
+</body>
+</html>
diff --git a/dom/messagechannel/tests/test_messageChannel_cloning.html b/dom/messagechannel/tests/test_messageChannel_cloning.html
new file mode 100644
index 0000000000..7f59e9e96f
--- /dev/null
+++ b/dom/messagechannel/tests/test_messageChannel_cloning.html
@@ -0,0 +1,70 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=677638
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 677638 - port cloning</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=677638">Mozilla Bug 677638</a>
+<div id="content"></div>
+<pre id="test">
+</pre>
+  <script type="application/javascript">
+
+  // This test checks if MessagePorts can be shared with iframes
+  function test_iframe() {
+    window.addEventListener('message', receiveMessage);
+    function receiveMessage(evt) {
+      if (evt.data.status == 'OK') {
+        ok(true, evt.data.message);
+      } else if (evt.data.status == 'KO') {
+        ok(false, evt.data.message);
+      } else if (evt.data.status == 'FINISH') {
+        ok (evt.data.port instanceof MessagePort, "Data contains a MessagePort");
+        window.removeEventListener('message', receiveMessage);
+        runTest();
+      } else {
+        ok(false, "Unknown message");
+      }
+    }
+
+    var a = new MessageChannel();
+    ok(a, "MessageChannel created");
+
+    var div = document.getElementById("content");
+    ok(div, "Parent exists");
+
+    var ifr = document.createElement("iframe");
+    ifr.addEventListener("load", iframeLoaded);
+    ifr.setAttribute('src', "iframe_messageChannel_cloning.html");
+    div.appendChild(ifr);
+
+    function iframeLoaded() {
+      ifr.contentWindow.postMessage({ port: a.port2 }, '*', [a.port2]);
+    }
+  }
+
+  var tests = [
+    test_iframe
+  ];
+
+  function runTest() {
+    if (!tests.length) {
+      SimpleTest.finish();
+      return;
+    }
+
+    var test = tests.shift();
+    test();
+  }
+
+  SimpleTest.waitForExplicitFinish();
+  runTest();
+  </script>
+</body>
+</html>
diff --git a/dom/messagechannel/tests/test_messageChannel_forceClose.html b/dom/messagechannel/tests/test_messageChannel_forceClose.html
new file mode 100644
index 0000000000..98c9e87311
--- /dev/null
+++ b/dom/messagechannel/tests/test_messageChannel_forceClose.html
@@ -0,0 +1,30 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=1176034
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 1176034 - start/close</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1176034">Mozilla Bug 1176034</a>
+<div id="content"></div>
+<pre id="test">
+</pre>
+  <script type="application/javascript">
+
+  var mc = new MessageChannel();
+
+  try {
+    postMessage(42, "*", [ mc.port1, window ]);
+    ok(false, "Something went wrong.");
+  } catch(e) {
+    ok(true, "PostMessage should fail and we should not leak.");
+  }
+
+  </script>
+</body>
+</html>
diff --git a/dom/messagechannel/tests/test_messageChannel_pingpong.html b/dom/messagechannel/tests/test_messageChannel_pingpong.html
new file mode 100644
index 0000000000..602478bcb7
--- /dev/null
+++ b/dom/messagechannel/tests/test_messageChannel_pingpong.html
@@ -0,0 +1,77 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=677638
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 677638 - port cloning</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=677638">Mozilla Bug 677638</a>
+<div id="content"></div>
+<pre id="test">
+</pre>
+  <script type="application/javascript">
+
+  function runTest() {
+    var MAX = 100;
+
+    var a = new MessageChannel();
+    ok(a, "MessageChannel created");
+
+    // Populate the message queue of this port.
+    for (var i = 0; i < MAX; ++i) {
+      a.port1.postMessage(i);
+    }
+
+    window.addEventListener('message', receiveMessage);
+    function receiveMessage(evt) {
+
+      // This test sends the port from this window to the iframe and viceversa.
+      if (evt.data.type == 'PORT') {
+        var port = evt.data.port;
+        var counter = 0;
+        port.onmessage = function(event) {
+          // only 1 message should be received by this port.
+          if (counter++ == 0) {
+            ok(event.data % 2, "The number " + event.data + " has been received correctly by the main window");
+
+            if (event.data < MAX - 1) {
+              ifr.contentWindow.postMessage({ type: 'PORT', port }, '*', [port]);
+            } else {
+              SimpleTest.finish();
+            }
+          } else {
+            ok(false, "Wrong message!");
+          }
+        }
+      } else if (evt.data.type == 'OK') {
+        ok(true, evt.data.msg);
+      } else if (evt.data.type == 'KO') {
+        ok(false, evt.data.msg);
+      } else {
+        ok(false, "Unknown message");
+      }
+    }
+
+    var div = document.getElementById("content");
+    ok(div, "Parent exists");
+
+    var ifr = document.createElement("iframe");
+    ifr.addEventListener("load", iframeLoaded);
+    ifr.setAttribute('src', "iframe_messageChannel_pingpong.html");
+    div.appendChild(ifr);
+
+    function iframeLoaded() {
+      ifr.contentWindow.postMessage({ type: 'PORT', port: a.port2 }, '*', [a.port2]);
+    }
+  }
+
+  SimpleTest.waitForExplicitFinish();
+  runTest();
+  </script>
+</body>
+</html>
diff --git a/dom/messagechannel/tests/test_messageChannel_post.html b/dom/messagechannel/tests/test_messageChannel_post.html
new file mode 100644
index 0000000000..86c27efc3e
--- /dev/null
+++ b/dom/messagechannel/tests/test_messageChannel_post.html
@@ -0,0 +1,76 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=677638
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 677638 - port cloning</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=677638">Mozilla Bug 677638</a>
+<div id="content"></div>
+<pre id="test">
+</pre>
+  <script type="application/javascript">
+
+  function start() {
+    var a = new MessageChannel();
+    ok(a, "MessageChannel created");
+
+    window.addEventListener('message', receiveMessage);
+    function receiveMessage(evt) {
+      if (evt.data.status == 'READY') {
+        runTest();
+      } else {
+        ok(false, "Unknown message");
+      }
+    }
+
+    var div = document.getElementById("content");
+    ok(div, "Parent exists");
+
+    var ifr = document.createElement("iframe");
+    ifr.addEventListener("load", iframeLoaded);
+    ifr.setAttribute('src', "iframe_messageChannel_post.html");
+    div.appendChild(ifr);
+
+    function iframeLoaded() {
+      ifr.contentWindow.postMessage({ port: a.port2 }, '*', [a.port2]);
+    }
+
+    var tests = [ 42,
+                  null,
+                  undefined,
+                  "hello world",
+                  new Blob([]),
+                  true ];
+
+    a.port1.onmessage = function(evt) {
+      ok(tests.length, "We are waiting for a message");
+      if (typeof(tests[0]) == 'object') {
+        is(typeof(tests[0]), typeof(evt.data), "Value ok: " + tests[0]);
+      } else {
+        is(tests[0], evt.data, "Value ok: " + tests[0]);
+      }
+      tests.shift();
+      runTest();
+    }
+
+    function runTest() {
+      if (!tests.length) {
+        SimpleTest.finish();
+        return;
+      }
+
+      a.port1.postMessage(tests[0]);
+    }
+  }
+
+  SimpleTest.waitForExplicitFinish();
+  start();
+  </script>
+</body>
+</html>
diff --git a/dom/messagechannel/tests/test_messageChannel_selfTransferring.html b/dom/messagechannel/tests/test_messageChannel_selfTransferring.html
new file mode 100644
index 0000000000..c3b96f32e6
--- /dev/null
+++ b/dom/messagechannel/tests/test_messageChannel_selfTransferring.html
@@ -0,0 +1,32 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=677638
+-->
+<head>
+  <meta charset="utf-8">
+  <title>MessagePort/Channel no self tranferring</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=677638">Mozilla Bug 677638</a>
+<div id="content"></div>
+<pre id="test">
+</pre>
+  <script type="application/javascript">
+
+  var a = new MessageChannel();
+
+  var status = false;
+  try {
+    a.port1.postMessage('foobar', [a.port1]);
+  } catch(e) {
+    status =true;
+  }
+
+  ok(status, "Transfering the same port should throw");
+
+  </script>
+</body>
+</html>
diff --git a/dom/messagechannel/tests/test_messageChannel_sharedWorker.html b/dom/messagechannel/tests/test_messageChannel_sharedWorker.html
new file mode 100644
index 0000000000..cf1864579f
--- /dev/null
+++ b/dom/messagechannel/tests/test_messageChannel_sharedWorker.html
@@ -0,0 +1,36 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=677638
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 677638 - sharedWorker</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=677638">Mozilla Bug 677638</a>
+<p id="display"></p>
+<div id="content" style="display: none">
+  <iframe name="x" id="x"></iframe>
+  <iframe name="y" id="y"></iframe>
+</div>
+<pre id="test">
+</pre>
+  <script type="application/javascript">
+
+  var a = new SharedWorker('sharedWorker_messageChannel.js');
+  a.port.onmessage = function(evt) {
+    is(evt.ports.length, 1, "We received a port.");
+    evt.ports[0].onmessage = function(e) {
+      is(e.data, 42, "Message reiceved back!");
+      SimpleTest.finish();
+    }
+    evt.ports[0].postMessage(42);
+  }
+
+  SimpleTest.waitForExplicitFinish();
+  </script>
+</body>
+</html>
diff --git a/dom/messagechannel/tests/test_messageChannel_sharedWorker2.html b/dom/messagechannel/tests/test_messageChannel_sharedWorker2.html
new file mode 100644
index 0000000000..8b8f259308
--- /dev/null
+++ b/dom/messagechannel/tests/test_messageChannel_sharedWorker2.html
@@ -0,0 +1,34 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=677638
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 677638 - sharedWorker</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+  <a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=677638">Mozilla Bug 677638</a>
+  <div id="content"></div>
+
+  <script type="application/javascript">
+
+  var iframe = document.createElement('iframe');
+  iframe.setAttribute('src', "iframe_messageChannel_sharedWorker2.html");
+  document.getElementById('content').appendChild(iframe);
+
+  var a = new SharedWorker('sharedWorker2_messageChannel.js');
+  a.port.onmessage = function(evt) {
+    is(evt.ports.length, 1, "We received a port.");
+    evt.ports[0].onmessage = function(e) {
+      is(e.data, "Hello from the iframe!", "Message reiceved from the iframe!");
+      SimpleTest.finish();
+    }
+  }
+
+  SimpleTest.waitForExplicitFinish();
+  </script>
+</body>
+</html>
diff --git a/dom/messagechannel/tests/test_messageChannel_start.html b/dom/messagechannel/tests/test_messageChannel_start.html
new file mode 100644
index 0000000000..4bc49cc0d6
--- /dev/null
+++ b/dom/messagechannel/tests/test_messageChannel_start.html
@@ -0,0 +1,235 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=677638
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 677638 - start/close</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=677638">Mozilla Bug 677638</a>
+<div id="content"></div>
+<pre id="test">
+</pre>
+  <script type="application/javascript">
+
+  function runTests() {
+    if (!tests.length) {
+      SimpleTest.finish();
+      return;
+    }
+
+    var test = tests.shift();
+    test();
+  }
+
+  function testOnMessage() {
+    var a = new MessageChannel();
+    ok(a, "MessageChannel created");
+
+    a.port1.postMessage(42);
+    a.port2.postMessage(43);
+    ok(true, "MessagePort{1,2}.postmessage() invoked");
+
+    var events = 2;
+
+    a.port1.onmessage = function(evt) {
+      ok(true, "This method should be called");
+      if (!--events) runTests();
+    }
+
+    a.port2.onmessage = function(evt) {
+      ok(true, "This method should be called");
+      if (!--events) runTests();
+    }
+  }
+
+  function testAddEventListener() {
+    var a = new MessageChannel();
+    ok(a, "MessageChannel created");
+
+    a.port1.postMessage(42);
+    a.port2.postMessage(43);
+    ok(true, "MessagePort{1,2}.postmessage() invoked");
+
+    a.port1.addEventListener('message', function(evt) {
+      ok(false, "This method should not be called");
+    });
+
+    a.port2.addEventListener('message', function(evt) {
+      ok(false, "This method should not be called");
+    });
+
+    setTimeout(runTests, 0);
+  }
+
+  function testAddEventListenerAndStart() {
+    var a = new MessageChannel();
+    ok(a, "MessageChannel created");
+
+    a.port1.postMessage(42);
+    a.port2.postMessage(43);
+    ok(true, "MessagePort{1,2}.postmessage() invoked");
+
+    var events = 2;
+
+    a.port1.addEventListener('message', function(evt) {
+      ok(true, "This method should be called");
+      if (!--events) runTests();
+    });
+
+    a.port2.addEventListener('message', function(evt) {
+      ok(true, "This method should be called");
+      if (!--events) runTests();
+    });
+
+    a.port1.start();
+    a.port2.start();
+  }
+
+  function testAddEventListener1AndStart() {
+    var a = new MessageChannel();
+    ok(a, "MessageChannel created");
+
+    a.port1.postMessage(42);
+    a.port2.postMessage(43);
+    ok(true, "MessagePort{1,2}.postmessage() invoked");
+
+    var events = 1;
+
+    a.port1.addEventListener('message', function(evt) {
+      ok(true, "This method should be called");
+      if (!--events) runTests();
+    });
+
+    a.port2.addEventListener('message', function(evt) {
+      ok(false, "This method should not be called");
+    });
+
+    a.port1.start();
+  }
+
+  function testAddEventListener2AndStart() {
+    var a = new MessageChannel();
+    ok(a, "MessageChannel created");
+
+    a.port1.postMessage(42);
+    a.port2.postMessage(43);
+    ok(true, "MessagePort{1,2}.postmessage() invoked");
+
+    var events = 1;
+
+    a.port1.addEventListener('message', function(evt) {
+      ok(false, "This method should not be called");
+    });
+
+    a.port2.addEventListener('message', function(evt) {
+      ok(true, "This method should be called");
+      if (!--events) runTests();
+    });
+
+    a.port2.start();
+  }
+
+  function testTimer() {
+    var a = new MessageChannel();
+    ok(a, "MessageChannel created");
+
+    a.port1.postMessage(42);
+    a.port2.postMessage(43);
+    ok(true, "MessagePort{1,2}.postmessage() invoked");
+
+    setTimeout(function() {
+      var events = 2;
+      a.port1.onmessage = function(evt) {
+        ok(true, "This method should be called");
+        if (!--events) runTests();
+      }
+
+      a.port2.onmessage = function(evt) {
+        ok(true, "This method should be called");
+        if (!--events) runTests();
+      }
+    }, 200);
+  }
+
+  function testAddEventListenerAndStartWrongOrder() {
+    var a = new MessageChannel();
+    ok(a, "MessageChannel created");
+
+    a.port1.postMessage(42);
+    a.port2.postMessage(43);
+    ok(true, "MessagePort{1,2}.postmessage() invoked");
+
+    var events = 2;
+
+    a.port1.start();
+    a.port1.addEventListener('message', function(evt) {
+      ok(true, "This method should be called");
+      if (!--events) runTests();
+    });
+
+    a.port2.start();
+    a.port2.addEventListener('message', function(evt) {
+      ok(true, "This method should be called");
+      if (!--events) runTests();
+    });
+  }
+
+  function testOnMessageClone() {
+    var a = new MessageChannel();
+    ok(a, "MessageChannel created");
+
+    a.port1.postMessage(42);
+    a.port2.postMessage(43);
+    ok(true, "MessagePort{1,2}.postmessage() invoked");
+
+    var events = 2;
+
+    addEventListener('message', testOnMessageCloneCb, false);
+    function testOnMessageCloneCb(event) {
+      a.port1.onmessage = function(evt) {
+        ok(true, "This method should be called");
+        testOnMessageCloneFinish();
+      }
+
+      event.data.onmessage = function(evt) {
+        ok(true, "This method should be called");
+        testOnMessageCloneFinish();
+      }
+
+      a.port2.onmessage = function(evt) {
+        ok(false, "This method should not be called");
+      }
+    }
+
+    function testOnMessageCloneFinish() {
+      if (!--events) {
+        removeEventListener('message', testOnMessageCloneCb);
+        runTests();
+      }
+    }
+
+    postMessage(a.port2, '*', [a.port2]);
+  }
+
+  var tests = [
+    testOnMessage,
+    testAddEventListener,
+    testAddEventListenerAndStart,
+    testAddEventListener1AndStart,
+    testAddEventListener2AndStart,
+    testTimer,
+    testAddEventListenerAndStartWrongOrder,
+    testOnMessageClone,
+  ];
+
+  SimpleTest.waitForExplicitFinish();
+  SimpleTest.requestFlakyTimeout("untriaged");
+  runTests();
+  </script>
+</body>
+</html>
diff --git a/dom/messagechannel/tests/test_messageChannel_transferable.html b/dom/messagechannel/tests/test_messageChannel_transferable.html
new file mode 100644
index 0000000000..44a27b34c4
--- /dev/null
+++ b/dom/messagechannel/tests/test_messageChannel_transferable.html
@@ -0,0 +1,111 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=677638
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 677638 - port cloning</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=677638">Mozilla Bug 677638</a>
+<div id="content"></div>
+<pre id="test">
+</pre>
+  <script type="application/javascript">
+
+  function basic_test() {
+    var a = new MessageChannel();
+    ok(a, "MessageChannel created");
+
+    window.addEventListener('message', receiveMessage);
+    function receiveMessage(evt) {
+      if (evt.data.status == 'READY') {
+        a.port1.postMessage({ab, cb: ab}, [ab]);
+        ok(ab.byteLength == 0, "PostMessage - The size is: 0 == " + ab.byteLength)
+      } else {
+        ok(false, "Unknown message");
+      }
+    }
+
+    var div = document.getElementById("content");
+    ok(div, "Parent exists");
+
+    var ifr = document.createElement("iframe");
+    ifr.addEventListener("load", iframeLoaded);
+    ifr.setAttribute('src', "iframe_messageChannel_post.html");
+    div.appendChild(ifr);
+
+    function iframeLoaded() {
+      ifr.contentWindow.postMessage({ port: a.port2 }, '*', [a.port2]);
+    }
+
+    a.port1.addEventListener('message', receivePortMessage);
+    function receivePortMessage(evt) {
+      is(evt.data.ab.byteLength, size, "The size is: " + size + " == " + ab.byteLength);
+      window.removeEventListener('message', receiveMessage);
+      runTests();
+    }
+
+    // Start() is not implicity invoked when addEventListener is used.
+    a.port1.start();
+
+    var size = 1024 * 1024 * 32;
+    var ab = new ArrayBuffer(size);
+    is(ab.byteLength, size, "The size is: " + size + " == " + ab.byteLength);
+  }
+
+  function port_test() {
+    window.addEventListener('message', receiveMessage);
+    function receiveMessage(evt) {
+      ok(evt.data.type == 'OK', evt.data.msg);
+    }
+
+    var a = new MessageChannel();
+    ok(a, "MessageChannel created");
+
+    var div = document.getElementById("content");
+    ok(div, "Parent exists");
+
+    var ifr = document.createElement("iframe");
+    ifr.addEventListener("load", iframeLoaded);
+    ifr.setAttribute('src', "iframe_messageChannel_transferable.html");
+    div.appendChild(ifr);
+
+    function iframeLoaded() {
+      ifr.contentWindow.postMessage('foobar!', '*', [a.port2]);
+    }
+
+    a.port1.onmessage = function(evt) {
+      ok(evt.ports.length == 1, "Iframe sent a new port!");
+      evt.ports[0].onmessage = function(event) {
+        is(event.data, "hello world!", "Message sent and received!");
+        runTests();
+      }
+
+      evt.ports[0].postMessage("hello world!");
+    }
+  }
+
+  var tests = [
+    basic_test,
+    port_test
+  ];
+
+  function runTests() {
+    if (!tests.length) {
+      SimpleTest.finish();
+      return;
+    }
+
+    var t = tests.shift();
+    t();
+  }
+
+  SimpleTest.waitForExplicitFinish();
+  runTests();
+  </script>
+</body>
+</html>
diff --git a/dom/messagechannel/tests/test_messageChannel_unshipped.html b/dom/messagechannel/tests/test_messageChannel_unshipped.html
new file mode 100644
index 0000000000..44bf56979c
--- /dev/null
+++ b/dom/messagechannel/tests/test_messageChannel_unshipped.html
@@ -0,0 +1,123 @@
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=677638
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 677638 - unshipped message port queue</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=677638">Mozilla Bug 677638</a>
+<div id="content"></div>
+<pre id="test">
+</pre>
+  <script type="application/javascript">
+
+  function test_orderedMessages() {
+    var a = new MessageChannel();
+    ok(a, "MessageChannel created");
+
+    var b = new MessageChannel();
+    ok(b, "MessageChannel created");
+
+    var expectedNumber = 1;
+    function testEvent(number, id) {
+      is(expectedNumber, number, "This is the right number!");
+      ok(!((expectedNumber - id) % 4), "From the right port: " + expectedNumber + " " + id);
+      expectedNumber++;
+
+      if (expectedNumber >100) {
+        runTests();
+      }
+    }
+
+    a.port1.onmessage = function(evt) {
+      testEvent(evt.data, 2);
+    };
+
+    a.port2.onmessage = function(evt) {
+      testEvent(evt.data, 1);
+    };
+
+    b.port1.onmessage = function(evt) {
+      testEvent(evt.data, 4);
+    };
+
+    b.port2.onmessage = function(evt) {
+      testEvent(evt.data, 3);
+    };
+
+    for (var i = 0; i < 100;) {
+      a.port1.postMessage(++i);
+      a.port2.postMessage(++i);
+      b.port1.postMessage(++i);
+      b.port2.postMessage(++i);
+    }
+  }
+
+  function test_unstarted() {
+    var a = new MessageChannel();
+    ok(a, "MessageChannel created");
+
+    var b = new MessageChannel();
+    ok(b, "MessageChannel created");
+
+    var expectedNumber = 1;
+    function testEvent(number, id) {
+      is(expectedNumber, number, "This is the right number!");
+      ok(!((expectedNumber - id) % 3), "From the right port: " + expectedNumber + " " + id);
+      expectedNumber++;
+
+      // 102 because it's the first multiple of 3.
+      if (expectedNumber > 102) {
+        runTests();
+      }
+    }
+
+    a.port1.onmessage = function(evt) {
+      testEvent(evt.data, 2);
+    };
+
+    a.port2.onmessage = function(evt) {
+      testEvent(evt.data, 1);
+    };
+
+    b.port1.addEventListener("message", function() {
+      ok(false, "shouldn't be called");
+    });
+
+    b.port2.onmessage = function(evt) {
+      testEvent(evt.data, 3);
+    };
+
+    for (var i = 0; i < 100;) {
+      a.port1.postMessage(++i);
+      a.port2.postMessage(++i);
+      b.port1.postMessage(++i);
+      b.port2.postMessage(1000);
+    }
+  }
+
+  var tests = [
+    test_orderedMessages,
+    test_unstarted
+  ];
+
+  function runTests() {
+    if (!tests.length) {
+      SimpleTest.finish();
+      return;
+    }
+
+    var test = tests.shift();
+    test();
+  }
+
+  SimpleTest.waitForExplicitFinish();
+  runTests();
+  </script>
+</body>
+</html>
diff --git a/dom/messagechannel/tests/test_messageChannel_worker.html b/dom/messagechannel/tests/test_messageChannel_worker.html
new file mode 100644
index 0000000000..742212a5d3
--- /dev/null
+++ b/dom/messagechannel/tests/test_messageChannel_worker.html
@@ -0,0 +1,60 @@
+
+<!DOCTYPE HTML>
+<html>
+<!--
+https://bugzilla.mozilla.org/show_bug.cgi?id=677638
+-->
+<head>
+  <meta charset="utf-8">
+  <title>Test for Bug 677638 - basic support</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=677638">Mozilla Bug 677638</a>
+<p id="display"></p>
+<div id="content" style="display: none">
+  <iframe name="x" id="x"></iframe>
+  <iframe name="y" id="y"></iframe>
+</div>
+<pre id="test">
+</pre>
+  <script type="application/javascript">
+
+  var tests = [ 0, 3 ];
+
+  function runTests() {
+    if (!tests.length) {
+      SimpleTest.finish();
+      return;
+    }
+
+    var a = new Worker('worker_messageChannel.js');
+    a.onmessage = function(evt) {
+      if (evt.data.type == 'finish') {
+        runTests();
+      } else if (evt.data.type == 'info') {
+        info(evt.data.message);
+      } else if (evt.data.type == 'check') {
+        ok(evt.data.check, evt.data.message);
+      } else if (evt.data.type == 'port') {
+        is(evt.ports.length, 1, "A port has been received!");
+        evt.ports[0].onmessage = function(e) {
+          e.target.postMessage(e.data);
+        }
+      } else if (evt.data.type == 'newport') {
+        var ch = new MessageChannel();
+        ok(ch, "MessageChannel created");
+        ch.port1.postMessage(42);
+        a.postMessage('a gift!', [ch.port2]);
+      }
+    }
+
+    a.postMessage(tests.shift());
+  }
+
+  SimpleTest.waitForExplicitFinish();
+  runTests();
+  </script>
+</body>
+</html>
diff --git a/dom/messagechannel/tests/test_messageChannel_worker_forceClose.html b/dom/messagechannel/tests/test_messageChannel_worker_forceClose.html
new file mode 100644
index 0000000000..8de3450fb5
--- /dev/null
+++ b/dom/messagechannel/tests/test_messageChannel_worker_forceClose.html
@@ -0,0 +1,27 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Test for forcing the closing of the port in workers</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<div id="content"></div>
+<pre id="test">
+</pre>
+  <script type="application/javascript">
+
+  var worker = new Worker('data:javascript,onmessage = function(e) { "doing nothing with this port"; }');
+
+  var mc = new MessageChannel();
+  worker.postMessage(42, [mc.port2]);
+
+  for (var i = 0; i < 10; ++i) {
+    mc.port1.postMessage(i);
+  }
+
+  ok(true, "All the messages are sent! We should shutdown correctly.");
+  </script>
+</body>
+</html>
diff --git a/dom/messagechannel/tests/test_removedWindow.html b/dom/messagechannel/tests/test_removedWindow.html
new file mode 100644
index 0000000000..b660000fd8
--- /dev/null
+++ b/dom/messagechannel/tests/test_removedWindow.html
@@ -0,0 +1,55 @@
+<!DOCTYPE html>
+<title>MessagePort should not work when created from a disconnected window</title>
+<script src="/tests/SimpleTest/SimpleTest.js"></script>
+<link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+
+<body>
+<script>
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+runTest();
+
+async function runTest() {
+  let ifr = document.createElement('iframe');
+  await new Promise(resolve => {
+    ifr.onload = resolve;
+    ifr.src = 'support/empty.html';
+    document.body.appendChild(ifr);
+  });
+
+  let w = ifr.contentWindow;
+
+  let pre = new w.MessageChannel();
+  ok(!!pre, "We have a channel");
+
+  ifr.remove();
+
+  let post = new w.MessageChannel();
+  ok(!!post, "We have a channel");
+
+  // This should silently fail.
+  pre.port1.postMessage(42);
+  pre.port2.onmessage = e => {
+    ok(false, "No messages should be received!");
+  }
+
+  // This should silently fail.
+  post.port1.postMessage(42);
+  post.port2.onmessage = e => {
+    ok(false, "No messages should be received!");
+  }
+
+  // Let's use another MessagePort just to be sure no messages are received by
+  // port2.
+
+  let mc = new MessageChannel();
+  mc.port1.postMessage(42);
+  mc.port2.onmessage = e => {
+    ok(true, "Ready to complete the test");
+    SimpleTest.finish();
+  }
+}
+
+</script>
+</body>
diff --git a/dom/messagechannel/tests/unit/chromeWorker_messageChannel.js b/dom/messagechannel/tests/unit/chromeWorker_messageChannel.js
new file mode 100644
index 0000000000..3f557a4fb2
--- /dev/null
+++ b/dom/messagechannel/tests/unit/chromeWorker_messageChannel.js
@@ -0,0 +1,14 @@
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+onmessage = function (pingEvt) {
+  if (pingEvt.data == "ping") {
+    let { port1, port2 } = new MessageChannel();
+    port2.onmessage = helloEvt => {
+      if (helloEvt.data == "hello") {
+        helloEvt.ports[0].postMessage("goodbye");
+      }
+    };
+    pingEvt.ports[0].postMessage("pong", [port1]);
+  }
+};
diff --git a/dom/messagechannel/tests/unit/test_messageChannel.js b/dom/messagechannel/tests/unit/test_messageChannel.js
new file mode 100644
index 0000000000..d672920f71
--- /dev/null
+++ b/dom/messagechannel/tests/unit/test_messageChannel.js
@@ -0,0 +1,23 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+add_test(function test_messageChannel() {
+  do_test_pending();
+
+  let chromeWorker = new ChromeWorker(
+    "resource://test/chromeWorker_messageChannel.js"
+  );
+  let { port1, port2 } = new MessageChannel();
+  port2.onmessage = pongEvt => {
+    Assert.equal(pongEvt.data, "pong");
+    let { port1: newPort1, port2: newPort2 } = new MessageChannel();
+    newPort2.onmessage = goodbyeEvt => {
+      Assert.equal(goodbyeEvt.data, "goodbye");
+
+      do_test_finished();
+      run_next_test();
+    };
+    pongEvt.ports[0].postMessage("hello", [newPort1]);
+  };
+  chromeWorker.postMessage("ping", [port1]);
+});
diff --git a/dom/messagechannel/tests/unit/xpcshell.ini b/dom/messagechannel/tests/unit/xpcshell.ini
new file mode 100644
index 0000000000..7164d1ea96
--- /dev/null
+++ b/dom/messagechannel/tests/unit/xpcshell.ini
@@ -0,0 +1,7 @@
+[DEFAULT]
+head =
+skip-if = toolkit == 'android'
+support-files =
+  chromeWorker_messageChannel.js
+
+[test_messageChannel.js]
diff --git a/dom/messagechannel/tests/worker_messageChannel.js b/dom/messagechannel/tests/worker_messageChannel.js
new file mode 100644
index 0000000000..f0b97ee36c
--- /dev/null
+++ b/dom/messagechannel/tests/worker_messageChannel.js
@@ -0,0 +1,110 @@
+function ok(a, msg) {
+  postMessage({ type: "check", check: !!a, message: msg });
+}
+
+function is(a, b, msg) {
+  ok(a === b, msg);
+}
+
+function info(msg) {
+  postMessage({ type: "info", message: msg });
+}
+
+function finish() {
+  postMessage({ type: "finish" });
+}
+
+function basic() {
+  var a = new MessageChannel();
+  ok(a, "MessageChannel created");
+
+  var port1 = a.port1;
+  ok(port1, "MessageChannel.port1 exists");
+  is(port1, a.port1, "MessageChannel.port1 is port1");
+
+  var port2 = a.port2;
+  ok(port2, "MessageChannel.port1 exists");
+  is(port2, a.port2, "MessageChannel.port2 is port2");
+
+  ["postMessage", "start", "close"].forEach(function (e) {
+    ok(e in port1, "MessagePort1." + e + " exists");
+    ok(e in port2, "MessagePort2." + e + " exists");
+  });
+
+  runTests();
+}
+
+function sendMessages() {
+  var a = new MessageChannel();
+  ok(a, "MessageChannel created");
+
+  a.port1.postMessage("Hello world!");
+  a.port1.onmessage = function (e) {
+    is(e.data, "Hello world!", "The message is back!");
+    runTests();
+  };
+
+  a.port2.onmessage = function (e) {
+    a.port2.postMessage(e.data);
+  };
+}
+
+function transferPort() {
+  var a = new MessageChannel();
+  ok(a, "MessageChannel created");
+
+  a.port1.postMessage("Hello world!");
+  a.port1.onmessage = function (e) {
+    is(e.data, "Hello world!", "The message is back!");
+    runTests();
+  };
+
+  postMessage({ type: "port" }, [a.port2]);
+}
+
+function transferPort2() {
+  onmessage = function (evt) {
+    is(evt.ports.length, 1, "A port has been received by the worker");
+    evt.ports[0].onmessage = function (e) {
+      is(e.data, 42, "Data is 42!");
+      runTests();
+    };
+  };
+
+  postMessage({ type: "newport" });
+}
+
+var tests = [basic, sendMessages, transferPort, transferPort2];
+
+function runTests() {
+  if (!tests.length) {
+    finish();
+    return;
+  }
+
+  var t = tests.shift();
+  t();
+}
+
+var subworker;
+onmessage = function (evt) {
+  if (evt.data == 0) {
+    runTests();
+    return;
+  }
+
+  if (!subworker) {
+    info("Create a subworkers. ID: " + evt.data);
+    subworker = new Worker("worker_messageChannel.js");
+    subworker.onmessage = function (e) {
+      info("Proxy a message to the parent.");
+      postMessage(e.data, e.ports);
+    };
+
+    subworker.postMessage(evt.data - 1);
+    return;
+  }
+
+  info("Dispatch a message to the subworker.");
+  subworker.postMessage(evt.data, evt.ports);
+};
diff --git a/dom/messagechannel/tests/worker_messageChannel_any.js b/dom/messagechannel/tests/worker_messageChannel_any.js
new file mode 100644
index 0000000000..11018da9a0
--- /dev/null
+++ b/dom/messagechannel/tests/worker_messageChannel_any.js
@@ -0,0 +1,7 @@
+onmessage = function (evt) {
+  evt.data.onmessage = function (event) {
+    evt.data.postMessage(event.data);
+  };
+};
+
+postMessage("READY");