Adding upstream version 86.0.1.upstream/86.0.1upstream

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

150 files changed, 26418 insertions, 0 deletions

diff --git a/dom/presentation/AvailabilityCollection.cpp b/dom/presentation/AvailabilityCollection.cpp
new file mode 100644
index 0000000000..33e2e394c0
--- /dev/null
+++ b/dom/presentation/AvailabilityCollection.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 "AvailabilityCollection.h"
+
+#include "mozilla/ClearOnShutdown.h"
+#include "PresentationAvailability.h"
+
+namespace mozilla {
+namespace dom {
+
+/* static */
+StaticAutoPtr<AvailabilityCollection> AvailabilityCollection::sSingleton;
+static bool gOnceAliveNowDead = false;
+
+/* static */
+AvailabilityCollection* AvailabilityCollection::GetSingleton() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!sSingleton && !gOnceAliveNowDead) {
+    sSingleton = new AvailabilityCollection();
+    ClearOnShutdown(&sSingleton);
+  }
+
+  return sSingleton;
+}
+
+AvailabilityCollection::AvailabilityCollection() {
+  MOZ_COUNT_CTOR(AvailabilityCollection);
+}
+
+AvailabilityCollection::~AvailabilityCollection() {
+  MOZ_COUNT_DTOR(AvailabilityCollection);
+  gOnceAliveNowDead = true;
+}
+
+void AvailabilityCollection::Add(PresentationAvailability* aAvailability) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!aAvailability) {
+    return;
+  }
+
+  WeakPtr<PresentationAvailability> availability = aAvailability;
+  if (mAvailabilities.Contains(aAvailability)) {
+    return;
+  }
+
+  mAvailabilities.AppendElement(aAvailability);
+}
+
+void AvailabilityCollection::Remove(PresentationAvailability* aAvailability) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!aAvailability) {
+    return;
+  }
+
+  WeakPtr<PresentationAvailability> availability = aAvailability;
+  mAvailabilities.RemoveElement(availability);
+}
+
+already_AddRefed<PresentationAvailability> AvailabilityCollection::Find(
+    const uint64_t aWindowId, const nsTArray<nsString>& aUrls) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  // Loop backwards to allow removing elements in the loop.
+  for (int i = mAvailabilities.Length() - 1; i >= 0; --i) {
+    WeakPtr<PresentationAvailability> availability = mAvailabilities[i];
+    if (!availability) {
+      // The availability object was destroyed. Remove it from the list.
+      mAvailabilities.RemoveElementAt(i);
+      continue;
+    }
+
+    if (availability->Equals(aWindowId, aUrls)) {
+      RefPtr<PresentationAvailability> matchedAvailability = availability.get();
+      return matchedAvailability.forget();
+    }
+  }
+
+  return nullptr;
+}
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/presentation/AvailabilityCollection.h b/dom/presentation/AvailabilityCollection.h
new file mode 100644
index 0000000000..0e0914850d
--- /dev/null
+++ b/dom/presentation/AvailabilityCollection.h
@@ -0,0 +1,44 @@
+/* -*- 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_AvailabilityCollection_h
+#define mozilla_dom_AvailabilityCollection_h
+
+#include "mozilla/StaticPtr.h"
+#include "mozilla/WeakPtr.h"
+#include "nsString.h"
+#include "nsTArray.h"
+
+namespace mozilla {
+namespace dom {
+
+class PresentationAvailability;
+
+class AvailabilityCollection final {
+ public:
+  static AvailabilityCollection* GetSingleton();
+
+  void Add(PresentationAvailability* aAvailability);
+
+  void Remove(PresentationAvailability* aAvailability);
+
+  already_AddRefed<PresentationAvailability> Find(
+      const uint64_t aWindowId, const nsTArray<nsString>& aUrls);
+
+ private:
+  friend class StaticAutoPtr<AvailabilityCollection>;
+
+  AvailabilityCollection();
+  virtual ~AvailabilityCollection();
+
+  static StaticAutoPtr<AvailabilityCollection> sSingleton;
+  nsTArray<WeakPtr<PresentationAvailability>> mAvailabilities;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_AvailabilityCollection_h
diff --git a/dom/presentation/ControllerConnectionCollection.cpp b/dom/presentation/ControllerConnectionCollection.cpp
new file mode 100644
index 0000000000..96659cbfba
--- /dev/null
+++ b/dom/presentation/ControllerConnectionCollection.cpp
@@ -0,0 +1,105 @@
+/* -*- 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 "ControllerConnectionCollection.h"
+
+#include "mozilla/ClearOnShutdown.h"
+#include "nsIPresentationService.h"
+#include "PresentationConnection.h"
+
+namespace mozilla {
+namespace dom {
+
+/* static */
+StaticAutoPtr<ControllerConnectionCollection>
+    ControllerConnectionCollection::sSingleton;
+
+/* static */
+ControllerConnectionCollection* ControllerConnectionCollection::GetSingleton() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!sSingleton) {
+    sSingleton = new ControllerConnectionCollection();
+    ClearOnShutdown(&sSingleton);
+  }
+
+  return sSingleton;
+}
+
+ControllerConnectionCollection::ControllerConnectionCollection() {
+  MOZ_COUNT_CTOR(ControllerConnectionCollection);
+}
+
+ControllerConnectionCollection::~ControllerConnectionCollection() {
+  MOZ_COUNT_DTOR(ControllerConnectionCollection);
+}
+
+void ControllerConnectionCollection::AddConnection(
+    PresentationConnection* aConnection, const uint8_t aRole) {
+  MOZ_ASSERT(NS_IsMainThread());
+  if (aRole != nsIPresentationService::ROLE_CONTROLLER) {
+    MOZ_ASSERT(false, "This is allowed only to be called at controller side.");
+    return;
+  }
+
+  if (!aConnection) {
+    return;
+  }
+
+  WeakPtr<PresentationConnection> connection = aConnection;
+  if (mConnections.Contains(connection)) {
+    return;
+  }
+
+  mConnections.AppendElement(connection);
+}
+
+void ControllerConnectionCollection::RemoveConnection(
+    PresentationConnection* aConnection, const uint8_t aRole) {
+  MOZ_ASSERT(NS_IsMainThread());
+  if (aRole != nsIPresentationService::ROLE_CONTROLLER) {
+    MOZ_ASSERT(false, "This is allowed only to be called at controller side.");
+    return;
+  }
+
+  if (!aConnection) {
+    return;
+  }
+
+  WeakPtr<PresentationConnection> connection = aConnection;
+  mConnections.RemoveElement(connection);
+}
+
+already_AddRefed<PresentationConnection>
+ControllerConnectionCollection::FindConnection(uint64_t aWindowId,
+                                               const nsAString& aId,
+                                               const uint8_t aRole) {
+  MOZ_ASSERT(NS_IsMainThread());
+  if (aRole != nsIPresentationService::ROLE_CONTROLLER) {
+    MOZ_ASSERT(false, "This is allowed only to be called at controller side.");
+    return nullptr;
+  }
+
+  // Loop backwards to allow removing elements in the loop.
+  for (int i = mConnections.Length() - 1; i >= 0; --i) {
+    WeakPtr<PresentationConnection> connection = mConnections[i];
+    if (!connection) {
+      // The connection was destroyed. Remove it from the list.
+      mConnections.RemoveElementAt(i);
+      continue;
+    }
+
+    if (connection->Equals(aWindowId, aId)) {
+      RefPtr<PresentationConnection> matchedConnection = connection.get();
+      return matchedConnection.forget();
+    }
+  }
+
+  return nullptr;
+}
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/presentation/ControllerConnectionCollection.h b/dom/presentation/ControllerConnectionCollection.h
new file mode 100644
index 0000000000..c48e9ca495
--- /dev/null
+++ b/dom/presentation/ControllerConnectionCollection.h
@@ -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/. */
+
+#ifndef mozilla_dom_ControllerConnectionCollection_h
+#define mozilla_dom_ControllerConnectionCollection_h
+
+#include "mozilla/StaticPtr.h"
+#include "mozilla/WeakPtr.h"
+#include "nsString.h"
+#include "nsTArray.h"
+
+namespace mozilla {
+namespace dom {
+
+class PresentationConnection;
+
+class ControllerConnectionCollection final {
+ public:
+  static ControllerConnectionCollection* GetSingleton();
+
+  void AddConnection(PresentationConnection* aConnection, const uint8_t aRole);
+
+  void RemoveConnection(PresentationConnection* aConnection,
+                        const uint8_t aRole);
+
+  already_AddRefed<PresentationConnection> FindConnection(uint64_t aWindowId,
+                                                          const nsAString& aId,
+                                                          const uint8_t aRole);
+
+ private:
+  friend class StaticAutoPtr<ControllerConnectionCollection>;
+
+  ControllerConnectionCollection();
+  virtual ~ControllerConnectionCollection();
+
+  static StaticAutoPtr<ControllerConnectionCollection> sSingleton;
+  nsTArray<WeakPtr<PresentationConnection>> mConnections;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_ControllerConnectionCollection_h
diff --git a/dom/presentation/DCPresentationChannelDescription.cpp b/dom/presentation/DCPresentationChannelDescription.cpp
new file mode 100644
index 0000000000..471ede837e
--- /dev/null
+++ b/dom/presentation/DCPresentationChannelDescription.cpp
@@ -0,0 +1,43 @@
+/* -*- 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 "DCPresentationChannelDescription.h"
+
+namespace mozilla {
+namespace dom {
+
+NS_IMPL_ISUPPORTS(DCPresentationChannelDescription,
+                  nsIPresentationChannelDescription)
+
+NS_IMETHODIMP
+DCPresentationChannelDescription::GetType(uint8_t* aRetVal) {
+  if (NS_WARN_IF(!aRetVal)) {
+    return NS_ERROR_INVALID_POINTER;
+  }
+
+  *aRetVal = nsIPresentationChannelDescription::TYPE_DATACHANNEL;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+DCPresentationChannelDescription::GetTcpAddress(nsIArray** aRetVal) {
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+DCPresentationChannelDescription::GetTcpPort(uint16_t* aRetVal) {
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+DCPresentationChannelDescription::GetDataChannelSDP(
+    nsAString& aDataChannelSDP) {
+  aDataChannelSDP = mSDP;
+  return NS_OK;
+}
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/presentation/DCPresentationChannelDescription.h b/dom/presentation/DCPresentationChannelDescription.h
new file mode 100644
index 0000000000..997f3d99e5
--- /dev/null
+++ b/dom/presentation/DCPresentationChannelDescription.h
@@ -0,0 +1,35 @@
+/* -*- 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_DCPresentationChannelDescription_h
+#define mozilla_dom_DCPresentationChannelDescription_h
+
+#include "nsIPresentationControlChannel.h"
+#include "nsString.h"
+
+namespace mozilla {
+namespace dom {
+
+// PresentationChannelDescription for Data Channel
+class DCPresentationChannelDescription final
+    : public nsIPresentationChannelDescription {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPRESENTATIONCHANNELDESCRIPTION
+
+  explicit DCPresentationChannelDescription(const nsAString& aSDP)
+      : mSDP(aSDP) {}
+
+ private:
+  virtual ~DCPresentationChannelDescription() = default;
+
+  nsString mSDP;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_DCPresentationChannelDescription_h
diff --git a/dom/presentation/MockedSocketTransport.cpp b/dom/presentation/MockedSocketTransport.cpp
new file mode 100644
index 0000000000..f5d29f746c
--- /dev/null
+++ b/dom/presentation/MockedSocketTransport.cpp
@@ -0,0 +1,224 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=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 https://mozilla.org/MPL/2.0/. */
+
+#include "MockedSocketTransport.h"
+
+using namespace mozilla::net;
+
+namespace mozilla {
+namespace dom {
+
+NS_IMPL_ISUPPORTS(MockedSocketTransport, nsISocketTransport, nsITransport)
+
+// static
+already_AddRefed<MockedSocketTransport> MockedSocketTransport::Create() {
+  RefPtr<MockedSocketTransport> transport = new MockedSocketTransport();
+  return transport.forget();
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::SetKeepaliveEnabled(bool) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::SetKeepaliveVals(int32_t, int32_t) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::GetSecurityCallbacks(nsIInterfaceRequestor**) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::SetSecurityCallbacks(nsIInterfaceRequestor*) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::OpenInputStream(uint32_t, uint32_t, uint32_t,
+                                       nsIInputStream**) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::OpenOutputStream(uint32_t, uint32_t, uint32_t,
+                                        nsIOutputStream**) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::Close(nsresult) { return NS_ERROR_NOT_IMPLEMENTED; }
+
+NS_IMETHODIMP
+MockedSocketTransport::SetEventSink(nsITransportEventSink*, nsIEventTarget*) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::Bind(NetAddr*) { return NS_ERROR_NOT_IMPLEMENTED; }
+
+NS_IMETHODIMP
+MockedSocketTransport::GetFirstRetryError(nsresult*) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::GetEchConfigUsed(bool*) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::SetEchConfig(const nsACString&) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::ResolvedByTRR(bool*) { return NS_ERROR_NOT_IMPLEMENTED; }
+
+nsresult MockedSocketTransport::GetOriginAttributes(
+    mozilla::OriginAttributes*) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::GetKeepaliveEnabled(bool*) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::GetSendBufferSize(uint32_t*) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::SetSendBufferSize(uint32_t) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::GetPort(int32_t*) { return NS_ERROR_NOT_IMPLEMENTED; }
+
+NS_IMETHODIMP
+MockedSocketTransport::GetPeerAddr(mozilla::net::NetAddr*) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::GetSelfAddr(mozilla::net::NetAddr*) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::GetScriptablePeerAddr(nsINetAddr**) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::GetScriptableSelfAddr(nsINetAddr**) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::GetSecurityInfo(nsISupports**) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::IsAlive(bool*) { return NS_ERROR_NOT_IMPLEMENTED; }
+
+NS_IMETHODIMP
+MockedSocketTransport::GetConnectionFlags(uint32_t*) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::SetConnectionFlags(uint32_t) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::SetIsPrivate(bool) { return NS_ERROR_NOT_IMPLEMENTED; }
+
+NS_IMETHODIMP
+MockedSocketTransport::GetTlsFlags(uint32_t*) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::SetTlsFlags(uint32_t) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::GetRecvBufferSize(uint32_t*) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::SetRecvBufferSize(uint32_t) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::GetResetIPFamilyPreference(bool*) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+nsresult MockedSocketTransport::SetOriginAttributes(
+    const mozilla::OriginAttributes&) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::GetScriptableOriginAttributes(
+    JSContext* aCx, JS::MutableHandle<JS::Value>) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::SetScriptableOriginAttributes(JSContext* aCx,
+                                                     JS::Handle<JS::Value>) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::GetHost(nsACString&) { return NS_ERROR_NOT_IMPLEMENTED; }
+
+NS_IMETHODIMP
+MockedSocketTransport::GetTimeout(uint32_t, uint32_t*) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::SetTimeout(uint32_t, uint32_t) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::SetReuseAddrPort(bool) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::SetLinger(bool, int16_t) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+NS_IMETHODIMP
+MockedSocketTransport::GetQoSBits(uint8_t*) { return NS_ERROR_NOT_IMPLEMENTED; }
+
+NS_IMETHODIMP
+MockedSocketTransport::SetQoSBits(uint8_t) { return NS_ERROR_NOT_IMPLEMENTED; }
+
+NS_IMETHODIMP
+MockedSocketTransport::SetFastOpenCallback(TCPFastOpen*) {
+  return NS_ERROR_NOT_IMPLEMENTED;
+}
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/presentation/MockedSocketTransport.h b/dom/presentation/MockedSocketTransport.h
new file mode 100644
index 0000000000..c83e8f1382
--- /dev/null
+++ b/dom/presentation/MockedSocketTransport.h
@@ -0,0 +1,36 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=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 https://mozilla.org/MPL/2.0/. */
+
+#ifndef DOM_PRESENTATION_MOCKEDSOCKETTRANSPORT_H_
+#define DOM_PRESENTATION_MOCKEDSOCKETTRANSPORT_H_
+
+#include "nsISocketTransport.h"
+
+namespace mozilla {
+namespace dom {
+
+// For testing purposes, we need a mocked socket transport that doesn't do
+// anything. It has to be implemented in C++ because nsISocketTransport is
+// builtinclass because it contains nostdcall methods.
+
+class MockedSocketTransport final : public nsISocketTransport {
+ public:
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSITRANSPORT
+  NS_DECL_NSISOCKETTRANSPORT
+
+  MockedSocketTransport() = default;
+
+  static already_AddRefed<MockedSocketTransport> Create();
+
+ protected:
+  virtual ~MockedSocketTransport() = default;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // DOM_PRESENTATION_MOCKEDSOCKETTRANSPORT_H_
diff --git a/dom/presentation/Presentation.cpp b/dom/presentation/Presentation.cpp
new file mode 100644
index 0000000000..9f27fa56f7
--- /dev/null
+++ b/dom/presentation/Presentation.cpp
@@ -0,0 +1,180 @@
+/* -*- 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 "Presentation.h"
+
+#include <ctype.h>
+
+#include "mozilla/StaticPrefs_dom.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/dom/PresentationBinding.h"
+#include "mozilla/dom/PresentationRequest.h"
+#include "mozilla/dom/Promise.h"
+#include "nsContentUtils.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsIDocShell.h"
+#include "nsIScriptSecurityManager.h"
+#include "nsJSUtils.h"
+#include "nsNetUtil.h"
+#include "nsPIDOMWindow.h"
+#include "nsSandboxFlags.h"
+#include "nsServiceManagerUtils.h"
+#include "PresentationReceiver.h"
+
+namespace mozilla {
+namespace dom {
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(Presentation, mWindow, mDefaultRequest,
+                                      mReceiver)
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(Presentation)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(Presentation)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(Presentation)
+  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+/* static */
+already_AddRefed<Presentation> Presentation::Create(
+    nsPIDOMWindowInner* aWindow) {
+  RefPtr<Presentation> presentation = new Presentation(aWindow);
+  return presentation.forget();
+}
+
+Presentation::Presentation(nsPIDOMWindowInner* aWindow) : mWindow(aWindow) {}
+
+Presentation::~Presentation() = default;
+
+/* virtual */
+JSObject* Presentation::WrapObject(JSContext* aCx,
+                                   JS::Handle<JSObject*> aGivenProto) {
+  return Presentation_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+void Presentation::SetDefaultRequest(PresentationRequest* aRequest) {
+  if (nsContentUtils::ShouldResistFingerprinting()) {
+    return;
+  }
+
+  nsCOMPtr<Document> doc = mWindow ? mWindow->GetExtantDoc() : nullptr;
+  if (NS_WARN_IF(!doc)) {
+    return;
+  }
+
+  if (doc->GetSandboxFlags() & SANDBOXED_PRESENTATION) {
+    return;
+  }
+
+  mDefaultRequest = aRequest;
+}
+
+already_AddRefed<PresentationRequest> Presentation::GetDefaultRequest() const {
+  if (nsContentUtils::ShouldResistFingerprinting()) {
+    return nullptr;
+  }
+
+  RefPtr<PresentationRequest> request = mDefaultRequest;
+  return request.forget();
+}
+
+already_AddRefed<PresentationReceiver> Presentation::GetReceiver() {
+  if (nsContentUtils::ShouldResistFingerprinting()) {
+    return nullptr;
+  }
+
+  // return the same receiver if already created
+  if (mReceiver) {
+    RefPtr<PresentationReceiver> receiver = mReceiver;
+    return receiver.forget();
+  }
+
+  if (!HasReceiverSupport() || !IsInPresentedContent()) {
+    return nullptr;
+  }
+
+  mReceiver = PresentationReceiver::Create(mWindow);
+  if (NS_WARN_IF(!mReceiver)) {
+    MOZ_ASSERT(mReceiver);
+    return nullptr;
+  }
+
+  RefPtr<PresentationReceiver> receiver = mReceiver;
+  return receiver.forget();
+}
+
+void Presentation::SetStartSessionUnsettled(bool aIsUnsettled) {
+  mStartSessionUnsettled = aIsUnsettled;
+}
+
+bool Presentation::IsStartSessionUnsettled() const {
+  return mStartSessionUnsettled;
+}
+
+bool Presentation::HasReceiverSupport() const {
+  if (!mWindow) {
+    return false;
+  }
+
+  // Grant access to browser receiving pages and their same-origin iframes. (App
+  // pages should be controlled by "presentation" permission in app manifests.)
+  nsCOMPtr<nsIDocShell> docShell = mWindow->GetDocShell();
+  if (!docShell) {
+    return false;
+  }
+
+  if (!StaticPrefs::dom_presentation_testing_simulate_receiver() &&
+      !docShell->GetIsTopLevelContentDocShell()) {
+    return false;
+  }
+
+  nsAutoString presentationURL;
+  nsContentUtils::GetPresentationURL(docShell, presentationURL);
+
+  if (presentationURL.IsEmpty()) {
+    return false;
+  }
+
+  nsCOMPtr<nsIScriptSecurityManager> securityManager =
+      nsContentUtils::GetSecurityManager();
+  if (!securityManager) {
+    return false;
+  }
+
+  nsCOMPtr<nsIURI> presentationURI;
+  nsresult rv = NS_NewURI(getter_AddRefs(presentationURI), presentationURL);
+  if (NS_FAILED(rv)) {
+    return false;
+  }
+
+  bool isPrivateWin = false;
+  nsCOMPtr<Document> doc = mWindow->GetExtantDoc();
+  if (doc) {
+    isPrivateWin =
+        doc->NodePrincipal()->OriginAttributesRef().mPrivateBrowsingId > 0;
+  }
+
+  nsCOMPtr<nsIURI> docURI = mWindow->GetDocumentURI();
+  return NS_SUCCEEDED(securityManager->CheckSameOriginURI(
+      presentationURI, docURI, false, isPrivateWin));
+}
+
+bool Presentation::IsInPresentedContent() const {
+  if (!mWindow) {
+    return false;
+  }
+
+  nsCOMPtr<nsIDocShell> docShell = mWindow->GetDocShell();
+  MOZ_ASSERT(docShell);
+
+  nsAutoString presentationURL;
+  nsContentUtils::GetPresentationURL(docShell, presentationURL);
+
+  return !presentationURL.IsEmpty();
+}
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/presentation/Presentation.h b/dom/presentation/Presentation.h
new file mode 100644
index 0000000000..c2c0284ce7
--- /dev/null
+++ b/dom/presentation/Presentation.h
@@ -0,0 +1,65 @@
+/* -*- 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_Presentation_h
+#define mozilla_dom_Presentation_h
+
+#include "nsCOMPtr.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsISupportsImpl.h"
+#include "nsWrapperCache.h"
+
+class nsPIDOMWindowInner;
+
+namespace mozilla {
+namespace dom {
+
+class Promise;
+class PresentationReceiver;
+class PresentationRequest;
+
+class Presentation final : public nsISupports, public nsWrapperCache {
+ public:
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(Presentation)
+
+  static already_AddRefed<Presentation> Create(nsPIDOMWindowInner* aWindow);
+
+  virtual JSObject* WrapObject(JSContext* aCx,
+                               JS::Handle<JSObject*> aGivenProto) override;
+
+  nsPIDOMWindowInner* GetParentObject() const { return mWindow; }
+
+  // WebIDL (public APIs)
+  void SetDefaultRequest(PresentationRequest* aRequest);
+
+  already_AddRefed<PresentationRequest> GetDefaultRequest() const;
+
+  already_AddRefed<PresentationReceiver> GetReceiver();
+
+  // For bookkeeping unsettled start session request
+  void SetStartSessionUnsettled(bool aIsUnsettled);
+  bool IsStartSessionUnsettled() const;
+
+ private:
+  explicit Presentation(nsPIDOMWindowInner* aWindow);
+
+  virtual ~Presentation();
+
+  bool HasReceiverSupport() const;
+
+  bool IsInPresentedContent() const;
+
+  RefPtr<PresentationRequest> mDefaultRequest;
+  RefPtr<PresentationReceiver> mReceiver;
+  nsCOMPtr<nsPIDOMWindowInner> mWindow;
+  bool mStartSessionUnsettled = false;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_Presentation_h
diff --git a/dom/presentation/PresentationAvailability.cpp b/dom/presentation/PresentationAvailability.cpp
new file mode 100644
index 0000000000..ba816f975a
--- /dev/null
+++ b/dom/presentation/PresentationAvailability.cpp
@@ -0,0 +1,203 @@
+/* -*- 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 "PresentationAvailability.h"
+
+#include "mozilla/dom/PresentationAvailabilityBinding.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/Logging.h"
+#include "mozilla/Unused.h"
+#include "nsContentUtils.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsIPresentationService.h"
+#include "nsServiceManagerUtils.h"
+#include "AvailabilityCollection.h"
+#include "PresentationLog.h"
+
+namespace mozilla {
+namespace dom {
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(PresentationAvailability)
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(PresentationAvailability,
+                                                  DOMEventTargetHelper)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mPromises)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(PresentationAvailability,
+                                                DOMEventTargetHelper)
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mPromises);
+  tmp->Shutdown();
+  NS_IMPL_CYCLE_COLLECTION_UNLINK_WEAK_PTR
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_ADDREF_INHERITED(PresentationAvailability, DOMEventTargetHelper)
+NS_IMPL_RELEASE_INHERITED(PresentationAvailability, DOMEventTargetHelper)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PresentationAvailability)
+  NS_INTERFACE_MAP_ENTRY(nsIPresentationAvailabilityListener)
+NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
+
+/* static */
+already_AddRefed<PresentationAvailability> PresentationAvailability::Create(
+    nsPIDOMWindowInner* aWindow, const nsTArray<nsString>& aUrls,
+    RefPtr<Promise>& aPromise) {
+  RefPtr<PresentationAvailability> availability =
+      new PresentationAvailability(aWindow, aUrls);
+  return NS_WARN_IF(!availability->Init(aPromise)) ? nullptr
+                                                   : availability.forget();
+}
+
+PresentationAvailability::PresentationAvailability(
+    nsPIDOMWindowInner* aWindow, const nsTArray<nsString>& aUrls)
+    : DOMEventTargetHelper(aWindow), mIsAvailable(false), mUrls(aUrls.Clone()) {
+  for (uint32_t i = 0; i < mUrls.Length(); ++i) {
+    mAvailabilityOfUrl.AppendElement(false);
+  }
+}
+
+PresentationAvailability::~PresentationAvailability() { Shutdown(); }
+
+bool PresentationAvailability::Init(RefPtr<Promise>& aPromise) {
+  nsCOMPtr<nsIPresentationService> service =
+      do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+  if (NS_WARN_IF(!service)) {
+    return false;
+  }
+
+  nsresult rv = service->RegisterAvailabilityListener(mUrls, this);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    // If the user agent is unable to monitor available device,
+    // Resolve promise with |value| set to false.
+    mIsAvailable = false;
+    aPromise->MaybeResolve(this);
+    return true;
+  }
+
+  EnqueuePromise(aPromise);
+
+  AvailabilityCollection* collection = AvailabilityCollection::GetSingleton();
+  if (collection) {
+    collection->Add(this);
+  }
+
+  return true;
+}
+
+void PresentationAvailability::Shutdown() {
+  AvailabilityCollection* collection = AvailabilityCollection::GetSingleton();
+  if (collection) {
+    collection->Remove(this);
+  }
+
+  nsCOMPtr<nsIPresentationService> service =
+      do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+  if (NS_WARN_IF(!service)) {
+    return;
+  }
+
+  Unused << NS_WARN_IF(
+      NS_FAILED(service->UnregisterAvailabilityListener(mUrls, this)));
+}
+
+/* virtual */
+void PresentationAvailability::DisconnectFromOwner() {
+  Shutdown();
+  DOMEventTargetHelper::DisconnectFromOwner();
+}
+
+/* virtual */
+JSObject* PresentationAvailability::WrapObject(
+    JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
+  return PresentationAvailability_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+bool PresentationAvailability::Equals(const uint64_t aWindowID,
+                                      const nsTArray<nsString>& aUrls) const {
+  if (GetOwner() && GetOwner()->WindowID() == aWindowID &&
+      mUrls.Length() == aUrls.Length()) {
+    for (const auto& url : aUrls) {
+      if (!mUrls.Contains(url)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  return false;
+}
+
+bool PresentationAvailability::IsCachedValueReady() {
+  // All pending promises will be solved when cached value is ready and
+  // no promise should be enqueued afterward.
+  return mPromises.IsEmpty();
+}
+
+void PresentationAvailability::EnqueuePromise(RefPtr<Promise>& aPromise) {
+  mPromises.AppendElement(aPromise);
+}
+
+bool PresentationAvailability::Value() const {
+  if (nsContentUtils::ShouldResistFingerprinting()) {
+    return false;
+  }
+
+  return mIsAvailable;
+}
+
+NS_IMETHODIMP
+PresentationAvailability::NotifyAvailableChange(
+    const nsTArray<nsString>& aAvailabilityUrls, bool aIsAvailable) {
+  bool available = false;
+  for (uint32_t i = 0; i < mUrls.Length(); ++i) {
+    if (aAvailabilityUrls.Contains(mUrls[i])) {
+      mAvailabilityOfUrl[i] = aIsAvailable;
+    }
+    available |= mAvailabilityOfUrl[i];
+  }
+
+  return NS_DispatchToCurrentThread(NewRunnableMethod<bool>(
+      "dom::PresentationAvailability::UpdateAvailabilityAndDispatchEvent", this,
+      &PresentationAvailability::UpdateAvailabilityAndDispatchEvent,
+      available));
+}
+
+void PresentationAvailability::UpdateAvailabilityAndDispatchEvent(
+    bool aIsAvailable) {
+  PRES_DEBUG("%s\n", __func__);
+  bool isChanged = (aIsAvailable != mIsAvailable);
+
+  mIsAvailable = aIsAvailable;
+
+  if (!mPromises.IsEmpty()) {
+    // Use the first availability change notification to resolve promise.
+    do {
+      nsTArray<RefPtr<Promise>> promises = std::move(mPromises);
+
+      if (nsContentUtils::ShouldResistFingerprinting()) {
+        continue;
+      }
+
+      for (auto& promise : promises) {
+        promise->MaybeResolve(this);
+      }
+      // more promises may have been added to mPromises, at least in theory
+    } while (!mPromises.IsEmpty());
+
+    return;
+  }
+
+  if (nsContentUtils::ShouldResistFingerprinting()) {
+    return;
+  }
+
+  if (isChanged) {
+    Unused << NS_WARN_IF(NS_FAILED(DispatchTrustedEvent(u"change"_ns)));
+  }
+}
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/presentation/PresentationAvailability.h b/dom/presentation/PresentationAvailability.h
new file mode 100644
index 0000000000..0559841046
--- /dev/null
+++ b/dom/presentation/PresentationAvailability.h
@@ -0,0 +1,73 @@
+/* -*- 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_PresentationAvailability_h
+#define mozilla_dom_PresentationAvailability_h
+
+#include "mozilla/DOMEventTargetHelper.h"
+#include "mozilla/WeakPtr.h"
+#include "nsIPresentationListener.h"
+#include "nsTArray.h"
+
+namespace mozilla {
+namespace dom {
+
+class Promise;
+
+class PresentationAvailability final
+    : public DOMEventTargetHelper,
+      public nsIPresentationAvailabilityListener,
+      public SupportsWeakPtr {
+ public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(PresentationAvailability,
+                                           DOMEventTargetHelper)
+  NS_DECL_NSIPRESENTATIONAVAILABILITYLISTENER
+
+  static already_AddRefed<PresentationAvailability> Create(
+      nsPIDOMWindowInner* aWindow, const nsTArray<nsString>& aUrls,
+      RefPtr<Promise>& aPromise);
+
+  virtual void DisconnectFromOwner() override;
+
+  virtual JSObject* WrapObject(JSContext* aCx,
+                               JS::Handle<JSObject*> aGivenProto) override;
+
+  bool Equals(const uint64_t aWindowID, const nsTArray<nsString>& aUrls) const;
+
+  bool IsCachedValueReady();
+
+  void EnqueuePromise(RefPtr<Promise>& aPromise);
+
+  // WebIDL (public APIs)
+  bool Value() const;
+
+  IMPL_EVENT_HANDLER(change);
+
+ private:
+  explicit PresentationAvailability(nsPIDOMWindowInner* aWindow,
+                                    const nsTArray<nsString>& aUrls);
+
+  virtual ~PresentationAvailability();
+
+  bool Init(RefPtr<Promise>& aPromise);
+
+  void Shutdown();
+
+  void UpdateAvailabilityAndDispatchEvent(bool aIsAvailable);
+
+  bool mIsAvailable;
+
+  nsTArray<RefPtr<Promise>> mPromises;
+
+  nsTArray<nsString> mUrls;
+  nsTArray<bool> mAvailabilityOfUrl;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_PresentationAvailability_h
diff --git a/dom/presentation/PresentationCallbacks.cpp b/dom/presentation/PresentationCallbacks.cpp
new file mode 100644
index 0000000000..8880ba9b7c
--- /dev/null
+++ b/dom/presentation/PresentationCallbacks.cpp
@@ -0,0 +1,251 @@
+/* -*- 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 "mozilla/dom/Promise.h"
+#include "nsIDocShell.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsIPresentationService.h"
+#include "nsIWebProgress.h"
+#include "nsServiceManagerUtils.h"
+#include "nsThreadUtils.h"
+#include "PresentationCallbacks.h"
+#include "PresentationRequest.h"
+#include "PresentationConnection.h"
+#include "PresentationTransportBuilderConstructor.h"
+
+namespace mozilla {
+namespace dom {
+
+/*
+ * Implementation of PresentationRequesterCallback
+ */
+
+NS_IMPL_ISUPPORTS(PresentationRequesterCallback, nsIPresentationServiceCallback)
+
+PresentationRequesterCallback::PresentationRequesterCallback(
+    PresentationRequest* aRequest, const nsAString& aSessionId,
+    Promise* aPromise)
+    : mRequest(aRequest), mSessionId(aSessionId), mPromise(aPromise) {
+  MOZ_ASSERT(mRequest);
+  MOZ_ASSERT(mPromise);
+  MOZ_ASSERT(!mSessionId.IsEmpty());
+}
+
+PresentationRequesterCallback::~PresentationRequesterCallback() = default;
+
+// nsIPresentationServiceCallback
+NS_IMETHODIMP
+PresentationRequesterCallback::NotifySuccess(const nsAString& aUrl) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (aUrl.IsEmpty()) {
+    return NotifyError(NS_ERROR_DOM_OPERATION_ERR);
+  }
+
+  RefPtr<PresentationConnection> connection =
+      PresentationConnection::Create(mRequest->GetOwner(), mSessionId, aUrl,
+                                     nsIPresentationService::ROLE_CONTROLLER);
+  if (NS_WARN_IF(!connection)) {
+    return NotifyError(NS_ERROR_DOM_OPERATION_ERR);
+  }
+
+  mRequest->NotifyPromiseSettled();
+  mPromise->MaybeResolve(connection);
+
+  return mRequest->DispatchConnectionAvailableEvent(connection);
+}
+
+NS_IMETHODIMP
+PresentationRequesterCallback::NotifyError(nsresult aError) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  mRequest->NotifyPromiseSettled();
+  mPromise->MaybeReject(aError);
+  return NS_OK;
+}
+
+/*
+ * Implementation of PresentationRequesterCallback
+ */
+
+PresentationReconnectCallback::PresentationReconnectCallback(
+    PresentationRequest* aRequest, const nsAString& aSessionId,
+    Promise* aPromise, PresentationConnection* aConnection)
+    : PresentationRequesterCallback(aRequest, aSessionId, aPromise),
+      mConnection(aConnection) {}
+
+PresentationReconnectCallback::~PresentationReconnectCallback() = default;
+
+NS_IMETHODIMP
+PresentationReconnectCallback::NotifySuccess(const nsAString& aUrl) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  nsCOMPtr<nsIPresentationService> service =
+      do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+  if (NS_WARN_IF(!service)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  nsresult rv = NS_OK;
+  // We found a matched connection with the same window ID, URL, and
+  // the session ID. Resolve the promise with this connection and dispatch
+  // the event.
+  if (mConnection) {
+    mConnection->NotifyStateChange(
+        mSessionId, nsIPresentationSessionListener::STATE_CONNECTING, NS_OK);
+    mPromise->MaybeResolve(mConnection);
+    rv = mRequest->DispatchConnectionAvailableEvent(mConnection);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+  } else {
+    // Use |PresentationRequesterCallback::NotifySuccess| to create a new
+    // connection since we don't find one that can be reused.
+    rv = PresentationRequesterCallback::NotifySuccess(aUrl);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    rv = service->UpdateWindowIdBySessionId(
+        mSessionId, nsIPresentationService::ROLE_CONTROLLER,
+        mRequest->GetOwner()->WindowID());
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+  }
+
+  nsString sessionId = nsString(mSessionId);
+  return NS_DispatchToMainThread(NS_NewRunnableFunction(
+      "dom::PresentationReconnectCallback::NotifySuccess",
+      [sessionId, service]() -> void {
+        service->BuildTransport(sessionId,
+                                nsIPresentationService::ROLE_CONTROLLER);
+      }));
+}
+
+NS_IMETHODIMP
+PresentationReconnectCallback::NotifyError(nsresult aError) {
+  if (mConnection) {
+    mConnection->NotifyStateChange(
+        mSessionId, nsIPresentationSessionListener::STATE_CLOSED, aError);
+  }
+  return PresentationRequesterCallback::NotifyError(aError);
+}
+
+NS_IMPL_ISUPPORTS(PresentationResponderLoadingCallback, nsIWebProgressListener,
+                  nsISupportsWeakReference)
+
+PresentationResponderLoadingCallback::PresentationResponderLoadingCallback(
+    const nsAString& aSessionId)
+    : mSessionId(aSessionId) {}
+
+PresentationResponderLoadingCallback::~PresentationResponderLoadingCallback() {
+  if (mProgress) {
+    mProgress->RemoveProgressListener(this);
+    mProgress = nullptr;
+  }
+}
+
+nsresult PresentationResponderLoadingCallback::Init(nsIDocShell* aDocShell) {
+  mProgress = do_GetInterface(aDocShell);
+  if (NS_WARN_IF(!mProgress)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  auto busyFlags = aDocShell->GetBusyFlags();
+
+  if ((busyFlags == nsIDocShell::BUSY_FLAGS_NONE) ||
+      (busyFlags & nsIDocShell::BUSY_FLAGS_PAGE_LOADING)) {
+    // The docshell has finished loading or is receiving data
+    // (|STATE_TRANSFERRING| has already been fired), so the page is ready for
+    // presentation use.
+    return NotifyReceiverReady(/* isLoading = */ true);
+  }
+
+  // Start to listen to document state change event |STATE_TRANSFERRING|.
+  return mProgress->AddProgressListener(this,
+                                        nsIWebProgress::NOTIFY_STATE_DOCUMENT);
+}
+
+nsresult PresentationResponderLoadingCallback::NotifyReceiverReady(
+    bool aIsLoading) {
+  nsCOMPtr<nsPIDOMWindowOuter> window = do_GetInterface(mProgress);
+  if (NS_WARN_IF(!window || !window->GetCurrentInnerWindow())) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+  uint64_t windowId = window->GetCurrentInnerWindow()->WindowID();
+
+  nsCOMPtr<nsIPresentationService> service =
+      do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+  if (NS_WARN_IF(!service)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  nsCOMPtr<nsIPresentationTransportBuilderConstructor> constructor =
+      PresentationTransportBuilderConstructor::Create();
+  return service->NotifyReceiverReady(mSessionId, windowId, aIsLoading,
+                                      constructor);
+}
+
+// nsIWebProgressListener
+NS_IMETHODIMP
+PresentationResponderLoadingCallback::OnStateChange(
+    nsIWebProgress* aWebProgress, nsIRequest* aRequest, uint32_t aStateFlags,
+    nsresult aStatus) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (aStateFlags & (nsIWebProgressListener::STATE_TRANSFERRING |
+                     nsIWebProgressListener::STATE_STOP)) {
+    mProgress->RemoveProgressListener(this);
+
+    bool isLoading = aStateFlags & nsIWebProgressListener::STATE_TRANSFERRING;
+    return NotifyReceiverReady(isLoading);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationResponderLoadingCallback::OnProgressChange(
+    nsIWebProgress* aWebProgress, nsIRequest* aRequest,
+    int32_t aCurSelfProgress, int32_t aMaxSelfProgress,
+    int32_t aCurTotalProgress, int32_t aMaxTotalProgress) {
+  // Do nothing.
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationResponderLoadingCallback::OnLocationChange(
+    nsIWebProgress* aWebProgress, nsIRequest* aRequest, nsIURI* aURI,
+    uint32_t aFlags) {
+  // Do nothing.
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationResponderLoadingCallback::OnStatusChange(
+    nsIWebProgress* aWebProgress, nsIRequest* aRequest, nsresult aStatus,
+    const char16_t* aMessage) {
+  // Do nothing.
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationResponderLoadingCallback::OnSecurityChange(
+    nsIWebProgress* aWebProgress, nsIRequest* aRequest, uint32_t aState) {
+  // Do nothing.
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationResponderLoadingCallback::OnContentBlockingEvent(
+    nsIWebProgress* aWebProgress, nsIRequest* aRequest, uint32_t aEvent) {
+  // Do nothing.
+  return NS_OK;
+}
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/presentation/PresentationCallbacks.h b/dom/presentation/PresentationCallbacks.h
new file mode 100644
index 0000000000..9b0d2b02fe
--- /dev/null
+++ b/dom/presentation/PresentationCallbacks.h
@@ -0,0 +1,83 @@
+/* -*- 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_PresentationCallbacks_h
+#define mozilla_dom_PresentationCallbacks_h
+
+#include "mozilla/RefPtr.h"
+#include "nsCOMPtr.h"
+#include "nsIPresentationService.h"
+#include "nsIWebProgressListener.h"
+#include "nsString.h"
+#include "nsWeakReference.h"
+
+class nsIDocShell;
+class nsIWebProgress;
+
+namespace mozilla {
+namespace dom {
+
+class PresentationConnection;
+class PresentationRequest;
+class Promise;
+
+class PresentationRequesterCallback : public nsIPresentationServiceCallback {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPRESENTATIONSERVICECALLBACK
+
+  PresentationRequesterCallback(PresentationRequest* aRequest,
+                                const nsAString& aSessionId, Promise* aPromise);
+
+ protected:
+  virtual ~PresentationRequesterCallback();
+
+  RefPtr<PresentationRequest> mRequest;
+  nsString mSessionId;
+  RefPtr<Promise> mPromise;
+};
+
+class PresentationReconnectCallback final
+    : public PresentationRequesterCallback {
+ public:
+  NS_INLINE_DECL_REFCOUNTING_INHERITED(PresentationReconnectCallback,
+                                       PresentationRequesterCallback)
+  NS_DECL_NSIPRESENTATIONSERVICECALLBACK
+
+  PresentationReconnectCallback(PresentationRequest* aRequest,
+                                const nsAString& aSessionId, Promise* aPromise,
+                                PresentationConnection* aConnection);
+
+ private:
+  virtual ~PresentationReconnectCallback();
+
+  RefPtr<PresentationConnection> mConnection;
+};
+
+class PresentationResponderLoadingCallback final
+    : public nsIWebProgressListener,
+      public nsSupportsWeakReference {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIWEBPROGRESSLISTENER
+
+  explicit PresentationResponderLoadingCallback(const nsAString& aSessionId);
+
+  nsresult Init(nsIDocShell* aDocShell);
+
+ private:
+  ~PresentationResponderLoadingCallback();
+
+  nsresult NotifyReceiverReady(bool aIsLoading);
+
+  nsString mSessionId;
+  nsCOMPtr<nsIWebProgress> mProgress;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_PresentationCallbacks_h
diff --git a/dom/presentation/PresentationConnection.cpp b/dom/presentation/PresentationConnection.cpp
new file mode 100644
index 0000000000..8d944f1e78
--- /dev/null
+++ b/dom/presentation/PresentationConnection.cpp
@@ -0,0 +1,757 @@
+/* -*- 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 "PresentationConnection.h"
+
+#include "ControllerConnectionCollection.h"
+#include "mozilla/AsyncEventDispatcher.h"
+#include "mozilla/dom/DOMException.h"
+#include "mozilla/dom/File.h"
+#include "mozilla/dom/MessageEvent.h"
+#include "mozilla/dom/MessageEventBinding.h"
+#include "mozilla/dom/PresentationConnectionCloseEvent.h"
+#include "mozilla/dom/ScriptSettings.h"
+#include "mozilla/dom/ToJSValue.h"
+#include "mozilla/ErrorNames.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/IntegerPrintfMacros.h"
+#include "nsContentUtils.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsIPresentationService.h"
+#include "nsServiceManagerUtils.h"
+#include "nsStringStream.h"
+#include "PresentationConnectionList.h"
+#include "PresentationLog.h"
+
+namespace mozilla {
+namespace dom {
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(PresentationConnection)
+
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(PresentationConnection,
+                                                  DOMEventTargetHelper)
+  NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mOwningConnectionList)
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(PresentationConnection,
+                                                DOMEventTargetHelper)
+  tmp->Shutdown();
+  NS_IMPL_CYCLE_COLLECTION_UNLINK(mOwningConnectionList)
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+
+NS_IMPL_ADDREF_INHERITED(PresentationConnection, DOMEventTargetHelper)
+NS_IMPL_RELEASE_INHERITED(PresentationConnection, DOMEventTargetHelper)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PresentationConnection)
+  NS_INTERFACE_MAP_ENTRY(nsIPresentationSessionListener)
+  NS_INTERFACE_MAP_ENTRY(nsIRequest)
+NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
+
+PresentationConnection::PresentationConnection(
+    nsPIDOMWindowInner* aWindow, const nsAString& aId, const nsAString& aUrl,
+    const uint8_t aRole, PresentationConnectionList* aList)
+    : DOMEventTargetHelper(aWindow),
+      mId(aId),
+      mUrl(aUrl),
+      mState(PresentationConnectionState::Connecting),
+      mOwningConnectionList(aList),
+      mBinaryType(PresentationConnectionBinaryType::Arraybuffer) {
+  MOZ_ASSERT(aRole == nsIPresentationService::ROLE_CONTROLLER ||
+             aRole == nsIPresentationService::ROLE_RECEIVER);
+  mRole = aRole;
+}
+
+/* virtual */ PresentationConnection::~PresentationConnection() = default;
+
+/* static */
+already_AddRefed<PresentationConnection> PresentationConnection::Create(
+    nsPIDOMWindowInner* aWindow, const nsAString& aId, const nsAString& aUrl,
+    const uint8_t aRole, PresentationConnectionList* aList) {
+  MOZ_ASSERT(aRole == nsIPresentationService::ROLE_CONTROLLER ||
+             aRole == nsIPresentationService::ROLE_RECEIVER);
+  RefPtr<PresentationConnection> connection =
+      new PresentationConnection(aWindow, aId, aUrl, aRole, aList);
+  if (NS_WARN_IF(!connection->Init())) {
+    return nullptr;
+  }
+
+  if (aRole == nsIPresentationService::ROLE_CONTROLLER) {
+    ControllerConnectionCollection::GetSingleton()->AddConnection(connection,
+                                                                  aRole);
+  }
+
+  return connection.forget();
+}
+
+bool PresentationConnection::Init() {
+  if (NS_WARN_IF(mId.IsEmpty())) {
+    return false;
+  }
+
+  nsCOMPtr<nsIPresentationService> service =
+      do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+  if (NS_WARN_IF(!service)) {
+    return false;
+  }
+
+  nsresult rv = service->RegisterSessionListener(mId, mRole, this);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return false;
+  }
+
+  rv = AddIntoLoadGroup();
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return false;
+  }
+
+  return true;
+}
+
+void PresentationConnection::Shutdown() {
+  PRES_DEBUG("connection shutdown:id[%s], role[%d]\n",
+             NS_ConvertUTF16toUTF8(mId).get(), mRole);
+
+  nsCOMPtr<nsIPresentationService> service =
+      do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+  if (NS_WARN_IF(!service)) {
+    return;
+  }
+
+  DebugOnly<nsresult> rv = service->UnregisterSessionListener(mId, mRole);
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "UnregisterSessionListener failed");
+
+  DebugOnly<nsresult> rv2 = RemoveFromLoadGroup();
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(rv2), "RemoveFromLoadGroup failed");
+
+  if (mRole == nsIPresentationService::ROLE_CONTROLLER) {
+    ControllerConnectionCollection::GetSingleton()->RemoveConnection(this,
+                                                                     mRole);
+  }
+}
+
+/* virtual */
+void PresentationConnection::DisconnectFromOwner() {
+  Unused << NS_WARN_IF(NS_FAILED(ProcessConnectionWentAway()));
+  DOMEventTargetHelper::DisconnectFromOwner();
+}
+
+/* virtual */
+JSObject* PresentationConnection::WrapObject(
+    JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
+  return PresentationConnection_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+void PresentationConnection::GetId(nsAString& aId) const {
+  if (nsContentUtils::ShouldResistFingerprinting()) {
+    aId.Truncate();
+    return;
+  }
+
+  aId = mId;
+}
+
+void PresentationConnection::GetUrl(nsAString& aUrl) const {
+  if (nsContentUtils::ShouldResistFingerprinting()) {
+    aUrl.Truncate();
+    return;
+  }
+
+  aUrl = mUrl;
+}
+
+PresentationConnectionState PresentationConnection::State() const {
+  if (nsContentUtils::ShouldResistFingerprinting()) {
+    return PresentationConnectionState::Terminated;
+  }
+
+  return mState;
+}
+
+PresentationConnectionBinaryType PresentationConnection::BinaryType() const {
+  if (nsContentUtils::ShouldResistFingerprinting()) {
+    return PresentationConnectionBinaryType::Blob;
+  }
+
+  return mBinaryType;
+}
+
+void PresentationConnection::SetBinaryType(
+    PresentationConnectionBinaryType aType) {
+  if (nsContentUtils::ShouldResistFingerprinting()) {
+    return;
+  }
+
+  mBinaryType = aType;
+}
+
+void PresentationConnection::Send(const nsAString& aData, ErrorResult& aRv) {
+  if (nsContentUtils::ShouldResistFingerprinting()) {
+    return;
+  }
+
+  // Sending is not allowed if the session is not connected.
+  if (NS_WARN_IF(mState != PresentationConnectionState::Connected)) {
+    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+    return;
+  }
+
+  nsCOMPtr<nsIPresentationService> service =
+      do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+  if (NS_WARN_IF(!service)) {
+    AsyncCloseConnectionWithErrorMsg(
+        u"Unable to send message due to an internal error."_ns);
+    return;
+  }
+
+  nsresult rv = service->SendSessionMessage(mId, mRole, aData);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    const uint32_t kMaxMessageLength = 256;
+    nsAutoString data(Substring(aData, 0, kMaxMessageLength));
+
+    AsyncCloseConnectionWithErrorMsg(u"Unable to send message: \""_ns + data +
+                                     u"\""_ns);
+  }
+}
+
+void PresentationConnection::Send(Blob& aData, ErrorResult& aRv) {
+  if (nsContentUtils::ShouldResistFingerprinting()) {
+    return;
+  }
+
+  if (NS_WARN_IF(mState != PresentationConnectionState::Connected)) {
+    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+    return;
+  }
+
+  nsCOMPtr<nsIPresentationService> service =
+      do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+  if (NS_WARN_IF(!service)) {
+    AsyncCloseConnectionWithErrorMsg(
+        u"Unable to send message due to an internal error."_ns);
+    return;
+  }
+
+  nsresult rv = service->SendSessionBlob(mId, mRole, &aData);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    AsyncCloseConnectionWithErrorMsg(
+        u"Unable to send binary message for Blob message."_ns);
+  }
+}
+
+void PresentationConnection::Send(const ArrayBuffer& aData, ErrorResult& aRv) {
+  if (nsContentUtils::ShouldResistFingerprinting()) {
+    return;
+  }
+
+  if (NS_WARN_IF(mState != PresentationConnectionState::Connected)) {
+    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+    return;
+  }
+
+  nsCOMPtr<nsIPresentationService> service =
+      do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+  if (NS_WARN_IF(!service)) {
+    AsyncCloseConnectionWithErrorMsg(
+        u"Unable to send message due to an internal error."_ns);
+    return;
+  }
+
+  aData.ComputeState();
+
+  static_assert(sizeof(*aData.Data()) == 1, "byte-sized data required");
+
+  uint32_t length = aData.Length();
+  char* data = reinterpret_cast<char*>(aData.Data());
+  nsDependentCSubstring msgString(data, length);
+
+  nsresult rv = service->SendSessionBinaryMsg(mId, mRole, msgString);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    AsyncCloseConnectionWithErrorMsg(nsLiteralString(
+        u"Unable to send binary message for ArrayBuffer message."));
+  }
+}
+
+void PresentationConnection::Send(const ArrayBufferView& aData,
+                                  ErrorResult& aRv) {
+  if (nsContentUtils::ShouldResistFingerprinting()) {
+    return;
+  }
+
+  if (NS_WARN_IF(mState != PresentationConnectionState::Connected)) {
+    aRv.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
+    return;
+  }
+
+  nsCOMPtr<nsIPresentationService> service =
+      do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+  if (NS_WARN_IF(!service)) {
+    AsyncCloseConnectionWithErrorMsg(
+        u"Unable to send message due to an internal error."_ns);
+    return;
+  }
+
+  aData.ComputeState();
+
+  static_assert(sizeof(*aData.Data()) == 1, "byte-sized data required");
+
+  uint32_t length = aData.Length();
+  char* data = reinterpret_cast<char*>(aData.Data());
+  nsDependentCSubstring msgString(data, length);
+
+  nsresult rv = service->SendSessionBinaryMsg(mId, mRole, msgString);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    AsyncCloseConnectionWithErrorMsg(nsLiteralString(
+        u"Unable to send binary message for ArrayBufferView message."));
+  }
+}
+
+void PresentationConnection::Close(ErrorResult& aRv) {
+  if (nsContentUtils::ShouldResistFingerprinting()) {
+    return;
+  }
+
+  // It only works when the state is CONNECTED or CONNECTING.
+  if (NS_WARN_IF(mState != PresentationConnectionState::Connected &&
+                 mState != PresentationConnectionState::Connecting)) {
+    return;
+  }
+
+  nsCOMPtr<nsIPresentationService> service =
+      do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+  if (NS_WARN_IF(!service)) {
+    aRv.Throw(NS_ERROR_DOM_OPERATION_ERR);
+    return;
+  }
+
+  Unused << NS_WARN_IF(NS_FAILED(service->CloseSession(
+      mId, mRole, nsIPresentationService::CLOSED_REASON_CLOSED)));
+}
+
+void PresentationConnection::Terminate(ErrorResult& aRv) {
+  if (nsContentUtils::ShouldResistFingerprinting()) {
+    return;
+  }
+
+  // It only works when the state is CONNECTED.
+  if (NS_WARN_IF(mState != PresentationConnectionState::Connected)) {
+    return;
+  }
+
+  nsCOMPtr<nsIPresentationService> service =
+      do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+  if (NS_WARN_IF(!service)) {
+    aRv.Throw(NS_ERROR_DOM_OPERATION_ERR);
+    return;
+  }
+
+  Unused << NS_WARN_IF(NS_FAILED(service->TerminateSession(mId, mRole)));
+}
+
+bool PresentationConnection::Equals(uint64_t aWindowId, const nsAString& aId) {
+  return GetOwner() && aWindowId == GetOwner()->WindowID() && mId.Equals(aId);
+}
+
+NS_IMETHODIMP
+PresentationConnection::NotifyStateChange(const nsAString& aSessionId,
+                                          uint16_t aState, nsresult aReason) {
+  PRES_DEBUG("connection state change:id[%s], state[%" PRIx32
+             "], reason[%" PRIx32 "], role[%d]\n",
+             NS_ConvertUTF16toUTF8(aSessionId).get(), aState,
+             static_cast<uint32_t>(aReason), mRole);
+
+  if (!aSessionId.Equals(mId)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  // A terminated connection should always remain in terminated.
+  if (mState == PresentationConnectionState::Terminated) {
+    return NS_OK;
+  }
+
+  PresentationConnectionState state;
+  switch (aState) {
+    case nsIPresentationSessionListener::STATE_CONNECTING:
+      state = PresentationConnectionState::Connecting;
+      break;
+    case nsIPresentationSessionListener::STATE_CONNECTED:
+      state = PresentationConnectionState::Connected;
+      break;
+    case nsIPresentationSessionListener::STATE_CLOSED:
+      state = PresentationConnectionState::Closed;
+      break;
+    case nsIPresentationSessionListener::STATE_TERMINATED:
+      state = PresentationConnectionState::Terminated;
+      break;
+    default:
+      NS_WARNING("Unknown presentation session state.");
+      return NS_ERROR_INVALID_ARG;
+  }
+
+  if (mState == state) {
+    return NS_OK;
+  }
+  mState = state;
+
+  nsresult rv = ProcessStateChanged(aReason);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  if (mOwningConnectionList) {
+    mOwningConnectionList->NotifyStateChange(aSessionId, this);
+  }
+
+  return NS_OK;
+}
+
+nsresult PresentationConnection::ProcessStateChanged(nsresult aReason) {
+  switch (mState) {
+    case PresentationConnectionState::Connecting:
+      return NS_OK;
+    case PresentationConnectionState::Connected: {
+      if (nsContentUtils::ShouldResistFingerprinting()) {
+        return NS_OK;
+      }
+
+      RefPtr<AsyncEventDispatcher> asyncDispatcher =
+          new AsyncEventDispatcher(this, u"connect"_ns, CanBubble::eNo);
+      return asyncDispatcher->PostDOMEvent();
+    }
+    case PresentationConnectionState::Closed: {
+      PresentationConnectionClosedReason reason =
+          PresentationConnectionClosedReason::Closed;
+
+      nsString errorMsg;
+      if (NS_FAILED(aReason)) {
+        reason = PresentationConnectionClosedReason::Error;
+        nsCString name, message;
+
+        // If aReason is not a DOM error, use error name as message.
+        if (NS_FAILED(
+                NS_GetNameAndMessageForDOMNSResult(aReason, name, message))) {
+          GetErrorName(aReason, message);
+          message.InsertLiteral("Internal error: ", 0);
+        }
+        CopyUTF8toUTF16(message, errorMsg);
+      }
+
+      Unused << NS_WARN_IF(
+          NS_FAILED(DispatchConnectionCloseEvent(reason, errorMsg)));
+
+      return RemoveFromLoadGroup();
+    }
+    case PresentationConnectionState::Terminated: {
+      if (!nsContentUtils::ShouldResistFingerprinting()) {
+        // Ensure onterminate event is fired.
+        RefPtr<AsyncEventDispatcher> asyncDispatcher =
+            new AsyncEventDispatcher(this, u"terminate"_ns, CanBubble::eNo);
+        Unused << NS_WARN_IF(NS_FAILED(asyncDispatcher->PostDOMEvent()));
+      }
+
+      nsCOMPtr<nsIPresentationService> service =
+          do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+      if (NS_WARN_IF(!service)) {
+        return NS_ERROR_NOT_AVAILABLE;
+      }
+
+      nsresult rv = service->UnregisterSessionListener(mId, mRole);
+      if (NS_WARN_IF(NS_FAILED(rv))) {
+        return rv;
+      }
+
+      return RemoveFromLoadGroup();
+    }
+    default:
+      MOZ_CRASH("Unknown presentation session state.");
+      return NS_ERROR_INVALID_ARG;
+  }
+}
+
+NS_IMETHODIMP
+PresentationConnection::NotifyMessage(const nsAString& aSessionId,
+                                      const nsACString& aData, bool aIsBinary) {
+  PRES_DEBUG("connection %s:id[%s], data[%s], role[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(aSessionId).get(),
+             nsPromiseFlatCString(aData).get(), mRole);
+
+  if (!aSessionId.Equals(mId)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  // No message should be expected when the session is not connected.
+  if (NS_WARN_IF(mState != PresentationConnectionState::Connected)) {
+    return NS_ERROR_DOM_INVALID_STATE_ERR;
+  }
+
+  if (NS_WARN_IF(NS_FAILED(DoReceiveMessage(aData, aIsBinary)))) {
+    AsyncCloseConnectionWithErrorMsg(u"Unable to receive a message."_ns);
+    return NS_ERROR_FAILURE;
+  }
+
+  return NS_OK;
+}
+
+nsresult PresentationConnection::DoReceiveMessage(const nsACString& aData,
+                                                  bool aIsBinary) {
+  if (nsContentUtils::ShouldResistFingerprinting()) {
+    return NS_OK;
+  }
+
+  // Transform the data.
+  AutoJSAPI jsapi;
+  if (!jsapi.Init(GetOwner())) {
+    return NS_ERROR_FAILURE;
+  }
+  JSContext* cx = jsapi.cx();
+  JS::Rooted<JS::Value> jsData(cx);
+
+  nsresult rv;
+  if (aIsBinary) {
+    if (mBinaryType == PresentationConnectionBinaryType::Blob) {
+      RefPtr<Blob> blob =
+          Blob::CreateStringBlob(GetOwnerGlobal(), aData, u""_ns);
+      if (NS_WARN_IF(!blob)) {
+        return NS_ERROR_FAILURE;
+      }
+
+      if (!ToJSValue(cx, blob, &jsData)) {
+        return NS_ERROR_FAILURE;
+      }
+    } else if (mBinaryType == PresentationConnectionBinaryType::Arraybuffer) {
+      JS::Rooted<JSObject*> arrayBuf(cx);
+      rv = nsContentUtils::CreateArrayBuffer(cx, aData, arrayBuf.address());
+      if (NS_WARN_IF(NS_FAILED(rv))) {
+        return rv;
+      }
+      jsData.setObject(*arrayBuf);
+    } else {
+      MOZ_CRASH("Unknown binary type!");
+    }
+  } else {
+    NS_ConvertUTF8toUTF16 utf16Data(aData);
+    if (NS_WARN_IF(!ToJSValue(cx, utf16Data, &jsData))) {
+      return NS_ERROR_FAILURE;
+    }
+  }
+
+  return DispatchMessageEvent(jsData);
+}
+
+nsresult PresentationConnection::DispatchConnectionCloseEvent(
+    PresentationConnectionClosedReason aReason, const nsAString& aMessage,
+    bool aDispatchNow) {
+  if (nsContentUtils::ShouldResistFingerprinting()) {
+    return NS_OK;
+  }
+
+  if (mState != PresentationConnectionState::Closed) {
+    MOZ_ASSERT(false, "The connection state should be closed.");
+    return NS_ERROR_FAILURE;
+  }
+
+  PresentationConnectionCloseEventInit init;
+  init.mReason = aReason;
+  init.mMessage = aMessage;
+
+  RefPtr<PresentationConnectionCloseEvent> closedEvent =
+      PresentationConnectionCloseEvent::Constructor(this, u"close"_ns, init);
+  closedEvent->SetTrusted(true);
+
+  if (aDispatchNow) {
+    ErrorResult rv;
+    DispatchEvent(*closedEvent, rv);
+    return rv.StealNSResult();
+  }
+
+  RefPtr<AsyncEventDispatcher> asyncDispatcher =
+      new AsyncEventDispatcher(this, closedEvent);
+  return asyncDispatcher->PostDOMEvent();
+}
+
+nsresult PresentationConnection::DispatchMessageEvent(
+    JS::Handle<JS::Value> aData) {
+  nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetOwner());
+  if (NS_WARN_IF(!global)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  // Get the origin.
+  nsAutoString origin;
+  nsresult rv = nsContentUtils::GetUTFOrigin(global->PrincipalOrNull(), origin);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  RefPtr<MessageEvent> messageEvent = new MessageEvent(this, nullptr, nullptr);
+
+  messageEvent->InitMessageEvent(
+      nullptr, u"message"_ns, CanBubble::eNo, Cancelable::eNo, aData, origin,
+      u""_ns, nullptr, Sequence<OwningNonNull<MessagePort>>());
+  messageEvent->SetTrusted(true);
+
+  RefPtr<AsyncEventDispatcher> asyncDispatcher =
+      new AsyncEventDispatcher(this, messageEvent);
+  return asyncDispatcher->PostDOMEvent();
+}
+
+nsresult PresentationConnection::ProcessConnectionWentAway() {
+  if (mState != PresentationConnectionState::Connected &&
+      mState != PresentationConnectionState::Connecting) {
+    // If the state is not connected or connecting, do not need to
+    // close the session.
+    return NS_OK;
+  }
+
+  mState = PresentationConnectionState::Terminated;
+
+  nsCOMPtr<nsIPresentationService> service =
+      do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+  if (NS_WARN_IF(!service)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  return service->CloseSession(mId, mRole,
+                               nsIPresentationService::CLOSED_REASON_WENTAWAY);
+}
+
+NS_IMETHODIMP
+PresentationConnection::GetName(nsACString& aResult) {
+  aResult.AssignLiteral("about:presentation-connection");
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationConnection::IsPending(bool* aRetval) {
+  *aRetval = true;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationConnection::GetStatus(nsresult* aStatus) {
+  *aStatus = NS_OK;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationConnection::Cancel(nsresult aStatus) {
+  nsCOMPtr<nsIRunnable> event = NewRunnableMethod(
+      "dom::PresentationConnection::ProcessConnectionWentAway", this,
+      &PresentationConnection::ProcessConnectionWentAway);
+  return NS_DispatchToCurrentThread(event);
+}
+NS_IMETHODIMP
+PresentationConnection::Suspend(void) { return NS_ERROR_NOT_IMPLEMENTED; }
+NS_IMETHODIMP
+PresentationConnection::Resume(void) { return NS_ERROR_NOT_IMPLEMENTED; }
+
+NS_IMETHODIMP
+PresentationConnection::GetLoadGroup(nsILoadGroup** aLoadGroup) {
+  *aLoadGroup = nullptr;
+
+  nsCOMPtr<Document> doc = GetOwner() ? GetOwner()->GetExtantDoc() : nullptr;
+  if (!doc) {
+    return NS_ERROR_FAILURE;
+  }
+
+  *aLoadGroup = doc->GetDocumentLoadGroup().take();
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationConnection::SetLoadGroup(nsILoadGroup* aLoadGroup) {
+  return NS_ERROR_UNEXPECTED;
+}
+
+NS_IMETHODIMP
+PresentationConnection::GetLoadFlags(nsLoadFlags* aLoadFlags) {
+  *aLoadFlags = nsIRequest::LOAD_BACKGROUND;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationConnection::SetLoadFlags(nsLoadFlags aLoadFlags) { return NS_OK; }
+
+NS_IMETHODIMP
+PresentationConnection::GetTRRMode(nsIRequest::TRRMode* aTRRMode) {
+  return GetTRRModeImpl(aTRRMode);
+}
+
+NS_IMETHODIMP
+PresentationConnection::SetTRRMode(nsIRequest::TRRMode aTRRMode) {
+  return SetTRRModeImpl(aTRRMode);
+}
+
+nsresult PresentationConnection::AddIntoLoadGroup() {
+  // Avoid adding to loadgroup multiple times
+  if (mWeakLoadGroup) {
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsILoadGroup> loadGroup;
+  nsresult rv = GetLoadGroup(getter_AddRefs(loadGroup));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = loadGroup->AddRequest(this, nullptr);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  mWeakLoadGroup = do_GetWeakReference(loadGroup);
+  return NS_OK;
+}
+
+nsresult PresentationConnection::RemoveFromLoadGroup() {
+  if (!mWeakLoadGroup) {
+    return NS_OK;
+  }
+
+  nsCOMPtr<nsILoadGroup> loadGroup = do_QueryReferent(mWeakLoadGroup);
+  if (loadGroup) {
+    mWeakLoadGroup = nullptr;
+    return loadGroup->RemoveRequest(this, nullptr, NS_OK);
+  }
+
+  return NS_OK;
+}
+
+void PresentationConnection::AsyncCloseConnectionWithErrorMsg(
+    const nsAString& aMessage) {
+  if (mState == PresentationConnectionState::Terminated) {
+    return;
+  }
+
+  nsString message = nsString(aMessage);
+  RefPtr<PresentationConnection> self = this;
+  nsCOMPtr<nsIRunnable> r = NS_NewRunnableFunction(
+      "dom::PresentationConnection::AsyncCloseConnectionWithErrorMsg",
+      [self, message]() -> void {
+        // Set |mState| to |PresentationConnectionState::Closed| here to avoid
+        // calling |ProcessStateChanged|.
+        self->mState = PresentationConnectionState::Closed;
+
+        // Make sure dispatching the event and closing the connection are
+        // invoked at the same time by setting |aDispatchNow| to true.
+        Unused << NS_WARN_IF(NS_FAILED(self->DispatchConnectionCloseEvent(
+            PresentationConnectionClosedReason::Error, message, true)));
+
+        nsCOMPtr<nsIPresentationService> service =
+            do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+        if (NS_WARN_IF(!service)) {
+          return;
+        }
+
+        Unused << NS_WARN_IF(NS_FAILED(service->CloseSession(
+            self->mId, self->mRole,
+            nsIPresentationService::CLOSED_REASON_ERROR)));
+      });
+
+  Unused << NS_WARN_IF(NS_FAILED(NS_DispatchToMainThread(r)));
+}
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/presentation/PresentationConnection.h b/dom/presentation/PresentationConnection.h
new file mode 100644
index 0000000000..dc994bf295
--- /dev/null
+++ b/dom/presentation/PresentationConnection.h
@@ -0,0 +1,116 @@
+/* -*- 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_PresentationConnection_h
+#define mozilla_dom_PresentationConnection_h
+
+#include "mozilla/DOMEventTargetHelper.h"
+#include "mozilla/dom/TypedArray.h"
+#include "mozilla/WeakPtr.h"
+#include "mozilla/dom/PresentationConnectionBinding.h"
+#include "mozilla/dom/PresentationConnectionCloseEventBinding.h"
+#include "nsIPresentationListener.h"
+#include "nsIRequest.h"
+#include "nsIWeakReferenceUtils.h"
+
+namespace mozilla {
+namespace dom {
+
+class Blob;
+class PresentationConnectionList;
+
+class PresentationConnection final : public DOMEventTargetHelper,
+                                     public nsIPresentationSessionListener,
+                                     public nsIRequest,
+                                     public SupportsWeakPtr {
+ public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(PresentationConnection,
+                                           DOMEventTargetHelper)
+  NS_DECL_NSIPRESENTATIONSESSIONLISTENER
+  NS_DECL_NSIREQUEST
+
+  static already_AddRefed<PresentationConnection> Create(
+      nsPIDOMWindowInner* aWindow, const nsAString& aId, const nsAString& aUrl,
+      const uint8_t aRole, PresentationConnectionList* aList = nullptr);
+
+  virtual void DisconnectFromOwner() override;
+
+  virtual JSObject* WrapObject(JSContext* aCx,
+                               JS::Handle<JSObject*> aGivenProto) override;
+
+  // WebIDL (public APIs)
+  void GetId(nsAString& aId) const;
+
+  void GetUrl(nsAString& aUrl) const;
+
+  PresentationConnectionState State() const;
+
+  PresentationConnectionBinaryType BinaryType() const;
+
+  void SetBinaryType(PresentationConnectionBinaryType aType);
+
+  void Send(const nsAString& aData, ErrorResult& aRv);
+
+  void Send(Blob& aData, ErrorResult& aRv);
+
+  void Send(const ArrayBuffer& aData, ErrorResult& aRv);
+
+  void Send(const ArrayBufferView& aData, ErrorResult& aRv);
+
+  void Close(ErrorResult& aRv);
+
+  void Terminate(ErrorResult& aRv);
+
+  bool Equals(uint64_t aWindowId, const nsAString& aId);
+
+  IMPL_EVENT_HANDLER(connect);
+  IMPL_EVENT_HANDLER(close);
+  IMPL_EVENT_HANDLER(terminate);
+  IMPL_EVENT_HANDLER(message);
+
+ private:
+  PresentationConnection(nsPIDOMWindowInner* aWindow, const nsAString& aId,
+                         const nsAString& aUrl, const uint8_t aRole,
+                         PresentationConnectionList* aList);
+
+  ~PresentationConnection();
+
+  bool Init();
+
+  void Shutdown();
+
+  nsresult ProcessStateChanged(nsresult aReason);
+
+  nsresult DispatchConnectionCloseEvent(
+      PresentationConnectionClosedReason aReason, const nsAString& aMessage,
+      bool aDispatchNow = false);
+
+  nsresult DispatchMessageEvent(JS::Handle<JS::Value> aData);
+
+  nsresult ProcessConnectionWentAway();
+
+  nsresult AddIntoLoadGroup();
+
+  nsresult RemoveFromLoadGroup();
+
+  void AsyncCloseConnectionWithErrorMsg(const nsAString& aMessage);
+
+  nsresult DoReceiveMessage(const nsACString& aData, bool aIsBinary);
+
+  nsString mId;
+  nsString mUrl;
+  uint8_t mRole;
+  PresentationConnectionState mState;
+  RefPtr<PresentationConnectionList> mOwningConnectionList;
+  nsWeakPtr mWeakLoadGroup;
+  PresentationConnectionBinaryType mBinaryType;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_PresentationConnection_h
diff --git a/dom/presentation/PresentationConnectionList.cpp b/dom/presentation/PresentationConnectionList.cpp
new file mode 100644
index 0000000000..7b2cc0b5a1
--- /dev/null
+++ b/dom/presentation/PresentationConnectionList.cpp
@@ -0,0 +1,124 @@
+/* -*- 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 "PresentationConnectionList.h"
+
+#include "nsContentUtils.h"
+#include "mozilla/AsyncEventDispatcher.h"
+#include "mozilla/dom/PresentationConnectionAvailableEvent.h"
+#include "mozilla/dom/PresentationConnectionListBinding.h"
+#include "mozilla/dom/Promise.h"
+#include "PresentationConnection.h"
+
+namespace mozilla {
+namespace dom {
+
+NS_IMPL_CYCLE_COLLECTION_INHERITED(PresentationConnectionList,
+                                   DOMEventTargetHelper,
+                                   mGetConnectionListPromise, mConnections)
+
+NS_IMPL_ADDREF_INHERITED(PresentationConnectionList, DOMEventTargetHelper)
+NS_IMPL_RELEASE_INHERITED(PresentationConnectionList, DOMEventTargetHelper)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PresentationConnectionList)
+NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
+
+PresentationConnectionList::PresentationConnectionList(
+    nsPIDOMWindowInner* aWindow, Promise* aPromise)
+    : DOMEventTargetHelper(aWindow), mGetConnectionListPromise(aPromise) {
+  MOZ_ASSERT(aWindow);
+  MOZ_ASSERT(aPromise);
+}
+
+/* virtual */
+JSObject* PresentationConnectionList::WrapObject(
+    JSContext* aCx, JS::Handle<JSObject*> aGivenProto) {
+  return PresentationConnectionList_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+void PresentationConnectionList::GetConnections(
+    nsTArray<RefPtr<PresentationConnection>>& aConnections) const {
+  if (nsContentUtils::ShouldResistFingerprinting()) {
+    aConnections.Clear();
+    return;
+  }
+
+  aConnections = mConnections.Clone();
+}
+
+nsresult PresentationConnectionList::DispatchConnectionAvailableEvent(
+    PresentationConnection* aConnection) {
+  if (nsContentUtils::ShouldResistFingerprinting()) {
+    return NS_OK;
+  }
+
+  PresentationConnectionAvailableEventInit init;
+  init.mConnection = aConnection;
+
+  RefPtr<PresentationConnectionAvailableEvent> event =
+      PresentationConnectionAvailableEvent::Constructor(
+          this, u"connectionavailable"_ns, init);
+
+  if (NS_WARN_IF(!event)) {
+    return NS_ERROR_FAILURE;
+  }
+  event->SetTrusted(true);
+
+  RefPtr<AsyncEventDispatcher> asyncDispatcher =
+      new AsyncEventDispatcher(this, event);
+  return asyncDispatcher->PostDOMEvent();
+}
+
+PresentationConnectionList::ConnectionArrayIndex
+PresentationConnectionList::FindConnectionById(const nsAString& aId) {
+  for (ConnectionArrayIndex i = 0; i < mConnections.Length(); i++) {
+    nsAutoString id;
+    mConnections[i]->GetId(id);
+    if (id == aId) {
+      return i;
+    }
+  }
+
+  return ConnectionArray::NoIndex;
+}
+
+void PresentationConnectionList::NotifyStateChange(
+    const nsAString& aSessionId, PresentationConnection* aConnection) {
+  if (!aConnection) {
+    MOZ_ASSERT(false, "PresentationConnection can not be null.");
+    return;
+  }
+
+  bool connectionFound =
+      FindConnectionById(aSessionId) != ConnectionArray::NoIndex;
+
+  PresentationConnectionList_Binding::ClearCachedConnectionsValue(this);
+  switch (aConnection->State()) {
+    case PresentationConnectionState::Connected:
+      if (!connectionFound) {
+        mConnections.AppendElement(aConnection);
+        if (mGetConnectionListPromise) {
+          if (!nsContentUtils::ShouldResistFingerprinting()) {
+            mGetConnectionListPromise->MaybeResolve(this);
+          }
+          mGetConnectionListPromise = nullptr;
+          return;
+        }
+      }
+      DispatchConnectionAvailableEvent(aConnection);
+      break;
+    case PresentationConnectionState::Terminated:
+      if (connectionFound) {
+        mConnections.RemoveElement(aConnection);
+      }
+      break;
+    default:
+      break;
+  }
+}
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/presentation/PresentationConnectionList.h b/dom/presentation/PresentationConnectionList.h
new file mode 100644
index 0000000000..60412daf25
--- /dev/null
+++ b/dom/presentation/PresentationConnectionList.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_PresentationConnectionList_h
+#define mozilla_dom_PresentationConnectionList_h
+
+#include "mozilla/DOMEventTargetHelper.h"
+#include "nsTArray.h"
+
+namespace mozilla {
+namespace dom {
+
+class PresentationConnection;
+class Promise;
+
+class PresentationConnectionList final : public DOMEventTargetHelper {
+ public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_CYCLE_COLLECTION_CLASS_INHERITED(PresentationConnectionList,
+                                           DOMEventTargetHelper)
+
+  PresentationConnectionList(nsPIDOMWindowInner* aWindow, Promise* aPromise);
+
+  virtual JSObject* WrapObject(JSContext* aCx,
+                               JS::Handle<JSObject*> aGivenProto) override;
+
+  void GetConnections(
+      nsTArray<RefPtr<PresentationConnection>>& aConnections) const;
+
+  void NotifyStateChange(const nsAString& aSessionId,
+                         PresentationConnection* aConnection);
+
+  IMPL_EVENT_HANDLER(connectionavailable);
+
+ private:
+  virtual ~PresentationConnectionList() = default;
+
+  nsresult DispatchConnectionAvailableEvent(
+      PresentationConnection* aConnection);
+
+  typedef nsTArray<RefPtr<PresentationConnection>> ConnectionArray;
+  typedef ConnectionArray::index_type ConnectionArrayIndex;
+
+  ConnectionArrayIndex FindConnectionById(const nsAString& aId);
+
+  RefPtr<Promise> mGetConnectionListPromise;
+
+  // This array stores only non-terminsted connections.
+  ConnectionArray mConnections;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_PresentationConnectionList_h
diff --git a/dom/presentation/PresentationDataChannelSessionTransport.jsm b/dom/presentation/PresentationDataChannelSessionTransport.jsm
new file mode 100644
index 0000000000..f3e788a1a7
--- /dev/null
+++ b/dom/presentation/PresentationDataChannelSessionTransport.jsm
@@ -0,0 +1,421 @@
+/* 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/. */
+
+"use strict";
+
+const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+
+// Bug 1228209 - plan to remove this eventually
+function log(aMsg) {
+  // dump("-*- PresentationDataChannelSessionTransport.js : " + aMsg + "\n");
+}
+
+const PRESENTATIONTRANSPORT_CID = Components.ID(
+  "{dd2bbf2f-3399-4389-8f5f-d382afb8b2d6}"
+);
+const PRESENTATIONTRANSPORT_CONTRACTID =
+  "mozilla.org/presentation/datachanneltransport;1";
+
+const PRESENTATIONTRANSPORTBUILDER_CID = Components.ID(
+  "{215b2f62-46e2-4004-a3d1-6858e56c20f3}"
+);
+const PRESENTATIONTRANSPORTBUILDER_CONTRACTID =
+  "mozilla.org/presentation/datachanneltransportbuilder;1";
+
+function PresentationDataChannelDescription(aDataChannelSDP) {
+  this._dataChannelSDP = JSON.stringify(aDataChannelSDP);
+}
+
+PresentationDataChannelDescription.prototype = {
+  QueryInterface: ChromeUtils.generateQI(["nsIPresentationChannelDescription"]),
+  get type() {
+    return Ci.nsIPresentationChannelDescription.TYPE_DATACHANNEL;
+  },
+  get tcpAddress() {
+    return null;
+  },
+  get tcpPort() {
+    return null;
+  },
+  get dataChannelSDP() {
+    return this._dataChannelSDP;
+  },
+};
+
+function PresentationTransportBuilder() {
+  log("PresentationTransportBuilder construct");
+  this._isControlChannelNeeded = true;
+}
+
+PresentationTransportBuilder.prototype = {
+  classID: PRESENTATIONTRANSPORTBUILDER_CID,
+  contractID: PRESENTATIONTRANSPORTBUILDER_CONTRACTID,
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIPresentationSessionTransportBuilder",
+    "nsIPresentationDataChannelSessionTransportBuilder",
+    "nsITimerCallback",
+  ]),
+
+  buildDataChannelTransport(aRole, aWindow, aListener) {
+    if (!aRole || !aWindow || !aListener) {
+      log("buildDataChannelTransport with illegal parameters");
+      throw Components.Exception("", Cr.NS_ERROR_ILLEGAL_VALUE);
+    }
+
+    if (this._window) {
+      log("buildDataChannelTransport has started.");
+      throw Components.Exception("", Cr.NS_ERROR_UNEXPECTED);
+    }
+
+    log("buildDataChannelTransport with role " + aRole);
+    this._role = aRole;
+    this._window = aWindow;
+    this._listener = aListener.QueryInterface(
+      Ci.nsIPresentationSessionTransportBuilderListener
+    );
+
+    // TODO bug 1227053 set iceServers from |nsIPresentationDevice|
+    this._peerConnection = new this._window.RTCPeerConnection();
+
+    // |this._listener == null| will throw since the control channel is
+    // abnormally closed.
+    this._peerConnection.onicecandidate = aEvent =>
+      aEvent.candidate &&
+      this._listener.sendIceCandidate(JSON.stringify(aEvent.candidate));
+
+    this._peerConnection.onnegotiationneeded = () => {
+      log("onnegotiationneeded with role " + this._role);
+      if (!this._peerConnection) {
+        log("ignoring negotiationneeded without PeerConnection");
+        return;
+      }
+      this._peerConnection
+        .createOffer()
+        .then(aOffer => this._peerConnection.setLocalDescription(aOffer))
+        .then(() =>
+          this._listener.sendOffer(
+            new PresentationDataChannelDescription(
+              this._peerConnection.localDescription
+            )
+          )
+        )
+        .catch(e => this._reportError(e));
+    };
+
+    switch (this._role) {
+      case Ci.nsIPresentationService.ROLE_CONTROLLER:
+        this._dataChannel = this._peerConnection.createDataChannel(
+          "presentationAPI"
+        );
+        this._setDataChannel();
+        break;
+
+      case Ci.nsIPresentationService.ROLE_RECEIVER:
+        this._peerConnection.ondatachannel = aEvent => {
+          this._dataChannel = aEvent.channel;
+          // Ensure the binaryType of dataChannel is blob.
+          this._dataChannel.binaryType = "blob";
+          this._setDataChannel();
+        };
+        break;
+      default:
+        throw Components.Exception("", Cr.NS_ERROR_ILLEGAL_VALUE);
+    }
+
+    // TODO bug 1228235 we should have a way to let device providers customize
+    // the time-out duration.
+    let timeout = Services.prefs.getIntPref(
+      "presentation.receiver.loading.timeout",
+      10000
+    );
+
+    // The timer is to check if the negotiation finishes on time.
+    this._timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+    this._timer.initWithCallback(this, timeout, this._timer.TYPE_ONE_SHOT);
+  },
+
+  notify() {
+    if (!this._sessionTransport) {
+      this._cleanup(Cr.NS_ERROR_NET_TIMEOUT);
+    }
+  },
+
+  _reportError(aError) {
+    log("report Error " + aError.name + ":" + aError.message);
+    this._cleanup(Cr.NS_ERROR_FAILURE);
+  },
+
+  _setDataChannel() {
+    this._dataChannel.onopen = () => {
+      log("data channel is open, notify the listener, role " + this._role);
+
+      // Handoff the ownership of _peerConnection and _dataChannel to
+      // _sessionTransport
+      this._sessionTransport = new PresentationTransport();
+      this._sessionTransport.init(
+        this._peerConnection,
+        this._dataChannel,
+        this._window
+      );
+      this._peerConnection.onicecandidate = null;
+      this._peerConnection.onnegotiationneeded = null;
+      this._peerConnection = this._dataChannel = null;
+
+      this._listener.onSessionTransport(this._sessionTransport);
+      this._sessionTransport.callback.notifyTransportReady();
+
+      this._cleanup(Cr.NS_OK);
+    };
+
+    this._dataChannel.onerror = aError => {
+      log("data channel onerror " + aError.name + ":" + aError.message);
+      this._cleanup(Cr.NS_ERROR_FAILURE);
+    };
+  },
+
+  _cleanup(aReason) {
+    if (aReason != Cr.NS_OK) {
+      this._listener.onError(aReason);
+    }
+
+    if (this._dataChannel) {
+      this._dataChannel.close();
+      this._dataChannel = null;
+    }
+
+    if (this._peerConnection) {
+      this._peerConnection.close();
+      this._peerConnection = null;
+    }
+
+    this._role = null;
+    this._window = null;
+
+    this._listener = null;
+    this._sessionTransport = null;
+
+    if (this._timer) {
+      this._timer.cancel();
+      this._timer = null;
+    }
+  },
+
+  // nsIPresentationControlChannelListener
+  onOffer(aOffer) {
+    if (
+      this._role !== Ci.nsIPresentationService.ROLE_RECEIVER ||
+      this._sessionTransport
+    ) {
+      log("onOffer status error");
+      this._cleanup(Cr.NS_ERROR_FAILURE);
+    }
+
+    log("onOffer: " + aOffer.dataChannelSDP + " with role " + this._role);
+
+    let offer = new this._window.RTCSessionDescription(
+      JSON.parse(aOffer.dataChannelSDP)
+    );
+
+    this._peerConnection
+      .setRemoteDescription(offer)
+      .then(
+        () =>
+          this._peerConnection.signalingState == "stable" ||
+          this._peerConnection.createAnswer()
+      )
+      .then(aAnswer => this._peerConnection.setLocalDescription(aAnswer))
+      .then(() => {
+        this._isControlChannelNeeded = false;
+        this._listener.sendAnswer(
+          new PresentationDataChannelDescription(
+            this._peerConnection.localDescription
+          )
+        );
+      })
+      .catch(e => this._reportError(e));
+  },
+
+  onAnswer(aAnswer) {
+    if (
+      this._role !== Ci.nsIPresentationService.ROLE_CONTROLLER ||
+      this._sessionTransport
+    ) {
+      log("onAnswer status error");
+      this._cleanup(Cr.NS_ERROR_FAILURE);
+    }
+
+    log("onAnswer: " + aAnswer.dataChannelSDP + " with role " + this._role);
+
+    let answer = new this._window.RTCSessionDescription(
+      JSON.parse(aAnswer.dataChannelSDP)
+    );
+
+    this._peerConnection
+      .setRemoteDescription(answer)
+      .catch(e => this._reportError(e));
+    this._isControlChannelNeeded = false;
+  },
+
+  onIceCandidate(aCandidate) {
+    log("onIceCandidate: " + aCandidate + " with role " + this._role);
+    if (!this._window || !this._peerConnection) {
+      log("ignoring ICE candidate after connection");
+      return;
+    }
+    let candidate = new this._window.RTCIceCandidate(JSON.parse(aCandidate));
+    this._peerConnection
+      .addIceCandidate(candidate)
+      .catch(e => this._reportError(e));
+  },
+
+  notifyDisconnected(aReason) {
+    log("notifyDisconnected reason: " + aReason);
+
+    if (aReason != Cr.NS_OK) {
+      this._cleanup(aReason);
+    } else if (this._isControlChannelNeeded) {
+      this._cleanup(Cr.NS_ERROR_FAILURE);
+    }
+  },
+};
+
+function PresentationTransport() {
+  this._messageQueue = [];
+  this._closeReason = Cr.NS_OK;
+}
+
+PresentationTransport.prototype = {
+  classID: PRESENTATIONTRANSPORT_CID,
+  contractID: PRESENTATIONTRANSPORT_CONTRACTID,
+  QueryInterface: ChromeUtils.generateQI(["nsIPresentationSessionTransport"]),
+
+  init(aPeerConnection, aDataChannel, aWindow) {
+    log("initWithDataChannel");
+    this._enableDataNotification = false;
+    this._dataChannel = aDataChannel;
+    this._peerConnection = aPeerConnection;
+    this._window = aWindow;
+
+    this._dataChannel.onopen = () => {
+      log("data channel reopen. Should never touch here");
+    };
+
+    this._dataChannel.onclose = () => {
+      log("data channel onclose");
+      if (this._callback) {
+        this._callback.notifyTransportClosed(this._closeReason);
+      }
+      this._cleanup();
+    };
+
+    this._dataChannel.onmessage = aEvent => {
+      log("data channel onmessage " + aEvent.data);
+
+      if (!this._enableDataNotification || !this._callback) {
+        log("queue message");
+        this._messageQueue.push(aEvent.data);
+        return;
+      }
+      this._doNotifyData(aEvent.data);
+    };
+
+    this._dataChannel.onerror = aError => {
+      log("data channel onerror " + aError.name + ":" + aError.message);
+      if (this._callback) {
+        this._callback.notifyTransportClosed(Cr.NS_ERROR_FAILURE);
+      }
+      this._cleanup();
+    };
+  },
+
+  // nsIPresentationTransport
+  get selfAddress() {
+    throw Components.Exception("", Cr.NS_ERROR_NOT_AVAILABLE);
+  },
+
+  get callback() {
+    return this._callback;
+  },
+
+  set callback(aCallback) {
+    this._callback = aCallback;
+  },
+
+  send(aData) {
+    log("send " + aData);
+    this._dataChannel.send(aData);
+  },
+
+  sendBinaryMsg(aData) {
+    log("sendBinaryMsg");
+
+    let array = new Uint8Array(aData.length);
+    for (let i = 0; i < aData.length; i++) {
+      array[i] = aData.charCodeAt(i);
+    }
+
+    this._dataChannel.send(array);
+  },
+
+  sendBlob(aBlob) {
+    log("sendBlob");
+
+    this._dataChannel.send(aBlob);
+  },
+
+  enableDataNotification() {
+    log("enableDataNotification");
+    if (this._enableDataNotification) {
+      return;
+    }
+
+    if (!this._callback) {
+      throw Components.Exception("", Cr.NS_ERROR_NOT_AVAILABLE);
+    }
+
+    this._enableDataNotification = true;
+
+    this._messageQueue.forEach(aData => this._doNotifyData(aData));
+    this._messageQueue = [];
+  },
+
+  close(aReason) {
+    this._closeReason = aReason;
+
+    this._dataChannel.close();
+  },
+
+  _cleanup() {
+    this._dataChannel = null;
+
+    if (this._peerConnection) {
+      this._peerConnection.close();
+      this._peerConnection = null;
+    }
+    this._callback = null;
+    this._messageQueue = [];
+    this._window = null;
+  },
+
+  _doNotifyData(aData) {
+    if (!this._callback) {
+      throw Components.Exception("", Cr.NS_ERROR_NOT_AVAILABLE);
+    }
+
+    if (aData instanceof this._window.Blob) {
+      let reader = new this._window.FileReader();
+      reader.addEventListener("load", aEvent => {
+        this._callback.notifyData(aEvent.target.result, true);
+      });
+      reader.readAsBinaryString(aData);
+    } else {
+      this._callback.notifyData(aData, false);
+    }
+  },
+};
+
+var EXPORTED_SYMBOLS = [
+  "PresentationTransportBuilder",
+  "PresentationTransport",
+];
diff --git a/dom/presentation/PresentationDeviceManager.cpp b/dom/presentation/PresentationDeviceManager.cpp
new file mode 100644
index 0000000000..185f541430
--- /dev/null
+++ b/dom/presentation/PresentationDeviceManager.cpp
@@ -0,0 +1,307 @@
+/* -*- 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 "PresentationDeviceManager.h"
+
+#include "mozilla/Services.h"
+#include "MainThreadUtils.h"
+#include "nsArrayUtils.h"
+#include "nsCategoryCache.h"
+#include "nsCOMPtr.h"
+#include "nsComponentManagerUtils.h"
+#include "nsIMutableArray.h"
+#include "nsIObserverService.h"
+#include "nsISupportsPrimitives.h"
+#include "nsThreadUtils.h"
+#include "nsXULAppAPI.h"
+#include "PresentationSessionRequest.h"
+#include "PresentationTerminateRequest.h"
+
+namespace mozilla {
+namespace dom {
+
+NS_IMPL_ISUPPORTS(PresentationDeviceManager, nsIPresentationDeviceManager,
+                  nsIPresentationDeviceListener, nsIObserver,
+                  nsISupportsWeakReference)
+
+PresentationDeviceManager::PresentationDeviceManager() = default;
+
+PresentationDeviceManager::~PresentationDeviceManager() {
+  UnloadDeviceProviders();
+  mDevices.Clear();
+}
+
+void PresentationDeviceManager::Init() {
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (obs) {
+    obs->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false);
+  }
+
+  LoadDeviceProviders();
+}
+
+void PresentationDeviceManager::Shutdown() {
+  nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+  if (obs) {
+    obs->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID);
+  }
+
+  UnloadDeviceProviders();
+}
+
+void PresentationDeviceManager::LoadDeviceProviders() {
+  MOZ_ASSERT(mProviders.IsEmpty());
+
+  nsCategoryCache<nsIPresentationDeviceProvider> providerCache(
+      PRESENTATION_DEVICE_PROVIDER_CATEGORY);
+  providerCache.GetEntries(mProviders);
+
+  for (uint32_t i = 0; i < mProviders.Length(); ++i) {
+    mProviders[i]->SetListener(this);
+  }
+}
+
+void PresentationDeviceManager::UnloadDeviceProviders() {
+  for (uint32_t i = 0; i < mProviders.Length(); ++i) {
+    mProviders[i]->SetListener(nullptr);
+  }
+
+  mProviders.Clear();
+}
+
+void PresentationDeviceManager::NotifyDeviceChange(
+    nsIPresentationDevice* aDevice, const char16_t* aType) {
+  nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
+  if (obs) {
+    obs->NotifyObservers(aDevice, PRESENTATION_DEVICE_CHANGE_TOPIC, aType);
+  }
+}
+
+// nsIPresentationDeviceManager
+NS_IMETHODIMP
+PresentationDeviceManager::ForceDiscovery() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  for (uint32_t i = 0; i < mProviders.Length(); ++i) {
+    mProviders[i]->ForceDiscovery();
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationDeviceManager::AddDeviceProvider(
+    nsIPresentationDeviceProvider* aProvider) {
+  NS_ENSURE_ARG(aProvider);
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (NS_WARN_IF(mProviders.Contains(aProvider))) {
+    return NS_OK;
+  }
+
+  mProviders.AppendElement(aProvider);
+  aProvider->SetListener(this);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationDeviceManager::RemoveDeviceProvider(
+    nsIPresentationDeviceProvider* aProvider) {
+  NS_ENSURE_ARG(aProvider);
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (NS_WARN_IF(!mProviders.RemoveElement(aProvider))) {
+    return NS_ERROR_FAILURE;
+  }
+
+  aProvider->SetListener(nullptr);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationDeviceManager::GetDeviceAvailable(bool* aRetVal) {
+  NS_ENSURE_ARG_POINTER(aRetVal);
+  MOZ_ASSERT(NS_IsMainThread());
+
+  *aRetVal = !mDevices.IsEmpty();
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationDeviceManager::GetAvailableDevices(nsIArray* aPresentationUrls,
+                                               nsIArray** aRetVal) {
+  NS_ENSURE_ARG_POINTER(aRetVal);
+  MOZ_ASSERT(NS_IsMainThread());
+
+  // Bug 1194049: some providers may discontinue discovery after timeout.
+  // Call |ForceDiscovery()| here to make sure device lists are updated.
+  NS_DispatchToMainThread(
+      NewRunnableMethod("dom::PresentationDeviceManager::ForceDiscovery", this,
+                        &PresentationDeviceManager::ForceDiscovery));
+
+  nsTArray<nsString> presentationUrls;
+  if (aPresentationUrls) {
+    uint32_t length;
+    nsresult rv = aPresentationUrls->GetLength(&length);
+    if (NS_SUCCEEDED(rv)) {
+      for (uint32_t i = 0; i < length; ++i) {
+        nsCOMPtr<nsISupportsString> isupportStr =
+            do_QueryElementAt(aPresentationUrls, i);
+
+        nsAutoString presentationUrl;
+        rv = isupportStr->GetData(presentationUrl);
+        if (NS_WARN_IF(NS_FAILED(rv))) {
+          continue;
+        }
+
+        presentationUrls.AppendElement(presentationUrl);
+      }
+    }
+  }
+
+  nsCOMPtr<nsIMutableArray> devices = do_CreateInstance(NS_ARRAY_CONTRACTID);
+  for (uint32_t i = 0; i < mDevices.Length(); ++i) {
+    if (presentationUrls.IsEmpty()) {
+      devices->AppendElement(mDevices[i]);
+      continue;
+    }
+
+    for (uint32_t j = 0; j < presentationUrls.Length(); ++j) {
+      bool isSupported;
+      if (NS_SUCCEEDED(mDevices[i]->IsRequestedUrlSupported(presentationUrls[j],
+                                                            &isSupported)) &&
+          isSupported) {
+        devices->AppendElement(mDevices[i]);
+        break;
+      }
+    }
+  }
+
+  devices.forget(aRetVal);
+
+  return NS_OK;
+}
+
+// nsIPresentationDeviceListener
+NS_IMETHODIMP
+PresentationDeviceManager::AddDevice(nsIPresentationDevice* aDevice) {
+  NS_ENSURE_ARG(aDevice);
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (NS_WARN_IF(mDevices.Contains(aDevice))) {
+    return NS_ERROR_FAILURE;
+  }
+
+  mDevices.AppendElement(aDevice);
+
+  NotifyDeviceChange(aDevice, u"add");
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationDeviceManager::RemoveDevice(nsIPresentationDevice* aDevice) {
+  NS_ENSURE_ARG(aDevice);
+  MOZ_ASSERT(NS_IsMainThread());
+
+  int32_t index = mDevices.IndexOf(aDevice);
+  if (NS_WARN_IF(index < 0)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  mDevices.RemoveElementAt(index);
+
+  NotifyDeviceChange(aDevice, u"remove");
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationDeviceManager::UpdateDevice(nsIPresentationDevice* aDevice) {
+  NS_ENSURE_ARG(aDevice);
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (NS_WARN_IF(!mDevices.Contains(aDevice))) {
+    return NS_ERROR_FAILURE;
+  }
+
+  NotifyDeviceChange(aDevice, u"update");
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationDeviceManager::OnSessionRequest(
+    nsIPresentationDevice* aDevice, const nsAString& aUrl,
+    const nsAString& aPresentationId,
+    nsIPresentationControlChannel* aControlChannel) {
+  NS_ENSURE_ARG(aDevice);
+  NS_ENSURE_ARG(aControlChannel);
+
+  nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
+  NS_ENSURE_TRUE(obs, NS_ERROR_FAILURE);
+
+  RefPtr<PresentationSessionRequest> request = new PresentationSessionRequest(
+      aDevice, aUrl, aPresentationId, aControlChannel);
+  obs->NotifyObservers(request, PRESENTATION_SESSION_REQUEST_TOPIC, nullptr);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationDeviceManager::OnTerminateRequest(
+    nsIPresentationDevice* aDevice, const nsAString& aPresentationId,
+    nsIPresentationControlChannel* aControlChannel, bool aIsFromReceiver) {
+  NS_ENSURE_ARG(aDevice);
+  NS_ENSURE_ARG(aControlChannel);
+
+  nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
+  NS_ENSURE_TRUE(obs, NS_ERROR_FAILURE);
+
+  RefPtr<PresentationTerminateRequest> request =
+      new PresentationTerminateRequest(aDevice, aPresentationId,
+                                       aControlChannel, aIsFromReceiver);
+  obs->NotifyObservers(request, PRESENTATION_TERMINATE_REQUEST_TOPIC, nullptr);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationDeviceManager::OnReconnectRequest(
+    nsIPresentationDevice* aDevice, const nsAString& aUrl,
+    const nsAString& aPresentationId,
+    nsIPresentationControlChannel* aControlChannel) {
+  NS_ENSURE_ARG(aDevice);
+  NS_ENSURE_ARG(aControlChannel);
+
+  nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
+  NS_ENSURE_TRUE(obs, NS_ERROR_FAILURE);
+
+  RefPtr<PresentationSessionRequest> request = new PresentationSessionRequest(
+      aDevice, aUrl, aPresentationId, aControlChannel);
+  obs->NotifyObservers(request, PRESENTATION_RECONNECT_REQUEST_TOPIC, nullptr);
+
+  return NS_OK;
+}
+
+// nsIObserver
+NS_IMETHODIMP
+PresentationDeviceManager::Observe(nsISupports* aSubject, const char* aTopic,
+                                   const char16_t* aData) {
+  if (!strcmp(aTopic, "profile-after-change")) {
+    Init();
+  } else if (!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {
+    Shutdown();
+  }
+
+  return NS_OK;
+}
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/presentation/PresentationDeviceManager.h b/dom/presentation/PresentationDeviceManager.h
new file mode 100644
index 0000000000..88a9f42345
--- /dev/null
+++ b/dom/presentation/PresentationDeviceManager.h
@@ -0,0 +1,53 @@
+/* -*- 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_PresentationDeviceManager_h__
+#define mozilla_dom_PresentationDeviceManager_h__
+
+#include "nsIObserver.h"
+#include "nsIPresentationDevice.h"
+#include "nsIPresentationDeviceManager.h"
+#include "nsIPresentationDeviceProvider.h"
+#include "nsCOMArray.h"
+#include "nsWeakReference.h"
+
+namespace mozilla {
+namespace dom {
+
+class PresentationDeviceManager final : public nsIPresentationDeviceManager,
+                                        public nsIPresentationDeviceListener,
+                                        public nsIObserver,
+                                        public nsSupportsWeakReference {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPRESENTATIONDEVICEMANAGER
+  NS_DECL_NSIPRESENTATIONDEVICELISTENER
+  NS_DECL_NSIOBSERVER
+
+  PresentationDeviceManager();
+
+ private:
+  virtual ~PresentationDeviceManager();
+
+  void Init();
+
+  void Shutdown();
+
+  void LoadDeviceProviders();
+
+  void UnloadDeviceProviders();
+
+  void NotifyDeviceChange(nsIPresentationDevice* aDevice,
+                          const char16_t* aType);
+
+  nsCOMArray<nsIPresentationDeviceProvider> mProviders;
+  nsCOMArray<nsIPresentationDevice> mDevices;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif /* mozilla_dom_PresentationDeviceManager_h__ */
diff --git a/dom/presentation/PresentationLog.h b/dom/presentation/PresentationLog.h
new file mode 100644
index 0000000000..36e1f19948
--- /dev/null
+++ b/dom/presentation/PresentationLog.h
@@ -0,0 +1,33 @@
+/* -*- 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_PresentationLog_h
+#define mozilla_dom_PresentationLog_h
+
+/*
+ * MOZ_LOG=Presentation:5
+ * For detail, see PresentationService.cpp
+ */
+namespace mozilla {
+
+class LazyLogModule;
+
+namespace dom {
+extern mozilla::LazyLogModule gPresentationLog;
+}
+}  // namespace mozilla
+
+#undef PRES_ERROR
+#define PRES_ERROR(...)                                             \
+  MOZ_LOG(mozilla::dom::gPresentationLog, mozilla::LogLevel::Error, \
+          (__VA_ARGS__))
+
+#undef PRES_DEBUG
+#define PRES_DEBUG(...)                                             \
+  MOZ_LOG(mozilla::dom::gPresentationLog, mozilla::LogLevel::Debug, \
+          (__VA_ARGS__))
+
+#endif  // mozilla_dom_PresentationLog_h
diff --git a/dom/presentation/PresentationNetworkHelper.jsm b/dom/presentation/PresentationNetworkHelper.jsm
new file mode 100644
index 0000000000..fd21c19142
--- /dev/null
+++ b/dom/presentation/PresentationNetworkHelper.jsm
@@ -0,0 +1,27 @@
+// -*- Mode: js2; tab-width: 2; indent-tabs-mode: nil; js2-basic-offset: 2; js2-skip-preprocessor-directives: t; -*-
+/* 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/. */
+
+"use strict";
+
+const { EventDispatcher } = ChromeUtils.import(
+  "resource://gre/modules/Messaging.jsm"
+);
+
+function PresentationNetworkHelper() {}
+
+PresentationNetworkHelper.prototype = {
+  QueryInterface: ChromeUtils.generateQI(["nsIPresentationNetworkHelper"]),
+
+  getWifiIPAddress(aListener) {
+    EventDispatcher.instance
+      .sendRequestForResult({ type: "Wifi:GetIPAddress" })
+      .then(
+        result => aListener.onGetWifiIPAddress(result),
+        err => aListener.onError(err)
+      );
+  },
+};
+
+var EXPORTED_SYMBOLS = ["PresentationNetworkHelper"];
diff --git a/dom/presentation/PresentationReceiver.cpp b/dom/presentation/PresentationReceiver.cpp
new file mode 100644
index 0000000000..6eb9c87b8a
--- /dev/null
+++ b/dom/presentation/PresentationReceiver.cpp
@@ -0,0 +1,169 @@
+/* -*- 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 "PresentationReceiver.h"
+
+#include "mozilla/Logging.h"
+#include "mozilla/dom/PresentationReceiverBinding.h"
+#include "mozilla/dom/Promise.h"
+#include "nsContentUtils.h"
+#include "nsIDocShell.h"
+#include "nsIPresentationService.h"
+#include "nsPIDOMWindow.h"
+#include "nsServiceManagerUtils.h"
+#include "nsThreadUtils.h"
+#include "PresentationConnection.h"
+#include "PresentationConnectionList.h"
+#include "PresentationLog.h"
+
+namespace mozilla {
+namespace dom {
+
+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(PresentationReceiver, mOwner,
+                                      mGetConnectionListPromise,
+                                      mConnectionList)
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(PresentationReceiver)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(PresentationReceiver)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PresentationReceiver)
+  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+  NS_INTERFACE_MAP_ENTRY(nsIPresentationRespondingListener)
+  NS_INTERFACE_MAP_ENTRY(nsISupports)
+NS_INTERFACE_MAP_END
+
+/* static */
+already_AddRefed<PresentationReceiver> PresentationReceiver::Create(
+    nsPIDOMWindowInner* aWindow) {
+  RefPtr<PresentationReceiver> receiver = new PresentationReceiver(aWindow);
+  return NS_WARN_IF(!receiver->Init()) ? nullptr : receiver.forget();
+}
+
+PresentationReceiver::PresentationReceiver(nsPIDOMWindowInner* aWindow)
+    : mOwner(aWindow) {
+  MOZ_ASSERT(aWindow);
+}
+
+PresentationReceiver::~PresentationReceiver() { Shutdown(); }
+
+bool PresentationReceiver::Init() {
+  if (NS_WARN_IF(!mOwner)) {
+    return false;
+  }
+  mWindowId = mOwner->WindowID();
+
+  nsCOMPtr<nsIDocShell> docShell = mOwner->GetDocShell();
+  MOZ_ASSERT(docShell);
+
+  nsContentUtils::GetPresentationURL(docShell, mUrl);
+  return !mUrl.IsEmpty();
+}
+
+void PresentationReceiver::Shutdown() {
+  PRES_DEBUG("receiver shutdown:windowId[%" PRId64 "]\n", mWindowId);
+
+  // Unregister listener for incoming sessions.
+  nsCOMPtr<nsIPresentationService> service =
+      do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+  if (NS_WARN_IF(!service)) {
+    return;
+  }
+
+  Unused << NS_WARN_IF(
+      NS_FAILED(service->UnregisterRespondingListener(mWindowId)));
+}
+
+/* virtual */
+JSObject* PresentationReceiver::WrapObject(JSContext* aCx,
+                                           JS::Handle<JSObject*> aGivenProto) {
+  return PresentationReceiver_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+NS_IMETHODIMP
+PresentationReceiver::NotifySessionConnect(uint64_t aWindowId,
+                                           const nsAString& aSessionId) {
+  PRES_DEBUG("receiver session connect:id[%s], windowId[%" PRIx64 "]\n",
+             NS_ConvertUTF16toUTF8(aSessionId).get(), aWindowId);
+
+  if (NS_WARN_IF(!mOwner)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  if (NS_WARN_IF(aWindowId != mWindowId)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  if (NS_WARN_IF(!mConnectionList)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  RefPtr<PresentationConnection> connection = PresentationConnection::Create(
+      mOwner, aSessionId, mUrl, nsIPresentationService::ROLE_RECEIVER,
+      mConnectionList);
+  if (NS_WARN_IF(!connection)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  return NS_OK;
+}
+
+already_AddRefed<Promise> PresentationReceiver::GetConnectionList(
+    ErrorResult& aRv) {
+  nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(mOwner);
+  if (NS_WARN_IF(!global)) {
+    aRv.Throw(NS_ERROR_UNEXPECTED);
+    return nullptr;
+  }
+
+  if (!mGetConnectionListPromise) {
+    mGetConnectionListPromise = Promise::Create(global, aRv);
+    if (NS_WARN_IF(aRv.Failed())) {
+      return nullptr;
+    }
+
+    RefPtr<PresentationReceiver> self = this;
+    nsresult rv = NS_DispatchToMainThread(NS_NewRunnableFunction(
+        "dom::PresentationReceiver::GetConnectionList",
+        [self]() -> void { self->CreateConnectionList(); }));
+    if (NS_FAILED(rv)) {
+      aRv.Throw(rv);
+      return nullptr;
+    }
+  }
+
+  RefPtr<Promise> promise = mGetConnectionListPromise;
+  if (nsContentUtils::ShouldResistFingerprinting()) {
+    promise->MaybeReject(NS_ERROR_DOM_SECURITY_ERR);
+  }
+  return promise.forget();
+}
+
+void PresentationReceiver::CreateConnectionList() {
+  MOZ_ASSERT(mGetConnectionListPromise);
+
+  if (mConnectionList) {
+    return;
+  }
+
+  mConnectionList =
+      new PresentationConnectionList(mOwner, mGetConnectionListPromise);
+
+  // Register listener for incoming sessions.
+  nsCOMPtr<nsIPresentationService> service =
+      do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+  if (NS_WARN_IF(!service)) {
+    mGetConnectionListPromise->MaybeReject(NS_ERROR_DOM_OPERATION_ERR);
+    return;
+  }
+
+  nsresult rv = service->RegisterRespondingListener(mWindowId, this);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    mGetConnectionListPromise->MaybeReject(rv);
+  }
+}
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/presentation/PresentationReceiver.h b/dom/presentation/PresentationReceiver.h
new file mode 100644
index 0000000000..b71cf0b894
--- /dev/null
+++ b/dom/presentation/PresentationReceiver.h
@@ -0,0 +1,69 @@
+/* -*- 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_PresentationReceiver_h
+#define mozilla_dom_PresentationReceiver_h
+
+#include "nsCOMPtr.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsIPresentationListener.h"
+#include "nsWrapperCache.h"
+#include "nsString.h"
+
+class nsPIDOMWindowInner;
+
+namespace mozilla {
+class ErrorResult;
+
+namespace dom {
+
+class PresentationConnection;
+class PresentationConnectionList;
+class Promise;
+
+class PresentationReceiver final : public nsIPresentationRespondingListener,
+                                   public nsWrapperCache {
+ public:
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(PresentationReceiver)
+  NS_DECL_NSIPRESENTATIONRESPONDINGLISTENER
+
+  static already_AddRefed<PresentationReceiver> Create(
+      nsPIDOMWindowInner* aWindow);
+
+  virtual JSObject* WrapObject(JSContext* aCx,
+                               JS::Handle<JSObject*> aGivenProto) override;
+
+  nsPIDOMWindowInner* GetParentObject() const { return mOwner; }
+
+  // WebIDL (public APIs)
+  already_AddRefed<Promise> GetConnectionList(ErrorResult& aRv);
+
+ private:
+  explicit PresentationReceiver(nsPIDOMWindowInner* aWindow);
+
+  virtual ~PresentationReceiver();
+
+  MOZ_IS_CLASS_INIT bool Init();
+
+  void Shutdown();
+
+  void CreateConnectionList();
+
+  // Store the inner window ID for |UnregisterRespondingListener| call in
+  // |Shutdown| since the inner window may not exist at that moment.
+  uint64_t mWindowId;
+
+  nsCOMPtr<nsPIDOMWindowInner> mOwner;
+  nsString mUrl;
+  RefPtr<Promise> mGetConnectionListPromise;
+  RefPtr<PresentationConnectionList> mConnectionList;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_PresentationReceiver_h
diff --git a/dom/presentation/PresentationRequest.cpp b/dom/presentation/PresentationRequest.cpp
new file mode 100644
index 0000000000..6a7595a3bd
--- /dev/null
+++ b/dom/presentation/PresentationRequest.cpp
@@ -0,0 +1,530 @@
+/* -*- 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 "PresentationRequest.h"
+
+#include <utility>
+
+#include "AvailabilityCollection.h"
+#include "ControllerConnectionCollection.h"
+#include "Presentation.h"
+#include "PresentationAvailability.h"
+#include "PresentationCallbacks.h"
+#include "PresentationLog.h"
+#include "PresentationTransportBuilderConstructor.h"
+#include "mozilla/AsyncEventDispatcher.h"
+#include "mozilla/BasePrincipal.h"
+#include "mozilla/dom/Document.h"
+#include "mozilla/dom/Navigator.h"
+#include "mozilla/dom/PresentationConnectionAvailableEvent.h"
+#include "mozilla/dom/PresentationRequestBinding.h"
+#include "mozilla/dom/Promise.h"
+#include "nsContentSecurityManager.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsGlobalWindow.h"
+#include "nsIPresentationService.h"
+#include "nsIURI.h"
+#include "nsIUUIDGenerator.h"
+#include "nsNetUtil.h"
+#include "nsSandboxFlags.h"
+#include "nsServiceManagerUtils.h"
+
+namespace mozilla {
+namespace dom {
+
+NS_IMPL_ADDREF_INHERITED(PresentationRequest, DOMEventTargetHelper)
+NS_IMPL_RELEASE_INHERITED(PresentationRequest, DOMEventTargetHelper)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PresentationRequest)
+NS_INTERFACE_MAP_END_INHERITING(DOMEventTargetHelper)
+
+static nsresult GetAbsoluteURL(const nsAString& aUrl, nsIURI* aBaseUri,
+                               Document* aDocument, nsAString& aAbsoluteUrl) {
+  nsCOMPtr<nsIURI> uri;
+  nsresult rv;
+  if (aDocument) {
+    rv = NS_NewURI(getter_AddRefs(uri), aUrl,
+                   aDocument->GetDocumentCharacterSet(), aBaseUri);
+  } else {
+    rv = NS_NewURI(getter_AddRefs(uri), aUrl, nullptr, aBaseUri);
+  }
+
+  if (NS_FAILED(rv)) {
+    return rv;
+  }
+
+  nsAutoCString spec;
+  uri->GetSpec(spec);
+
+  CopyUTF8toUTF16(spec, aAbsoluteUrl);
+
+  return NS_OK;
+}
+
+/* static */
+already_AddRefed<PresentationRequest> PresentationRequest::Constructor(
+    const GlobalObject& aGlobal, const nsAString& aUrl, ErrorResult& aRv) {
+  Sequence<nsString> urls;
+  if (!urls.AppendElement(aUrl, fallible)) {
+    aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
+    return nullptr;
+  }
+  return Constructor(aGlobal, urls, aRv);
+}
+
+/* static */
+already_AddRefed<PresentationRequest> PresentationRequest::Constructor(
+    const GlobalObject& aGlobal, const Sequence<nsString>& aUrls,
+    ErrorResult& aRv) {
+  nsCOMPtr<nsPIDOMWindowInner> window =
+      do_QueryInterface(aGlobal.GetAsSupports());
+  if (!window) {
+    aRv.Throw(NS_ERROR_UNEXPECTED);
+    return nullptr;
+  }
+
+  if (aUrls.IsEmpty()) {
+    aRv.Throw(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
+    return nullptr;
+  }
+
+  // Resolve relative URL to absolute URL
+  nsCOMPtr<nsIURI> baseUri = window->GetDocBaseURI();
+  nsTArray<nsString> urls;
+  for (const auto& url : aUrls) {
+    nsAutoString absoluteUrl;
+    nsresult rv =
+        GetAbsoluteURL(url, baseUri, window->GetExtantDoc(), absoluteUrl);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
+      return nullptr;
+    }
+
+    urls.AppendElement(absoluteUrl);
+  }
+
+  RefPtr<PresentationRequest> request =
+      new PresentationRequest(window, std::move(urls));
+  return NS_WARN_IF(!request->Init()) ? nullptr : request.forget();
+}
+
+PresentationRequest::PresentationRequest(nsPIDOMWindowInner* aWindow,
+                                         nsTArray<nsString>&& aUrls)
+    : DOMEventTargetHelper(aWindow), mUrls(std::move(aUrls)) {}
+
+PresentationRequest::~PresentationRequest() = default;
+
+bool PresentationRequest::Init() { return true; }
+
+/* virtual */
+JSObject* PresentationRequest::WrapObject(JSContext* aCx,
+                                          JS::Handle<JSObject*> aGivenProto) {
+  return PresentationRequest_Binding::Wrap(aCx, this, aGivenProto);
+}
+
+already_AddRefed<Promise> PresentationRequest::Start(ErrorResult& aRv) {
+  return StartWithDevice(VoidString(), aRv);
+}
+
+already_AddRefed<Promise> PresentationRequest::StartWithDevice(
+    const nsAString& aDeviceId, ErrorResult& aRv) {
+  nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetOwner());
+  if (NS_WARN_IF(!global)) {
+    aRv.Throw(NS_ERROR_UNEXPECTED);
+    return nullptr;
+  }
+
+  // Get the origin.
+  nsAutoString origin;
+  nsresult rv = nsContentUtils::GetUTFOrigin(global->PrincipalOrNull(), origin);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    aRv.Throw(rv);
+    return nullptr;
+  }
+
+  nsCOMPtr<Document> doc = GetOwner()->GetExtantDoc();
+  if (NS_WARN_IF(!doc)) {
+    aRv.Throw(NS_ERROR_FAILURE);
+    return nullptr;
+  }
+
+  RefPtr<Promise> promise = Promise::Create(global, aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return nullptr;
+  }
+
+  if (nsContentUtils::ShouldResistFingerprinting()) {
+    promise->MaybeReject(NS_ERROR_DOM_SECURITY_ERR);
+    return promise.forget();
+  }
+
+  if (IsProhibitMixedSecurityContexts(doc) && !IsAllURLAuthenticated()) {
+    promise->MaybeReject(NS_ERROR_DOM_SECURITY_ERR);
+    return promise.forget();
+  }
+
+  if (doc->GetSandboxFlags() & SANDBOXED_PRESENTATION) {
+    promise->MaybeReject(NS_ERROR_DOM_SECURITY_ERR);
+    return promise.forget();
+  }
+
+  RefPtr<Navigator> navigator =
+      nsGlobalWindowInner::Cast(GetOwner())->Navigator();
+  if (NS_WARN_IF(aRv.Failed())) {
+    return nullptr;
+  }
+
+  RefPtr<Presentation> presentation = navigator->GetPresentation(aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return nullptr;
+  }
+
+  if (presentation->IsStartSessionUnsettled()) {
+    promise->MaybeReject(NS_ERROR_DOM_OPERATION_ERR);
+    return promise.forget();
+  }
+
+  // Generate a session ID.
+  nsCOMPtr<nsIUUIDGenerator> uuidgen =
+      do_GetService("@mozilla.org/uuid-generator;1");
+  if (NS_WARN_IF(!uuidgen)) {
+    promise->MaybeReject(NS_ERROR_DOM_OPERATION_ERR);
+    return promise.forget();
+  }
+
+  nsID uuid;
+  uuidgen->GenerateUUIDInPlace(&uuid);
+  char buffer[NSID_LENGTH];
+  uuid.ToProvidedString(buffer);
+  nsAutoString id;
+  CopyASCIItoUTF16(Span(buffer, NSID_LENGTH - 1), id);
+
+  nsCOMPtr<nsIPresentationService> service =
+      do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+  if (NS_WARN_IF(!service)) {
+    promise->MaybeReject(NS_ERROR_DOM_OPERATION_ERR);
+    return promise.forget();
+  }
+
+  presentation->SetStartSessionUnsettled(true);
+
+  // Get xul:browser element in parent process or nsWindowRoot object in child
+  // process. If it's in child process, the corresponding xul:browser element
+  // will be obtained at PresentationRequestParent::DoRequest in its parent
+  // process.
+  nsCOMPtr<EventTarget> handler = GetOwner()->GetChromeEventHandler();
+  nsCOMPtr<nsIPrincipal> principal = doc->NodePrincipal();
+  nsCOMPtr<nsIPresentationServiceCallback> callback =
+      new PresentationRequesterCallback(this, id, promise);
+  nsCOMPtr<nsIPresentationTransportBuilderConstructor> constructor =
+      PresentationTransportBuilderConstructor::Create();
+  rv = service->StartSession(mUrls, id, origin, aDeviceId,
+                             GetOwner()->WindowID(), handler, principal,
+                             callback, constructor);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    promise->MaybeReject(NS_ERROR_DOM_OPERATION_ERR);
+    NotifyPromiseSettled();
+  }
+
+  return promise.forget();
+}
+
+already_AddRefed<Promise> PresentationRequest::Reconnect(
+    const nsAString& aPresentationId, ErrorResult& aRv) {
+  nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetOwner());
+  if (NS_WARN_IF(!global)) {
+    aRv.Throw(NS_ERROR_UNEXPECTED);
+    return nullptr;
+  }
+
+  nsCOMPtr<Document> doc = GetOwner()->GetExtantDoc();
+  if (NS_WARN_IF(!doc)) {
+    aRv.Throw(NS_ERROR_FAILURE);
+    return nullptr;
+  }
+
+  RefPtr<Promise> promise = Promise::Create(global, aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return nullptr;
+  }
+
+  if (nsContentUtils::ShouldResistFingerprinting()) {
+    promise->MaybeReject(NS_ERROR_DOM_SECURITY_ERR);
+    return promise.forget();
+  }
+
+  if (IsProhibitMixedSecurityContexts(doc) && !IsAllURLAuthenticated()) {
+    promise->MaybeReject(NS_ERROR_DOM_SECURITY_ERR);
+    return promise.forget();
+  }
+
+  if (doc->GetSandboxFlags() & SANDBOXED_PRESENTATION) {
+    promise->MaybeReject(NS_ERROR_DOM_SECURITY_ERR);
+    return promise.forget();
+  }
+
+  nsString presentationId = nsString(aPresentationId);
+  nsCOMPtr<nsIRunnable> r = NewRunnableMethod<nsString, RefPtr<Promise>>(
+      "dom::PresentationRequest::FindOrCreatePresentationConnection", this,
+      &PresentationRequest::FindOrCreatePresentationConnection, presentationId,
+      promise);
+
+  if (NS_WARN_IF(NS_FAILED(NS_DispatchToMainThread(r)))) {
+    promise->MaybeReject(NS_ERROR_DOM_OPERATION_ERR);
+  }
+
+  return promise.forget();
+}
+
+void PresentationRequest::FindOrCreatePresentationConnection(
+    const nsAString& aPresentationId, Promise* aPromise) {
+  MOZ_ASSERT(aPromise);
+
+  if (NS_WARN_IF(!GetOwner())) {
+    aPromise->MaybeReject(NS_ERROR_DOM_OPERATION_ERR);
+    return;
+  }
+
+  RefPtr<PresentationConnection> connection =
+      ControllerConnectionCollection::GetSingleton()->FindConnection(
+          GetOwner()->WindowID(), aPresentationId,
+          nsIPresentationService::ROLE_CONTROLLER);
+
+  if (connection) {
+    nsAutoString url;
+    connection->GetUrl(url);
+    if (mUrls.Contains(url)) {
+      switch (connection->State()) {
+        case PresentationConnectionState::Closed:
+          // We found the matched connection.
+          break;
+        case PresentationConnectionState::Connecting:
+        case PresentationConnectionState::Connected:
+          aPromise->MaybeResolve(connection);
+          return;
+        case PresentationConnectionState::Terminated:
+          // A terminated connection cannot be reused.
+          connection = nullptr;
+          break;
+        default:
+          MOZ_CRASH("Unknown presentation session state.");
+          return;
+      }
+    } else {
+      connection = nullptr;
+    }
+  }
+
+  nsCOMPtr<nsIPresentationService> service =
+      do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+  if (NS_WARN_IF(!service)) {
+    aPromise->MaybeReject(NS_ERROR_DOM_OPERATION_ERR);
+    return;
+  }
+
+  nsCOMPtr<nsIPresentationServiceCallback> callback =
+      new PresentationReconnectCallback(this, aPresentationId, aPromise,
+                                        connection);
+
+  nsresult rv = service->ReconnectSession(
+      mUrls, aPresentationId, nsIPresentationService::ROLE_CONTROLLER,
+      callback);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    aPromise->MaybeReject(NS_ERROR_DOM_OPERATION_ERR);
+  }
+}
+
+already_AddRefed<Promise> PresentationRequest::GetAvailability(
+    ErrorResult& aRv) {
+  PRES_DEBUG("%s\n", __func__);
+  nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetOwner());
+  if (NS_WARN_IF(!global)) {
+    aRv.Throw(NS_ERROR_UNEXPECTED);
+    return nullptr;
+  }
+
+  nsCOMPtr<Document> doc = GetOwner()->GetExtantDoc();
+  if (NS_WARN_IF(!doc)) {
+    aRv.Throw(NS_ERROR_FAILURE);
+    return nullptr;
+  }
+
+  RefPtr<Promise> promise = Promise::Create(global, aRv);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return nullptr;
+  }
+
+  if (nsContentUtils::ShouldResistFingerprinting()) {
+    promise->MaybeReject(NS_ERROR_DOM_SECURITY_ERR);
+    return promise.forget();
+  }
+
+  if (IsProhibitMixedSecurityContexts(doc) && !IsAllURLAuthenticated()) {
+    promise->MaybeReject(NS_ERROR_DOM_SECURITY_ERR);
+    return promise.forget();
+  }
+
+  if (doc->GetSandboxFlags() & SANDBOXED_PRESENTATION) {
+    promise->MaybeReject(NS_ERROR_DOM_SECURITY_ERR);
+    return promise.forget();
+  }
+
+  FindOrCreatePresentationAvailability(promise);
+
+  return promise.forget();
+}
+
+void PresentationRequest::FindOrCreatePresentationAvailability(
+    RefPtr<Promise>& aPromise) {
+  MOZ_ASSERT(aPromise);
+
+  if (NS_WARN_IF(!GetOwner())) {
+    aPromise->MaybeReject(NS_ERROR_DOM_OPERATION_ERR);
+    return;
+  }
+
+  AvailabilityCollection* collection = AvailabilityCollection::GetSingleton();
+  if (NS_WARN_IF(!collection)) {
+    aPromise->MaybeReject(NS_ERROR_DOM_OPERATION_ERR);
+    return;
+  }
+
+  RefPtr<PresentationAvailability> availability =
+      collection->Find(GetOwner()->WindowID(), mUrls);
+
+  if (!availability) {
+    availability =
+        PresentationAvailability::Create(GetOwner(), mUrls, aPromise);
+  } else {
+    PRES_DEBUG(">resolve with same object\n");
+
+    // Fetching cached available devices is asynchronous in our implementation,
+    // we need to ensure the promise is resolved in order.
+    if (availability->IsCachedValueReady()) {
+      aPromise->MaybeResolve(availability);
+      return;
+    }
+
+    availability->EnqueuePromise(aPromise);
+  }
+
+  if (!availability) {
+    aPromise->MaybeReject(NS_ERROR_DOM_NOT_SUPPORTED_ERR);
+    return;
+  }
+}
+
+nsresult PresentationRequest::DispatchConnectionAvailableEvent(
+    PresentationConnection* aConnection) {
+  if (nsContentUtils::ShouldResistFingerprinting()) {
+    return NS_OK;
+  }
+
+  PresentationConnectionAvailableEventInit init;
+  init.mConnection = aConnection;
+
+  RefPtr<PresentationConnectionAvailableEvent> event =
+      PresentationConnectionAvailableEvent::Constructor(
+          this, u"connectionavailable"_ns, init);
+  if (NS_WARN_IF(!event)) {
+    return NS_ERROR_FAILURE;
+  }
+  event->SetTrusted(true);
+
+  RefPtr<AsyncEventDispatcher> asyncDispatcher =
+      new AsyncEventDispatcher(this, event);
+  return asyncDispatcher->PostDOMEvent();
+}
+
+void PresentationRequest::NotifyPromiseSettled() {
+  PRES_DEBUG("%s\n", __func__);
+
+  if (!GetOwner()) {
+    return;
+  }
+
+  RefPtr<Navigator> navigator =
+      nsGlobalWindowInner::Cast(GetOwner())->Navigator();
+  if (!navigator) {
+    return;
+  }
+
+  ErrorResult rv;
+  RefPtr<Presentation> presentation = navigator->GetPresentation(rv);
+
+  if (presentation) {
+    presentation->SetStartSessionUnsettled(false);
+  }
+}
+
+bool PresentationRequest::IsProhibitMixedSecurityContexts(Document* aDocument) {
+  MOZ_ASSERT(aDocument);
+
+  if (nsContentUtils::IsChromeDoc(aDocument)) {
+    return true;
+  }
+
+  nsCOMPtr<Document> doc = aDocument;
+  while (doc && !nsContentUtils::IsChromeDoc(doc)) {
+    if (nsContentUtils::HttpsStateIsModern(doc)) {
+      return true;
+    }
+
+    doc = doc->GetInProcessParentDocument();
+  }
+
+  return false;
+}
+
+bool PresentationRequest::IsPrioriAuthenticatedURL(const nsAString& aUrl) {
+  nsCOMPtr<nsIURI> uri;
+  if (NS_FAILED(NS_NewURI(getter_AddRefs(uri), aUrl))) {
+    return false;
+  }
+
+  nsAutoCString scheme;
+  nsresult rv = uri->GetScheme(scheme);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return false;
+  }
+
+  if (scheme.EqualsLiteral("data")) {
+    return true;
+  }
+
+  nsAutoCString uriSpec;
+  rv = uri->GetSpec(uriSpec);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return false;
+  }
+
+  if (uriSpec.EqualsLiteral("about:blank") ||
+      uriSpec.EqualsLiteral("about:srcdoc")) {
+    return true;
+  }
+
+  OriginAttributes attrs;
+  nsCOMPtr<nsIPrincipal> principal =
+      BasePrincipal::CreateContentPrincipal(uri, attrs);
+  if (NS_WARN_IF(!principal)) {
+    return false;
+  }
+
+  return principal->GetIsOriginPotentiallyTrustworthy();
+}
+
+bool PresentationRequest::IsAllURLAuthenticated() {
+  for (const auto& url : mUrls) {
+    if (!IsPrioriAuthenticatedURL(url)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/presentation/PresentationRequest.h b/dom/presentation/PresentationRequest.h
new file mode 100644
index 0000000000..26c6031bcd
--- /dev/null
+++ b/dom/presentation/PresentationRequest.h
@@ -0,0 +1,80 @@
+/* -*- 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_PresentationRequest_h
+#define mozilla_dom_PresentationRequest_h
+
+#include "mozilla/dom/BindingDeclarations.h"
+#include "mozilla/DOMEventTargetHelper.h"
+
+namespace mozilla {
+namespace dom {
+
+class Promise;
+class PresentationAvailability;
+class PresentationConnection;
+
+class PresentationRequest final : public DOMEventTargetHelper {
+ public:
+  NS_DECL_ISUPPORTS_INHERITED
+
+  static already_AddRefed<PresentationRequest> Constructor(
+      const GlobalObject& aGlobal, const nsAString& aUrl, ErrorResult& aRv);
+
+  static already_AddRefed<PresentationRequest> Constructor(
+      const GlobalObject& aGlobal, const Sequence<nsString>& aUrls,
+      ErrorResult& aRv);
+
+  virtual JSObject* WrapObject(JSContext* aCx,
+                               JS::Handle<JSObject*> aGivenProto) override;
+
+  // WebIDL (public APIs)
+  already_AddRefed<Promise> Start(ErrorResult& aRv);
+
+  already_AddRefed<Promise> StartWithDevice(const nsAString& aDeviceId,
+                                            ErrorResult& aRv);
+
+  already_AddRefed<Promise> Reconnect(const nsAString& aPresentationId,
+                                      ErrorResult& aRv);
+
+  already_AddRefed<Promise> GetAvailability(ErrorResult& aRv);
+
+  IMPL_EVENT_HANDLER(connectionavailable);
+
+  nsresult DispatchConnectionAvailableEvent(
+      PresentationConnection* aConnection);
+
+  void NotifyPromiseSettled();
+
+ private:
+  PresentationRequest(nsPIDOMWindowInner* aWindow, nsTArray<nsString>&& aUrls);
+
+  ~PresentationRequest();
+
+  bool Init();
+
+  void FindOrCreatePresentationConnection(const nsAString& aPresentationId,
+                                          Promise* aPromise);
+
+  void FindOrCreatePresentationAvailability(RefPtr<Promise>& aPromise);
+
+  // Implement
+  // https://w3c.github.io/webappsec-mixed-content/#categorize-settings-object
+  bool IsProhibitMixedSecurityContexts(Document* aDocument);
+
+  // Implement
+  // https://w3c.github.io/webappsec-mixed-content/#a-priori-authenticated-url
+  bool IsPrioriAuthenticatedURL(const nsAString& aUrl);
+
+  bool IsAllURLAuthenticated();
+
+  nsTArray<nsString> mUrls;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_PresentationRequest_h
diff --git a/dom/presentation/PresentationService.cpp b/dom/presentation/PresentationService.cpp
new file mode 100644
index 0000000000..2845ad5931
--- /dev/null
+++ b/dom/presentation/PresentationService.cpp
@@ -0,0 +1,1117 @@
+/* -*- 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 "PresentationService.h"
+
+#include "ipc/PresentationIPCService.h"
+#include "mozilla/Services.h"
+#include "nsArrayUtils.h"
+#include "nsGlobalWindow.h"
+#include "nsIMutableArray.h"
+#include "nsIObserverService.h"
+#include "nsIPresentationDeviceManager.h"
+#include "nsIPresentationDevicePrompt.h"
+#include "nsIPresentationListener.h"
+#include "nsIPresentationRequestUIGlue.h"
+#include "nsIPresentationSessionRequest.h"
+#include "nsIPresentationTerminateRequest.h"
+#include "nsISupportsPrimitives.h"
+#include "nsNetUtil.h"
+#include "nsServiceManagerUtils.h"
+#include "nsThreadUtils.h"
+#include "nsXPCOMCID.h"
+#include "nsXULAppAPI.h"
+#include "PresentationLog.h"
+
+namespace mozilla {
+namespace dom {
+
+static bool IsSameDevice(nsIPresentationDevice* aDevice,
+                         nsIPresentationDevice* aDeviceAnother) {
+  if (!aDevice || !aDeviceAnother) {
+    return false;
+  }
+
+  nsAutoCString deviceId;
+  aDevice->GetId(deviceId);
+  nsAutoCString anotherId;
+  aDeviceAnother->GetId(anotherId);
+  if (!deviceId.Equals(anotherId)) {
+    return false;
+  }
+
+  nsAutoCString deviceType;
+  aDevice->GetType(deviceType);
+  nsAutoCString anotherType;
+  aDeviceAnother->GetType(anotherType);
+  if (!deviceType.Equals(anotherType)) {
+    return false;
+  }
+
+  return true;
+}
+
+static nsresult ConvertURLArrayHelper(const nsTArray<nsString>& aUrls,
+                                      nsIArray** aResult) {
+  if (!aResult) {
+    return NS_ERROR_INVALID_POINTER;
+  }
+
+  *aResult = nullptr;
+
+  nsresult rv;
+  nsCOMPtr<nsIMutableArray> urls = do_CreateInstance(NS_ARRAY_CONTRACTID, &rv);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  for (const auto& url : aUrls) {
+    nsCOMPtr<nsISupportsString> isupportsString =
+        do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID, &rv);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    rv = isupportsString->SetData(url);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    rv = urls->AppendElement(isupportsString);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+  }
+
+  urls.forget(aResult);
+  return NS_OK;
+}
+
+/*
+ * Implementation of PresentationDeviceRequest
+ */
+
+class PresentationDeviceRequest final : public nsIPresentationDeviceRequest {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPRESENTATIONDEVICEREQUEST
+
+  PresentationDeviceRequest(
+      const nsTArray<nsString>& aUrls, const nsAString& aId,
+      const nsAString& aOrigin, uint64_t aWindowId, EventTarget* aEventTarget,
+      nsIPrincipal* aPrincipal, nsIPresentationServiceCallback* aCallback,
+      nsIPresentationTransportBuilderConstructor* aBuilderConstructor);
+
+ private:
+  virtual ~PresentationDeviceRequest() = default;
+  nsresult CreateSessionInfo(nsIPresentationDevice* aDevice,
+                             const nsAString& aSelectedRequestUrl);
+
+  nsTArray<nsString> mRequestUrls;
+  nsString mId;
+  nsString mOrigin;
+  uint64_t mWindowId;
+  nsWeakPtr mChromeEventHandler;
+  nsCOMPtr<nsIPrincipal> mPrincipal;
+  nsCOMPtr<nsIPresentationServiceCallback> mCallback;
+  nsCOMPtr<nsIPresentationTransportBuilderConstructor> mBuilderConstructor;
+};
+
+LazyLogModule gPresentationLog("Presentation");
+
+NS_IMPL_ISUPPORTS(PresentationDeviceRequest, nsIPresentationDeviceRequest)
+
+PresentationDeviceRequest::PresentationDeviceRequest(
+    const nsTArray<nsString>& aUrls, const nsAString& aId,
+    const nsAString& aOrigin, uint64_t aWindowId, EventTarget* aEventTarget,
+    nsIPrincipal* aPrincipal, nsIPresentationServiceCallback* aCallback,
+    nsIPresentationTransportBuilderConstructor* aBuilderConstructor)
+    : mRequestUrls(aUrls.Clone()),
+      mId(aId),
+      mOrigin(aOrigin),
+      mWindowId(aWindowId),
+      mChromeEventHandler(do_GetWeakReference(aEventTarget)),
+      mPrincipal(aPrincipal),
+      mCallback(aCallback),
+      mBuilderConstructor(aBuilderConstructor) {
+  MOZ_ASSERT(!mRequestUrls.IsEmpty());
+  MOZ_ASSERT(!mId.IsEmpty());
+  MOZ_ASSERT(!mOrigin.IsEmpty());
+  MOZ_ASSERT(mCallback);
+  MOZ_ASSERT(mBuilderConstructor);
+}
+
+NS_IMETHODIMP
+PresentationDeviceRequest::GetOrigin(nsAString& aOrigin) {
+  aOrigin = mOrigin;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationDeviceRequest::GetRequestURLs(nsIArray** aUrls) {
+  return ConvertURLArrayHelper(mRequestUrls, aUrls);
+}
+
+NS_IMETHODIMP
+PresentationDeviceRequest::GetChromeEventHandler(
+    EventTarget** aChromeEventHandler) {
+  RefPtr<EventTarget> handler(do_QueryReferent(mChromeEventHandler));
+  handler.forget(aChromeEventHandler);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationDeviceRequest::GetPrincipal(nsIPrincipal** aPrincipal) {
+  nsCOMPtr<nsIPrincipal> principal(mPrincipal);
+  principal.forget(aPrincipal);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationDeviceRequest::Select(nsIPresentationDevice* aDevice) {
+  MOZ_ASSERT(NS_IsMainThread());
+  if (NS_WARN_IF(!aDevice)) {
+    MOZ_ASSERT(false, "|aDevice| should noe be null.");
+    mCallback->NotifyError(NS_ERROR_DOM_OPERATION_ERR);
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  // Select the most suitable URL for starting the presentation.
+  nsAutoString selectedRequestUrl;
+  for (const auto& url : mRequestUrls) {
+    bool isSupported;
+    if (NS_SUCCEEDED(aDevice->IsRequestedUrlSupported(url, &isSupported)) &&
+        isSupported) {
+      selectedRequestUrl.Assign(url);
+      break;
+    }
+  }
+
+  if (selectedRequestUrl.IsEmpty()) {
+    return mCallback->NotifyError(NS_ERROR_DOM_NOT_FOUND_ERR);
+  }
+
+  if (NS_WARN_IF(NS_FAILED(CreateSessionInfo(aDevice, selectedRequestUrl)))) {
+    return mCallback->NotifyError(NS_ERROR_DOM_OPERATION_ERR);
+  }
+
+  return mCallback->NotifySuccess(selectedRequestUrl);
+}
+
+nsresult PresentationDeviceRequest::CreateSessionInfo(
+    nsIPresentationDevice* aDevice, const nsAString& aSelectedRequestUrl) {
+  nsCOMPtr<nsIPresentationService> service =
+      do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+  if (NS_WARN_IF(!service)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  // Create the controlling session info
+  RefPtr<PresentationSessionInfo> info =
+      static_cast<PresentationService*>(service.get())
+          ->CreateControllingSessionInfo(aSelectedRequestUrl, mId, mWindowId);
+  if (NS_WARN_IF(!info)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+  info->SetDevice(aDevice);
+
+  // Establish a control channel. If we failed to do so, the callback is called
+  // with an error message.
+  nsCOMPtr<nsIPresentationControlChannel> ctrlChannel;
+  nsresult rv = aDevice->EstablishControlChannel(getter_AddRefs(ctrlChannel));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return info->ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+  }
+
+  // Initialize the session info with the control channel.
+  rv = info->Init(ctrlChannel);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return info->ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+  }
+
+  info->SetTransportBuilderConstructor(mBuilderConstructor);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationDeviceRequest::Cancel(nsresult aReason) {
+  return mCallback->NotifyError(aReason);
+}
+
+/*
+ * Implementation of PresentationService
+ */
+
+NS_IMPL_ISUPPORTS(PresentationService, nsIPresentationService, nsIObserver)
+
+PresentationService::PresentationService() = default;
+
+PresentationService::~PresentationService() { HandleShutdown(); }
+
+bool PresentationService::Init() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
+  if (NS_WARN_IF(!obs)) {
+    return false;
+  }
+
+  nsresult rv = obs->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return false;
+  }
+  rv = obs->AddObserver(this, PRESENTATION_DEVICE_CHANGE_TOPIC, false);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return false;
+  }
+  rv = obs->AddObserver(this, PRESENTATION_SESSION_REQUEST_TOPIC, false);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return false;
+  }
+  rv = obs->AddObserver(this, PRESENTATION_TERMINATE_REQUEST_TOPIC, false);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return false;
+  }
+  rv = obs->AddObserver(this, PRESENTATION_RECONNECT_REQUEST_TOPIC, false);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return false;
+  }
+
+  return !NS_WARN_IF(NS_FAILED(rv));
+}
+
+NS_IMETHODIMP
+PresentationService::Observe(nsISupports* aSubject, const char* aTopic,
+                             const char16_t* aData) {
+  if (!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {
+    HandleShutdown();
+    return NS_OK;
+  }
+
+  if (!strcmp(aTopic, PRESENTATION_DEVICE_CHANGE_TOPIC)) {
+    // Ignore the "update" case here, since we only care about the arrival and
+    // removal of the device.
+    if (!NS_strcmp(aData, u"add")) {
+      nsCOMPtr<nsIPresentationDevice> device = do_QueryInterface(aSubject);
+      if (NS_WARN_IF(!device)) {
+        return NS_ERROR_FAILURE;
+      }
+
+      HandleDeviceAdded(device);
+      return NS_OK;
+    }
+
+    if (!NS_strcmp(aData, u"remove")) {
+      return HandleDeviceRemoved();
+    }
+    return NS_OK;
+  }
+  if (!strcmp(aTopic, PRESENTATION_SESSION_REQUEST_TOPIC)) {
+    nsCOMPtr<nsIPresentationSessionRequest> request(
+        do_QueryInterface(aSubject));
+    if (NS_WARN_IF(!request)) {
+      return NS_ERROR_FAILURE;
+    }
+
+    return HandleSessionRequest(request);
+  }
+  if (!strcmp(aTopic, PRESENTATION_TERMINATE_REQUEST_TOPIC)) {
+    nsCOMPtr<nsIPresentationTerminateRequest> request(
+        do_QueryInterface(aSubject));
+    if (NS_WARN_IF(!request)) {
+      return NS_ERROR_FAILURE;
+    }
+
+    return HandleTerminateRequest(request);
+  }
+  if (!strcmp(aTopic, PRESENTATION_RECONNECT_REQUEST_TOPIC)) {
+    nsCOMPtr<nsIPresentationSessionRequest> request(
+        do_QueryInterface(aSubject));
+    if (NS_WARN_IF(!request)) {
+      return NS_ERROR_FAILURE;
+    }
+
+    return HandleReconnectRequest(request);
+  }
+  if (!strcmp(aTopic, "profile-after-change")) {
+    // It's expected since we add and entry to |kLayoutCategories| in
+    // |nsLayoutModule.cpp| to launch this service earlier.
+    return NS_OK;
+  }
+  MOZ_ASSERT(false, "Unexpected topic for PresentationService");
+  return NS_ERROR_UNEXPECTED;
+}
+
+void PresentationService::HandleShutdown() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  Shutdown();
+
+  mAvailabilityManager.Clear();
+  mSessionInfoAtController.Clear();
+  mSessionInfoAtReceiver.Clear();
+
+  nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
+  if (obs) {
+    obs->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID);
+    obs->RemoveObserver(this, PRESENTATION_DEVICE_CHANGE_TOPIC);
+    obs->RemoveObserver(this, PRESENTATION_SESSION_REQUEST_TOPIC);
+    obs->RemoveObserver(this, PRESENTATION_TERMINATE_REQUEST_TOPIC);
+    obs->RemoveObserver(this, PRESENTATION_RECONNECT_REQUEST_TOPIC);
+  }
+}
+
+void PresentationService::HandleDeviceAdded(nsIPresentationDevice* aDevice) {
+  PRES_DEBUG("%s\n", __func__);
+  MOZ_ASSERT(aDevice);
+
+  // Query for only unavailable URLs while device added.
+  nsTArray<nsString> unavailableUrls;
+  mAvailabilityManager.GetAvailbilityUrlByAvailability(unavailableUrls, false);
+
+  nsTArray<nsString> supportedAvailabilityUrl;
+  for (const auto& url : unavailableUrls) {
+    bool isSupported;
+    if (NS_SUCCEEDED(aDevice->IsRequestedUrlSupported(url, &isSupported)) &&
+        isSupported) {
+      supportedAvailabilityUrl.AppendElement(url);
+    }
+  }
+
+  if (!supportedAvailabilityUrl.IsEmpty()) {
+    mAvailabilityManager.DoNotifyAvailableChange(supportedAvailabilityUrl,
+                                                 true);
+  }
+}
+
+nsresult PresentationService::HandleDeviceRemoved() {
+  PRES_DEBUG("%s\n", __func__);
+
+  // Query for only available URLs while device removed.
+  nsTArray<nsString> availabilityUrls;
+  mAvailabilityManager.GetAvailbilityUrlByAvailability(availabilityUrls, true);
+
+  return UpdateAvailabilityUrlChange(availabilityUrls);
+}
+
+nsresult PresentationService::UpdateAvailabilityUrlChange(
+    const nsTArray<nsString>& aAvailabilityUrls) {
+  nsCOMPtr<nsIPresentationDeviceManager> deviceManager =
+      do_GetService(PRESENTATION_DEVICE_MANAGER_CONTRACTID);
+  if (NS_WARN_IF(!deviceManager)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  nsCOMPtr<nsIArray> devices;
+  nsresult rv =
+      deviceManager->GetAvailableDevices(nullptr, getter_AddRefs(devices));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  uint32_t numOfDevices;
+  devices->GetLength(&numOfDevices);
+
+  nsTArray<nsString> supportedAvailabilityUrl;
+  for (const auto& url : aAvailabilityUrls) {
+    for (uint32_t i = 0; i < numOfDevices; ++i) {
+      nsCOMPtr<nsIPresentationDevice> device = do_QueryElementAt(devices, i);
+      if (device) {
+        bool isSupported;
+        if (NS_SUCCEEDED(device->IsRequestedUrlSupported(url, &isSupported)) &&
+            isSupported) {
+          supportedAvailabilityUrl.AppendElement(url);
+          break;
+        }
+      }
+    }
+  }
+
+  if (supportedAvailabilityUrl.IsEmpty()) {
+    mAvailabilityManager.DoNotifyAvailableChange(aAvailabilityUrls, false);
+  } else {
+    mAvailabilityManager.DoNotifyAvailableChange(supportedAvailabilityUrl,
+                                                 true);
+  }
+  return NS_OK;
+}
+
+nsresult PresentationService::HandleSessionRequest(
+    nsIPresentationSessionRequest* aRequest) {
+  nsCOMPtr<nsIPresentationControlChannel> ctrlChannel;
+  nsresult rv = aRequest->GetControlChannel(getter_AddRefs(ctrlChannel));
+  if (NS_WARN_IF(NS_FAILED(rv) || !ctrlChannel)) {
+    return rv;
+  }
+
+  nsAutoString url;
+  rv = aRequest->GetUrl(url);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    ctrlChannel->Disconnect(rv);
+    return rv;
+  }
+
+  nsAutoString sessionId;
+  rv = aRequest->GetPresentationId(sessionId);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    ctrlChannel->Disconnect(rv);
+    return rv;
+  }
+
+  nsCOMPtr<nsIPresentationDevice> device;
+  rv = aRequest->GetDevice(getter_AddRefs(device));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    ctrlChannel->Disconnect(rv);
+    return rv;
+  }
+
+  // Create or reuse session info.
+  RefPtr<PresentationSessionInfo> info =
+      GetSessionInfo(sessionId, nsIPresentationService::ROLE_RECEIVER);
+
+  // This is the case for reconnecting a session.
+  // Update the control channel and device of the session info.
+  // Call |NotifyResponderReady| to indicate the receiver page is already there.
+  if (info) {
+    PRES_DEBUG("handle reconnection:id[%s]\n",
+               NS_ConvertUTF16toUTF8(sessionId).get());
+
+    info->SetControlChannel(ctrlChannel);
+    info->SetDevice(device);
+    return static_cast<PresentationPresentingInfo*>(info.get())->DoReconnect();
+  }
+
+  // This is the case for a new session.
+  PRES_DEBUG("handle new session:url[%s], id[%s]\n",
+             NS_ConvertUTF16toUTF8(url).get(),
+             NS_ConvertUTF16toUTF8(sessionId).get());
+
+  info = new PresentationPresentingInfo(url, sessionId, device);
+  rv = info->Init(ctrlChannel);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    ctrlChannel->Disconnect(rv);
+    return rv;
+  }
+
+  mSessionInfoAtReceiver.Put(sessionId, RefPtr{info});
+
+  // Notify the receiver to launch.
+  nsCOMPtr<nsIPresentationRequestUIGlue> glue =
+      do_CreateInstance(PRESENTATION_REQUEST_UI_GLUE_CONTRACTID);
+  if (NS_WARN_IF(!glue)) {
+    ctrlChannel->Disconnect(NS_ERROR_DOM_OPERATION_ERR);
+    return info->ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+  }
+  RefPtr<Promise> promise;
+  rv = glue->SendRequest(url, sessionId, device, getter_AddRefs(promise));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    ctrlChannel->Disconnect(rv);
+    return info->ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+  }
+  static_cast<PresentationPresentingInfo*>(info.get())->SetPromise(promise);
+
+  return NS_OK;
+}
+
+nsresult PresentationService::HandleTerminateRequest(
+    nsIPresentationTerminateRequest* aRequest) {
+  nsCOMPtr<nsIPresentationControlChannel> ctrlChannel;
+  nsresult rv = aRequest->GetControlChannel(getter_AddRefs(ctrlChannel));
+  if (NS_WARN_IF(NS_FAILED(rv) || !ctrlChannel)) {
+    return rv;
+  }
+
+  nsAutoString sessionId;
+  rv = aRequest->GetPresentationId(sessionId);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    ctrlChannel->Disconnect(rv);
+    return rv;
+  }
+
+  nsCOMPtr<nsIPresentationDevice> device;
+  rv = aRequest->GetDevice(getter_AddRefs(device));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    ctrlChannel->Disconnect(rv);
+    return rv;
+  }
+
+  bool isFromReceiver;
+  rv = aRequest->GetIsFromReceiver(&isFromReceiver);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    ctrlChannel->Disconnect(rv);
+    return rv;
+  }
+
+  RefPtr<PresentationSessionInfo> info;
+  if (!isFromReceiver) {
+    info = GetSessionInfo(sessionId, nsIPresentationService::ROLE_RECEIVER);
+  } else {
+    info = GetSessionInfo(sessionId, nsIPresentationService::ROLE_CONTROLLER);
+  }
+  if (NS_WARN_IF(!info)) {
+    // Cannot terminate non-existed session.
+    ctrlChannel->Disconnect(NS_ERROR_DOM_OPERATION_ERR);
+    return NS_ERROR_DOM_ABORT_ERR;
+  }
+
+  // Check if terminate request comes from known device.
+  RefPtr<nsIPresentationDevice> knownDevice = info->GetDevice();
+  if (NS_WARN_IF(!IsSameDevice(device, knownDevice))) {
+    ctrlChannel->Disconnect(NS_ERROR_DOM_OPERATION_ERR);
+    return NS_ERROR_DOM_ABORT_ERR;
+  }
+
+  PRES_DEBUG("%s:handle termination:id[%s], receiver[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(sessionId).get(), isFromReceiver);
+
+  info->OnTerminate(ctrlChannel);
+  return NS_OK;
+}
+
+nsresult PresentationService::HandleReconnectRequest(
+    nsIPresentationSessionRequest* aRequest) {
+  nsCOMPtr<nsIPresentationControlChannel> ctrlChannel;
+  nsresult rv = aRequest->GetControlChannel(getter_AddRefs(ctrlChannel));
+  if (NS_WARN_IF(NS_FAILED(rv) || !ctrlChannel)) {
+    return rv;
+  }
+
+  nsAutoString sessionId;
+  rv = aRequest->GetPresentationId(sessionId);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    ctrlChannel->Disconnect(rv);
+    return rv;
+  }
+
+  uint64_t windowId;
+  rv = GetWindowIdBySessionIdInternal(
+      sessionId, nsIPresentationService::ROLE_RECEIVER, &windowId);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    ctrlChannel->Disconnect(rv);
+    return rv;
+  }
+
+  RefPtr<PresentationSessionInfo> info =
+      GetSessionInfo(sessionId, nsIPresentationService::ROLE_RECEIVER);
+  if (NS_WARN_IF(!info)) {
+    // Cannot reconnect non-existed session
+    ctrlChannel->Disconnect(NS_ERROR_DOM_OPERATION_ERR);
+    return NS_ERROR_DOM_ABORT_ERR;
+  }
+
+  nsAutoString url;
+  rv = aRequest->GetUrl(url);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    ctrlChannel->Disconnect(rv);
+    return rv;
+  }
+
+  // Make sure the url is the same as the previous one.
+  if (NS_WARN_IF(!info->GetUrl().Equals(url))) {
+    ctrlChannel->Disconnect(rv);
+    return rv;
+  }
+
+  return HandleSessionRequest(aRequest);
+}
+
+NS_IMETHODIMP
+PresentationService::StartSession(
+    const nsTArray<nsString>& aUrls, const nsAString& aSessionId,
+    const nsAString& aOrigin, const nsAString& aDeviceId, uint64_t aWindowId,
+    EventTarget* aEventTarget, nsIPrincipal* aPrincipal,
+    nsIPresentationServiceCallback* aCallback,
+    nsIPresentationTransportBuilderConstructor* aBuilderConstructor) {
+  PRES_DEBUG("%s:id[%s]\n", __func__, NS_ConvertUTF16toUTF8(aSessionId).get());
+
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aCallback);
+  MOZ_ASSERT(!aSessionId.IsEmpty());
+  MOZ_ASSERT(!aUrls.IsEmpty());
+
+  nsCOMPtr<nsIPresentationDeviceRequest> request =
+      new PresentationDeviceRequest(aUrls, aSessionId, aOrigin, aWindowId,
+                                    aEventTarget, aPrincipal, aCallback,
+                                    aBuilderConstructor);
+
+  if (aDeviceId.IsVoid()) {
+    // Pop up a prompt and ask user to select a device.
+    nsCOMPtr<nsIPresentationDevicePrompt> prompt =
+        do_GetService(PRESENTATION_DEVICE_PROMPT_CONTRACTID);
+    if (NS_WARN_IF(!prompt)) {
+      return aCallback->NotifyError(NS_ERROR_DOM_INVALID_ACCESS_ERR);
+    }
+
+    nsresult rv = prompt->PromptDeviceSelection(request);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return aCallback->NotifyError(NS_ERROR_DOM_OPERATION_ERR);
+    }
+
+    return NS_OK;
+  }
+
+  // Find the designated device from available device list.
+  nsCOMPtr<nsIPresentationDeviceManager> deviceManager =
+      do_GetService(PRESENTATION_DEVICE_MANAGER_CONTRACTID);
+  if (NS_WARN_IF(!deviceManager)) {
+    return aCallback->NotifyError(NS_ERROR_DOM_OPERATION_ERR);
+  }
+
+  nsCOMPtr<nsIArray> presentationUrls;
+  if (NS_WARN_IF(NS_FAILED(
+          ConvertURLArrayHelper(aUrls, getter_AddRefs(presentationUrls))))) {
+    return aCallback->NotifyError(NS_ERROR_DOM_OPERATION_ERR);
+  }
+
+  nsCOMPtr<nsIArray> devices;
+  nsresult rv = deviceManager->GetAvailableDevices(presentationUrls,
+                                                   getter_AddRefs(devices));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return aCallback->NotifyError(NS_ERROR_DOM_OPERATION_ERR);
+  }
+
+  nsCOMPtr<nsISimpleEnumerator> enumerator;
+  rv = devices->Enumerate(getter_AddRefs(enumerator));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return aCallback->NotifyError(NS_ERROR_DOM_OPERATION_ERR);
+  }
+
+  NS_ConvertUTF16toUTF8 utf8DeviceId(aDeviceId);
+  bool hasMore;
+  while (NS_SUCCEEDED(enumerator->HasMoreElements(&hasMore)) && hasMore) {
+    nsCOMPtr<nsISupports> isupports;
+    rv = enumerator->GetNext(getter_AddRefs(isupports));
+
+    nsCOMPtr<nsIPresentationDevice> device(do_QueryInterface(isupports));
+    MOZ_ASSERT(device);
+
+    nsAutoCString id;
+    if (NS_SUCCEEDED(device->GetId(id)) && id.Equals(utf8DeviceId)) {
+      request->Select(device);
+      return NS_OK;
+    }
+  }
+
+  // Reject if designated device is not available.
+  return aCallback->NotifyError(NS_ERROR_DOM_NOT_FOUND_ERR);
+}
+
+already_AddRefed<PresentationSessionInfo>
+PresentationService::CreateControllingSessionInfo(const nsAString& aUrl,
+                                                  const nsAString& aSessionId,
+                                                  uint64_t aWindowId) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (aSessionId.IsEmpty()) {
+    return nullptr;
+  }
+
+  RefPtr<PresentationSessionInfo> info =
+      new PresentationControllingInfo(aUrl, aSessionId);
+
+  mSessionInfoAtController.Put(aSessionId, RefPtr{info});
+  AddRespondingSessionId(aWindowId, aSessionId,
+                         nsIPresentationService::ROLE_CONTROLLER);
+  return info.forget();
+}
+
+NS_IMETHODIMP
+PresentationService::SendSessionMessage(const nsAString& aSessionId,
+                                        uint8_t aRole, const nsAString& aData) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(!aData.IsEmpty());
+  MOZ_ASSERT(!aSessionId.IsEmpty());
+  MOZ_ASSERT(aRole == nsIPresentationService::ROLE_CONTROLLER ||
+             aRole == nsIPresentationService::ROLE_RECEIVER);
+
+  RefPtr<PresentationSessionInfo> info = GetSessionInfo(aSessionId, aRole);
+  if (NS_WARN_IF(!info)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  return info->Send(aData);
+}
+
+NS_IMETHODIMP
+PresentationService::SendSessionBinaryMsg(const nsAString& aSessionId,
+                                          uint8_t aRole,
+                                          const nsACString& aData) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(!aData.IsEmpty());
+  MOZ_ASSERT(!aSessionId.IsEmpty());
+  MOZ_ASSERT(aRole == nsIPresentationService::ROLE_CONTROLLER ||
+             aRole == nsIPresentationService::ROLE_RECEIVER);
+
+  RefPtr<PresentationSessionInfo> info = GetSessionInfo(aSessionId, aRole);
+  if (NS_WARN_IF(!info)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  return info->SendBinaryMsg(aData);
+}
+
+NS_IMETHODIMP
+PresentationService::SendSessionBlob(const nsAString& aSessionId, uint8_t aRole,
+                                     Blob* aBlob) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(!aSessionId.IsEmpty());
+  MOZ_ASSERT(aRole == nsIPresentationService::ROLE_CONTROLLER ||
+             aRole == nsIPresentationService::ROLE_RECEIVER);
+  MOZ_ASSERT(aBlob);
+
+  RefPtr<PresentationSessionInfo> info = GetSessionInfo(aSessionId, aRole);
+  if (NS_WARN_IF(!info)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  return info->SendBlob(aBlob);
+}
+
+NS_IMETHODIMP
+PresentationService::CloseSession(const nsAString& aSessionId, uint8_t aRole,
+                                  uint8_t aClosedReason) {
+  PRES_DEBUG("%s:id[%s], reason[%x], role[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(aSessionId).get(), aClosedReason, aRole);
+
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(!aSessionId.IsEmpty());
+  MOZ_ASSERT(aRole == nsIPresentationService::ROLE_CONTROLLER ||
+             aRole == nsIPresentationService::ROLE_RECEIVER);
+
+  RefPtr<PresentationSessionInfo> info = GetSessionInfo(aSessionId, aRole);
+  if (NS_WARN_IF(!info)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  if (aClosedReason == nsIPresentationService::CLOSED_REASON_WENTAWAY) {
+    // Remove nsIPresentationSessionListener since we don't want to dispatch
+    // PresentationConnectionCloseEvent if the page is went away.
+    info->SetListener(nullptr);
+  }
+
+  return info->Close(NS_OK, nsIPresentationSessionListener::STATE_CLOSED);
+}
+
+NS_IMETHODIMP
+PresentationService::TerminateSession(const nsAString& aSessionId,
+                                      uint8_t aRole) {
+  PRES_DEBUG("%s:id[%s], role[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(aSessionId).get(), aRole);
+
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(!aSessionId.IsEmpty());
+  MOZ_ASSERT(aRole == nsIPresentationService::ROLE_CONTROLLER ||
+             aRole == nsIPresentationService::ROLE_RECEIVER);
+
+  RefPtr<PresentationSessionInfo> info = GetSessionInfo(aSessionId, aRole);
+  if (NS_WARN_IF(!info)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  return info->Close(NS_OK, nsIPresentationSessionListener::STATE_TERMINATED);
+}
+
+NS_IMETHODIMP
+PresentationService::ReconnectSession(
+    const nsTArray<nsString>& aUrls, const nsAString& aSessionId, uint8_t aRole,
+    nsIPresentationServiceCallback* aCallback) {
+  PRES_DEBUG("%s:id[%s]\n", __func__, NS_ConvertUTF16toUTF8(aSessionId).get());
+
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(!aSessionId.IsEmpty());
+  MOZ_ASSERT(aCallback);
+  MOZ_ASSERT(!aUrls.IsEmpty());
+
+  if (aRole != nsIPresentationService::ROLE_CONTROLLER) {
+    MOZ_ASSERT(false, "Only controller can call ReconnectSession.");
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  if (NS_WARN_IF(!aCallback)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  RefPtr<PresentationSessionInfo> info = GetSessionInfo(aSessionId, aRole);
+  if (NS_WARN_IF(!info)) {
+    return aCallback->NotifyError(NS_ERROR_DOM_NOT_FOUND_ERR);
+  }
+
+  if (NS_WARN_IF(!aUrls.Contains(info->GetUrl()))) {
+    return aCallback->NotifyError(NS_ERROR_DOM_NOT_FOUND_ERR);
+  }
+
+  return static_cast<PresentationControllingInfo*>(info.get())
+      ->Reconnect(aCallback);
+}
+
+NS_IMETHODIMP
+PresentationService::BuildTransport(const nsAString& aSessionId,
+                                    uint8_t aRole) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(!aSessionId.IsEmpty());
+
+  if (aRole != nsIPresentationService::ROLE_CONTROLLER) {
+    MOZ_ASSERT(false, "Only controller can call BuildTransport.");
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  RefPtr<PresentationSessionInfo> info = GetSessionInfo(aSessionId, aRole);
+  if (NS_WARN_IF(!info)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  return static_cast<PresentationControllingInfo*>(info.get())
+      ->BuildTransport();
+}
+
+NS_IMETHODIMP
+PresentationService::RegisterAvailabilityListener(
+    const nsTArray<nsString>& aAvailabilityUrls,
+    nsIPresentationAvailabilityListener* aListener) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(!aAvailabilityUrls.IsEmpty());
+  MOZ_ASSERT(aListener);
+
+  mAvailabilityManager.AddAvailabilityListener(aAvailabilityUrls, aListener);
+  return UpdateAvailabilityUrlChange(aAvailabilityUrls);
+}
+
+NS_IMETHODIMP
+PresentationService::UnregisterAvailabilityListener(
+    const nsTArray<nsString>& aAvailabilityUrls,
+    nsIPresentationAvailabilityListener* aListener) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  mAvailabilityManager.RemoveAvailabilityListener(aAvailabilityUrls, aListener);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationService::RegisterSessionListener(
+    const nsAString& aSessionId, uint8_t aRole,
+    nsIPresentationSessionListener* aListener) {
+  PRES_DEBUG("%s:id[%s], role[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(aSessionId).get(), aRole);
+
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aListener);
+  MOZ_ASSERT(aRole == nsIPresentationService::ROLE_CONTROLLER ||
+             aRole == nsIPresentationService::ROLE_RECEIVER);
+
+  RefPtr<PresentationSessionInfo> info = GetSessionInfo(aSessionId, aRole);
+  if (NS_WARN_IF(!info)) {
+    // Notify the listener of TERMINATED since no correspondent session info is
+    // available possibly due to establishment failure. This would be useful at
+    // the receiver side, since a presentation session is created at beginning
+    // and here is the place to realize the underlying establishment fails.
+    nsresult rv = aListener->NotifyStateChange(
+        aSessionId, nsIPresentationSessionListener::STATE_TERMINATED,
+        NS_ERROR_NOT_AVAILABLE);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  return info->SetListener(aListener);
+}
+
+NS_IMETHODIMP
+PresentationService::UnregisterSessionListener(const nsAString& aSessionId,
+                                               uint8_t aRole) {
+  PRES_DEBUG("%s:id[%s], role[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(aSessionId).get(), aRole);
+
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aRole == nsIPresentationService::ROLE_CONTROLLER ||
+             aRole == nsIPresentationService::ROLE_RECEIVER);
+
+  RefPtr<PresentationSessionInfo> info = GetSessionInfo(aSessionId, aRole);
+  if (info) {
+    // When content side decide not handling this session anymore, simply
+    // close the connection. Session info is kept for reconnection.
+    Unused << NS_WARN_IF(NS_FAILED(
+        info->Close(NS_OK, nsIPresentationSessionListener::STATE_CLOSED)));
+    return info->SetListener(nullptr);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationService::RegisterRespondingListener(
+    uint64_t aWindowId, nsIPresentationRespondingListener* aListener) {
+  PRES_DEBUG("%s:windowId[%" PRIu64 "]\n", __func__, aWindowId);
+
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aListener);
+
+  nsCOMPtr<nsIPresentationRespondingListener> listener;
+  if (mRespondingListeners.Get(aWindowId, getter_AddRefs(listener))) {
+    return (listener == aListener) ? NS_OK : NS_ERROR_DOM_INVALID_STATE_ERR;
+  }
+
+  nsTArray<nsString> sessionIdArray;
+  nsresult rv =
+      mReceiverSessionIdManager.GetSessionIds(aWindowId, sessionIdArray);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  for (const auto& id : sessionIdArray) {
+    aListener->NotifySessionConnect(aWindowId, id);
+  }
+
+  mRespondingListeners.Put(aWindowId, RefPtr{aListener});
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationService::UnregisterRespondingListener(uint64_t aWindowId) {
+  PRES_DEBUG("%s:windowId[%" PRIu64 "]\n", __func__, aWindowId);
+
+  MOZ_ASSERT(NS_IsMainThread());
+
+  mRespondingListeners.Remove(aWindowId);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationService::NotifyReceiverReady(
+    const nsAString& aSessionId, uint64_t aWindowId, bool aIsLoading,
+    nsIPresentationTransportBuilderConstructor* aBuilderConstructor) {
+  PRES_DEBUG("%s:id[%s], windowId[%" PRIu64 "], loading[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(aSessionId).get(), aWindowId, aIsLoading);
+
+  RefPtr<PresentationSessionInfo> info =
+      GetSessionInfo(aSessionId, nsIPresentationService::ROLE_RECEIVER);
+  if (NS_WARN_IF(!info)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  AddRespondingSessionId(aWindowId, aSessionId,
+                         nsIPresentationService::ROLE_RECEIVER);
+
+  if (!aIsLoading) {
+    return static_cast<PresentationPresentingInfo*>(info.get())
+        ->NotifyResponderFailure();
+  }
+
+  nsCOMPtr<nsIPresentationRespondingListener> listener;
+  if (mRespondingListeners.Get(aWindowId, getter_AddRefs(listener))) {
+    nsresult rv = listener->NotifySessionConnect(aWindowId, aSessionId);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+  }
+
+  info->SetTransportBuilderConstructor(aBuilderConstructor);
+  return static_cast<PresentationPresentingInfo*>(info.get())
+      ->NotifyResponderReady();
+}
+
+nsresult PresentationService::NotifyTransportClosed(const nsAString& aSessionId,
+                                                    uint8_t aRole,
+                                                    nsresult aReason) {
+  PRES_DEBUG("%s:id[%s], reason[%" PRIx32 "], role[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(aSessionId).get(),
+             static_cast<uint32_t>(aReason), aRole);
+
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(!aSessionId.IsEmpty());
+  MOZ_ASSERT(aRole == nsIPresentationService::ROLE_CONTROLLER ||
+             aRole == nsIPresentationService::ROLE_RECEIVER);
+
+  RefPtr<PresentationSessionInfo> info = GetSessionInfo(aSessionId, aRole);
+  if (NS_WARN_IF(!info)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  return info->NotifyTransportClosed(aReason);
+}
+
+NS_IMETHODIMP
+PresentationService::UntrackSessionInfo(const nsAString& aSessionId,
+                                        uint8_t aRole) {
+  PRES_DEBUG("%s:id[%s], role[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(aSessionId).get(), aRole);
+
+  MOZ_ASSERT(aRole == nsIPresentationService::ROLE_CONTROLLER ||
+             aRole == nsIPresentationService::ROLE_RECEIVER);
+  // Remove the session info.
+  if (nsIPresentationService::ROLE_CONTROLLER == aRole) {
+    mSessionInfoAtController.Remove(aSessionId);
+  } else {
+    // Terminate receiver page.
+    uint64_t windowId;
+    nsresult rv = GetWindowIdBySessionIdInternal(aSessionId, aRole, &windowId);
+    if (NS_SUCCEEDED(rv)) {
+      NS_DispatchToMainThread(NS_NewRunnableFunction(
+          "dom::PresentationService::UntrackSessionInfo", [windowId]() -> void {
+            PRES_DEBUG("Attempt to close window[%" PRIu64 "]\n", windowId);
+
+            if (auto* window =
+                    nsGlobalWindowInner::GetInnerWindowWithId(windowId)) {
+              window->Close();
+            }
+          }));
+    }
+
+    mSessionInfoAtReceiver.Remove(aSessionId);
+  }
+
+  // Remove the in-process responding info if there's still any.
+  RemoveRespondingSessionId(aSessionId, aRole);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationService::GetWindowIdBySessionId(const nsAString& aSessionId,
+                                            uint8_t aRole,
+                                            uint64_t* aWindowId) {
+  return GetWindowIdBySessionIdInternal(aSessionId, aRole, aWindowId);
+}
+
+NS_IMETHODIMP
+PresentationService::UpdateWindowIdBySessionId(const nsAString& aSessionId,
+                                               uint8_t aRole,
+                                               const uint64_t aWindowId) {
+  UpdateWindowIdBySessionIdInternal(aSessionId, aRole, aWindowId);
+  return NS_OK;
+}
+
+bool PresentationService::IsSessionAccessible(const nsAString& aSessionId,
+                                              const uint8_t aRole,
+                                              base::ProcessId aProcessId) {
+  MOZ_ASSERT(aRole == nsIPresentationService::ROLE_CONTROLLER ||
+             aRole == nsIPresentationService::ROLE_RECEIVER);
+  RefPtr<PresentationSessionInfo> info = GetSessionInfo(aSessionId, aRole);
+  if (NS_WARN_IF(!info)) {
+    return false;
+  }
+  return info->IsAccessible(aProcessId);
+}
+
+}  // namespace dom
+}  // namespace mozilla
+
+already_AddRefed<nsIPresentationService> NS_CreatePresentationService() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  nsCOMPtr<nsIPresentationService> service;
+  if (XRE_GetProcessType() == GeckoProcessType_Content) {
+    service = new mozilla::dom::PresentationIPCService();
+  } else {
+    service = new mozilla::dom::PresentationService();
+    if (NS_WARN_IF(
+            !static_cast<mozilla::dom::PresentationService*>(service.get())
+                 ->Init())) {
+      return nullptr;
+    }
+  }
+
+  return service.forget();
+}
diff --git a/dom/presentation/PresentationService.h b/dom/presentation/PresentationService.h
new file mode 100644
index 0000000000..2aadbcb49e
--- /dev/null
+++ b/dom/presentation/PresentationService.h
@@ -0,0 +1,64 @@
+/* -*- 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_PresentationService_h
+#define mozilla_dom_PresentationService_h
+
+#include "nsCOMPtr.h"
+#include "nsIObserver.h"
+#include "PresentationServiceBase.h"
+#include "PresentationSessionInfo.h"
+
+class nsIPresentationSessionRequest;
+class nsIPresentationTerminateRequest;
+class nsIURI;
+class nsIPresentationSessionTransportBuilder;
+
+namespace mozilla {
+namespace dom {
+
+class PresentationDeviceRequest;
+class PresentationRespondingInfo;
+
+class PresentationService final
+    : public nsIPresentationService,
+      public nsIObserver,
+      public PresentationServiceBase<PresentationSessionInfo> {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIOBSERVER
+  NS_DECL_NSIPRESENTATIONSERVICE
+
+  PresentationService();
+  bool Init();
+
+  bool IsSessionAccessible(const nsAString& aSessionId, const uint8_t aRole,
+                           base::ProcessId aProcessId);
+
+ private:
+  friend class PresentationDeviceRequest;
+
+  virtual ~PresentationService();
+  void HandleShutdown();
+  void HandleDeviceAdded(nsIPresentationDevice* aDevice);
+  nsresult HandleDeviceRemoved();
+  nsresult HandleSessionRequest(nsIPresentationSessionRequest* aRequest);
+  nsresult HandleTerminateRequest(nsIPresentationTerminateRequest* aRequest);
+  nsresult HandleReconnectRequest(nsIPresentationSessionRequest* aRequest);
+
+  // This is meant to be called by PresentationDeviceRequest.
+  already_AddRefed<PresentationSessionInfo> CreateControllingSessionInfo(
+      const nsAString& aUrl, const nsAString& aSessionId, uint64_t aWindowId);
+
+  // Emumerate all devices to get the availability of each input Urls.
+  nsresult UpdateAvailabilityUrlChange(
+      const nsTArray<nsString>& aAvailabilityUrls);
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_PresentationService_h
diff --git a/dom/presentation/PresentationServiceBase.h b/dom/presentation/PresentationServiceBase.h
new file mode 100644
index 0000000000..a997d5db89
--- /dev/null
+++ b/dom/presentation/PresentationServiceBase.h
@@ -0,0 +1,356 @@
+/* -*- 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_PresentationServiceBase_h
+#define mozilla_dom_PresentationServiceBase_h
+
+#include "mozilla/Unused.h"
+#include "nsClassHashtable.h"
+#include "nsCOMArray.h"
+#include "nsIPresentationListener.h"
+#include "nsIPresentationService.h"
+#include "nsRefPtrHashtable.h"
+#include "nsString.h"
+#include "nsTArray.h"
+#include "nsDataHashtable.h"
+#include "nsThread.h"
+
+namespace mozilla {
+namespace dom {
+
+template <class T>
+class PresentationServiceBase {
+ public:
+  PresentationServiceBase() = default;
+
+  already_AddRefed<T> GetSessionInfo(const nsAString& aSessionId,
+                                     const uint8_t aRole) {
+    MOZ_ASSERT(aRole == nsIPresentationService::ROLE_CONTROLLER ||
+               aRole == nsIPresentationService::ROLE_RECEIVER);
+
+    RefPtr<T> info;
+    if (aRole == nsIPresentationService::ROLE_CONTROLLER) {
+      return mSessionInfoAtController.Get(aSessionId, getter_AddRefs(info))
+                 ? info.forget()
+                 : nullptr;
+    } else {
+      return mSessionInfoAtReceiver.Get(aSessionId, getter_AddRefs(info))
+                 ? info.forget()
+                 : nullptr;
+    }
+  }
+
+ protected:
+  class SessionIdManager final {
+   public:
+    explicit SessionIdManager() { MOZ_COUNT_CTOR(SessionIdManager); }
+
+    MOZ_COUNTED_DTOR(SessionIdManager)
+
+    nsresult GetWindowId(const nsAString& aSessionId, uint64_t* aWindowId) {
+      MOZ_ASSERT(NS_IsMainThread());
+
+      if (mRespondingWindowIds.Get(aSessionId, aWindowId)) {
+        return NS_OK;
+      }
+      return NS_ERROR_NOT_AVAILABLE;
+    }
+
+    nsresult GetSessionIds(uint64_t aWindowId,
+                           nsTArray<nsString>& aSessionIds) {
+      MOZ_ASSERT(NS_IsMainThread());
+
+      nsTArray<nsString>* sessionIdArray;
+      if (!mRespondingSessionIds.Get(aWindowId, &sessionIdArray)) {
+        return NS_ERROR_INVALID_ARG;
+      }
+
+      aSessionIds.Assign(*sessionIdArray);
+      return NS_OK;
+    }
+
+    void AddSessionId(uint64_t aWindowId, const nsAString& aSessionId) {
+      MOZ_ASSERT(NS_IsMainThread());
+
+      if (NS_WARN_IF(aWindowId == 0)) {
+        return;
+      }
+
+      nsTArray<nsString>* sessionIdArray;
+      if (!mRespondingSessionIds.Get(aWindowId, &sessionIdArray)) {
+        sessionIdArray = new nsTArray<nsString>();
+        mRespondingSessionIds.Put(aWindowId, sessionIdArray);
+      }
+
+      sessionIdArray->AppendElement(nsString(aSessionId));
+      mRespondingWindowIds.Put(aSessionId, aWindowId);
+    }
+
+    void RemoveSessionId(const nsAString& aSessionId) {
+      MOZ_ASSERT(NS_IsMainThread());
+
+      uint64_t windowId = 0;
+      if (mRespondingWindowIds.Get(aSessionId, &windowId)) {
+        mRespondingWindowIds.Remove(aSessionId);
+        nsTArray<nsString>* sessionIdArray;
+        if (mRespondingSessionIds.Get(windowId, &sessionIdArray)) {
+          sessionIdArray->RemoveElement(nsString(aSessionId));
+          if (sessionIdArray->IsEmpty()) {
+            mRespondingSessionIds.Remove(windowId);
+          }
+        }
+      }
+    }
+
+    void UpdateWindowId(const nsAString& aSessionId, const uint64_t aWindowId) {
+      MOZ_ASSERT(NS_IsMainThread());
+
+      RemoveSessionId(aSessionId);
+      AddSessionId(aWindowId, aSessionId);
+    }
+
+    void Clear() {
+      mRespondingSessionIds.Clear();
+      mRespondingWindowIds.Clear();
+    }
+
+   private:
+    nsClassHashtable<nsUint64HashKey, nsTArray<nsString>> mRespondingSessionIds;
+    nsDataHashtable<nsStringHashKey, uint64_t> mRespondingWindowIds;
+  };
+
+  class AvailabilityManager final {
+   public:
+    explicit AvailabilityManager() { MOZ_COUNT_CTOR(AvailabilityManager); }
+
+    MOZ_COUNTED_DTOR(AvailabilityManager)
+
+    void AddAvailabilityListener(
+        const nsTArray<nsString>& aAvailabilityUrls,
+        nsIPresentationAvailabilityListener* aListener) {
+      nsTArray<nsString> dummy;
+      AddAvailabilityListener(aAvailabilityUrls, aListener, dummy);
+    }
+
+    void AddAvailabilityListener(const nsTArray<nsString>& aAvailabilityUrls,
+                                 nsIPresentationAvailabilityListener* aListener,
+                                 nsTArray<nsString>& aAddedUrls) {
+      if (!aListener) {
+        MOZ_ASSERT(false, "aListener should not be null.");
+        return;
+      }
+
+      if (aAvailabilityUrls.IsEmpty()) {
+        MOZ_ASSERT(false, "aAvailabilityUrls should not be empty.");
+        return;
+      }
+
+      aAddedUrls.Clear();
+      nsTArray<nsString> knownAvailableUrls;
+      for (const auto& url : aAvailabilityUrls) {
+        AvailabilityEntry* entry;
+        if (!mAvailabilityUrlTable.Get(url, &entry)) {
+          entry = new AvailabilityEntry();
+          mAvailabilityUrlTable.Put(url, entry);
+          aAddedUrls.AppendElement(url);
+        }
+        if (!entry->mListeners.Contains(aListener)) {
+          entry->mListeners.AppendElement(aListener);
+        }
+        if (entry->mAvailable) {
+          knownAvailableUrls.AppendElement(url);
+        }
+      }
+
+      if (!knownAvailableUrls.IsEmpty()) {
+        Unused << NS_WARN_IF(NS_FAILED(
+            aListener->NotifyAvailableChange(knownAvailableUrls, true)));
+      } else {
+        // If we can't find any known available url and there is no newly
+        // added url, we still need to notify the listener of the result.
+        // So, the promise returned by |getAvailability| can be resolved.
+        if (aAddedUrls.IsEmpty()) {
+          Unused << NS_WARN_IF(NS_FAILED(
+              aListener->NotifyAvailableChange(aAvailabilityUrls, false)));
+        }
+      }
+    }
+
+    void RemoveAvailabilityListener(
+        const nsTArray<nsString>& aAvailabilityUrls,
+        nsIPresentationAvailabilityListener* aListener) {
+      nsTArray<nsString> dummy;
+      RemoveAvailabilityListener(aAvailabilityUrls, aListener, dummy);
+    }
+
+    void RemoveAvailabilityListener(
+        const nsTArray<nsString>& aAvailabilityUrls,
+        nsIPresentationAvailabilityListener* aListener,
+        nsTArray<nsString>& aRemovedUrls) {
+      if (!aListener) {
+        MOZ_ASSERT(false, "aListener should not be null.");
+        return;
+      }
+
+      if (aAvailabilityUrls.IsEmpty()) {
+        MOZ_ASSERT(false, "aAvailabilityUrls should not be empty.");
+        return;
+      }
+
+      aRemovedUrls.Clear();
+      for (const auto& url : aAvailabilityUrls) {
+        AvailabilityEntry* entry;
+        if (mAvailabilityUrlTable.Get(url, &entry)) {
+          entry->mListeners.RemoveElement(aListener);
+          if (entry->mListeners.IsEmpty()) {
+            mAvailabilityUrlTable.Remove(url);
+            aRemovedUrls.AppendElement(url);
+          }
+        }
+      }
+    }
+
+    void DoNotifyAvailableChange(const nsTArray<nsString>& aAvailabilityUrls,
+                                 bool aAvailable) {
+      typedef nsClassHashtable<nsISupportsHashKey, nsTArray<nsString>>
+          ListenerToUrlsMap;
+      ListenerToUrlsMap availabilityListenerTable;
+      // Create a mapping from nsIPresentationAvailabilityListener to
+      // availabilityUrls.
+      for (auto it = mAvailabilityUrlTable.ConstIter(); !it.Done(); it.Next()) {
+        if (aAvailabilityUrls.Contains(it.Key())) {
+          AvailabilityEntry* entry = it.UserData();
+          entry->mAvailable = aAvailable;
+
+          for (uint32_t i = 0; i < entry->mListeners.Length(); ++i) {
+            nsIPresentationAvailabilityListener* listener =
+                entry->mListeners.ObjectAt(i);
+            nsTArray<nsString>* urlArray;
+            if (!availabilityListenerTable.Get(listener, &urlArray)) {
+              urlArray = new nsTArray<nsString>();
+              availabilityListenerTable.Put(listener, urlArray);
+            }
+            urlArray->AppendElement(it.Key());
+          }
+        }
+      }
+
+      for (auto it = availabilityListenerTable.Iter(); !it.Done(); it.Next()) {
+        auto listener =
+            static_cast<nsIPresentationAvailabilityListener*>(it.Key());
+
+        Unused << NS_WARN_IF(NS_FAILED(
+            listener->NotifyAvailableChange(*it.UserData(), aAvailable)));
+      }
+    }
+
+    void GetAvailbilityUrlByAvailability(nsTArray<nsString>& aOutArray,
+                                         bool aAvailable) {
+      aOutArray.Clear();
+
+      for (auto it = mAvailabilityUrlTable.ConstIter(); !it.Done(); it.Next()) {
+        if (it.UserData()->mAvailable == aAvailable) {
+          aOutArray.AppendElement(it.Key());
+        }
+      }
+    }
+
+    void Clear() { mAvailabilityUrlTable.Clear(); }
+
+   private:
+    struct AvailabilityEntry {
+      explicit AvailabilityEntry() : mAvailable(false) {}
+
+      bool mAvailable;
+      nsCOMArray<nsIPresentationAvailabilityListener> mListeners;
+    };
+
+    nsClassHashtable<nsStringHashKey, AvailabilityEntry> mAvailabilityUrlTable;
+  };
+
+  virtual ~PresentationServiceBase() = default;
+
+  void Shutdown() {
+    mRespondingListeners.Clear();
+    mControllerSessionIdManager.Clear();
+    mReceiverSessionIdManager.Clear();
+  }
+
+  nsresult GetWindowIdBySessionIdInternal(const nsAString& aSessionId,
+                                          uint8_t aRole, uint64_t* aWindowId) {
+    MOZ_ASSERT(aRole == nsIPresentationService::ROLE_CONTROLLER ||
+               aRole == nsIPresentationService::ROLE_RECEIVER);
+
+    if (NS_WARN_IF(!aWindowId)) {
+      return NS_ERROR_INVALID_POINTER;
+    }
+
+    if (aRole == nsIPresentationService::ROLE_CONTROLLER) {
+      return mControllerSessionIdManager.GetWindowId(aSessionId, aWindowId);
+    }
+
+    return mReceiverSessionIdManager.GetWindowId(aSessionId, aWindowId);
+  }
+
+  void AddRespondingSessionId(uint64_t aWindowId, const nsAString& aSessionId,
+                              uint8_t aRole) {
+    MOZ_ASSERT(aRole == nsIPresentationService::ROLE_CONTROLLER ||
+               aRole == nsIPresentationService::ROLE_RECEIVER);
+
+    if (aRole == nsIPresentationService::ROLE_CONTROLLER) {
+      mControllerSessionIdManager.AddSessionId(aWindowId, aSessionId);
+    } else {
+      mReceiverSessionIdManager.AddSessionId(aWindowId, aSessionId);
+    }
+  }
+
+  void RemoveRespondingSessionId(const nsAString& aSessionId, uint8_t aRole) {
+    MOZ_ASSERT(aRole == nsIPresentationService::ROLE_CONTROLLER ||
+               aRole == nsIPresentationService::ROLE_RECEIVER);
+
+    if (aRole == nsIPresentationService::ROLE_CONTROLLER) {
+      mControllerSessionIdManager.RemoveSessionId(aSessionId);
+    } else {
+      mReceiverSessionIdManager.RemoveSessionId(aSessionId);
+    }
+  }
+
+  void UpdateWindowIdBySessionIdInternal(const nsAString& aSessionId,
+                                         uint8_t aRole,
+                                         const uint64_t aWindowId) {
+    MOZ_ASSERT(aRole == nsIPresentationService::ROLE_CONTROLLER ||
+               aRole == nsIPresentationService::ROLE_RECEIVER);
+
+    if (aRole == nsIPresentationService::ROLE_CONTROLLER) {
+      mControllerSessionIdManager.UpdateWindowId(aSessionId, aWindowId);
+    } else {
+      mReceiverSessionIdManager.UpdateWindowId(aSessionId, aWindowId);
+    }
+  }
+
+  // Store the responding listener based on the window ID of the (in-process or
+  // OOP) receiver page.
+  nsRefPtrHashtable<nsUint64HashKey, nsIPresentationRespondingListener>
+      mRespondingListeners;
+
+  // Store the mapping between the window ID of the in-process and OOP page and
+  // the ID of the responding session. It's used for both controller and
+  // receiver page to retrieve the correspondent session ID. Besides, also keep
+  // the mapping between the responding session ID and the window ID to help
+  // look up the window ID.
+  SessionIdManager mControllerSessionIdManager;
+  SessionIdManager mReceiverSessionIdManager;
+
+  nsRefPtrHashtable<nsStringHashKey, T> mSessionInfoAtController;
+  nsRefPtrHashtable<nsStringHashKey, T> mSessionInfoAtReceiver;
+
+  AvailabilityManager mAvailabilityManager;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_PresentationServiceBase_h
diff --git a/dom/presentation/PresentationSessionInfo.cpp b/dom/presentation/PresentationSessionInfo.cpp
new file mode 100644
index 0000000000..2db21b31e1
--- /dev/null
+++ b/dom/presentation/PresentationSessionInfo.cpp
@@ -0,0 +1,1536 @@
+/* -*- 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 "PresentationSessionInfo.h"
+
+#include <utility>
+
+#include "PresentationLog.h"
+#include "PresentationService.h"
+#include "mozilla/Logging.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/dom/BrowserParent.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/ElementBinding.h"
+#include "mozilla/dom/HTMLIFrameElementBinding.h"
+#include "nsContentUtils.h"
+#include "nsFrameLoader.h"
+#include "nsFrameLoaderOwner.h"
+#include "nsGlobalWindow.h"
+#include "nsIDocShell.h"
+#include "nsIMutableArray.h"
+#include "nsINetAddr.h"
+#include "nsISocketTransport.h"
+#include "nsISupportsPrimitives.h"
+#include "nsNetCID.h"
+#include "nsQueryObject.h"
+#include "nsServiceManagerUtils.h"
+#include "nsThreadUtils.h"
+
+#ifdef MOZ_WIDGET_ANDROID
+#  include "nsIPresentationNetworkHelper.h"
+#endif  // MOZ_WIDGET_ANDROID
+
+/*
+ * Implementation of PresentationChannelDescription
+ */
+
+namespace mozilla {
+namespace dom {
+
+#ifdef MOZ_WIDGET_ANDROID
+
+namespace {
+
+class PresentationNetworkHelper final
+    : public nsIPresentationNetworkHelperListener {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPRESENTATIONNETWORKHELPERLISTENER
+
+  using Function = nsresult (PresentationControllingInfo::*)(const nsACString&);
+
+  explicit PresentationNetworkHelper(PresentationControllingInfo* aInfo,
+                                     const Function& aFunc);
+
+  nsresult GetWifiIPAddress();
+
+ private:
+  ~PresentationNetworkHelper() = default;
+
+  RefPtr<PresentationControllingInfo> mInfo;
+  Function mFunc;
+};
+
+NS_IMPL_ISUPPORTS(PresentationNetworkHelper,
+                  nsIPresentationNetworkHelperListener)
+
+PresentationNetworkHelper::PresentationNetworkHelper(
+    PresentationControllingInfo* aInfo, const Function& aFunc)
+    : mInfo(aInfo), mFunc(aFunc) {
+  MOZ_ASSERT(aInfo);
+  MOZ_ASSERT(aFunc);
+}
+
+nsresult PresentationNetworkHelper::GetWifiIPAddress() {
+  nsresult rv;
+
+  nsCOMPtr<nsIPresentationNetworkHelper> networkHelper =
+      do_GetService(PRESENTATION_NETWORK_HELPER_CONTRACTID, &rv);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return networkHelper->GetWifiIPAddress(this);
+}
+
+NS_IMETHODIMP
+PresentationNetworkHelper::OnError(const nsACString& aReason) {
+  PRES_ERROR("PresentationNetworkHelper::OnError: %s",
+             nsPromiseFlatCString(aReason).get());
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationNetworkHelper::OnGetWifiIPAddress(const nsACString& aIPAddress) {
+  MOZ_ASSERT(mInfo);
+  MOZ_ASSERT(mFunc);
+
+  NS_DispatchToMainThread(NewRunnableMethod<nsCString>(
+      "dom::PresentationNetworkHelper::OnGetWifiIPAddress", mInfo, mFunc,
+      aIPAddress));
+  return NS_OK;
+}
+
+}  // anonymous namespace
+
+#endif  // MOZ_WIDGET_ANDROID
+
+class TCPPresentationChannelDescription final
+    : public nsIPresentationChannelDescription {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPRESENTATIONCHANNELDESCRIPTION
+
+  TCPPresentationChannelDescription(const nsACString& aAddress, uint16_t aPort)
+      : mAddress(aAddress), mPort(aPort) {}
+
+ private:
+  ~TCPPresentationChannelDescription() = default;
+
+  nsCString mAddress;
+  uint16_t mPort;
+};
+
+NS_IMPL_ISUPPORTS(TCPPresentationChannelDescription,
+                  nsIPresentationChannelDescription)
+
+NS_IMETHODIMP
+TCPPresentationChannelDescription::GetType(uint8_t* aRetVal) {
+  if (NS_WARN_IF(!aRetVal)) {
+    return NS_ERROR_INVALID_POINTER;
+  }
+
+  *aRetVal = nsIPresentationChannelDescription::TYPE_TCP;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TCPPresentationChannelDescription::GetTcpAddress(nsIArray** aRetVal) {
+  if (NS_WARN_IF(!aRetVal)) {
+    return NS_ERROR_INVALID_POINTER;
+  }
+
+  nsCOMPtr<nsIMutableArray> array = do_CreateInstance(NS_ARRAY_CONTRACTID);
+  if (NS_WARN_IF(!array)) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  // TODO bug 1228504 Take all IP addresses in PresentationChannelDescription
+  // into account. And at the first stage Presentation API is only exposed on
+  // Firefox OS where the first IP appears enough for most scenarios.
+  nsCOMPtr<nsISupportsCString> address =
+      do_CreateInstance(NS_SUPPORTS_CSTRING_CONTRACTID);
+  if (NS_WARN_IF(!address)) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+  address->SetData(mAddress);
+
+  array->AppendElement(address);
+  array.forget(aRetVal);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TCPPresentationChannelDescription::GetTcpPort(uint16_t* aRetVal) {
+  if (NS_WARN_IF(!aRetVal)) {
+    return NS_ERROR_INVALID_POINTER;
+  }
+
+  *aRetVal = mPort;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TCPPresentationChannelDescription::GetDataChannelSDP(
+    nsAString& aDataChannelSDP) {
+  aDataChannelSDP.Truncate();
+  return NS_OK;
+}
+
+/*
+ * Implementation of PresentationSessionInfo
+ */
+
+NS_IMPL_ISUPPORTS(PresentationSessionInfo,
+                  nsIPresentationSessionTransportCallback,
+                  nsIPresentationControlChannelListener,
+                  nsIPresentationSessionTransportBuilderListener);
+
+/* virtual */
+nsresult PresentationSessionInfo::Init(
+    nsIPresentationControlChannel* aControlChannel) {
+  SetControlChannel(aControlChannel);
+  return NS_OK;
+}
+
+/* virtual */
+void PresentationSessionInfo::Shutdown(nsresult aReason) {
+  PRES_DEBUG("%s:id[%s], reason[%" PRIx32 "], role[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(mSessionId).get(),
+             static_cast<uint32_t>(aReason), mRole);
+
+  NS_WARNING_ASSERTION(NS_SUCCEEDED(aReason), "bad reason");
+
+  // Close the control channel if any.
+  if (mControlChannel) {
+    Unused << NS_WARN_IF(NS_FAILED(mControlChannel->Disconnect(aReason)));
+  }
+
+  // Close the data transport channel if any.
+  if (mTransport) {
+    // |mIsTransportReady| will be unset once |NotifyTransportClosed| is called.
+    Unused << NS_WARN_IF(NS_FAILED(mTransport->Close(aReason)));
+  }
+
+  mIsResponderReady = false;
+  mIsOnTerminating = false;
+
+  ResetBuilder();
+}
+
+nsresult PresentationSessionInfo::SetListener(
+    nsIPresentationSessionListener* aListener) {
+  mListener = aListener;
+
+  if (mListener) {
+    // Enable data notification for the transport channel if it's available.
+    if (mTransport) {
+      nsresult rv = mTransport->EnableDataNotification();
+      if (NS_WARN_IF(NS_FAILED(rv))) {
+        return rv;
+      }
+    }
+
+    // The transport might become ready, or might become un-ready again, before
+    // the listener has registered. So notify the listener of the state change.
+    return mListener->NotifyStateChange(mSessionId, mState, mReason);
+  }
+
+  return NS_OK;
+}
+
+nsresult PresentationSessionInfo::Send(const nsAString& aData) {
+  if (NS_WARN_IF(!IsSessionReady())) {
+    return NS_ERROR_DOM_INVALID_STATE_ERR;
+  }
+
+  if (NS_WARN_IF(!mTransport)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  return mTransport->Send(aData);
+}
+
+nsresult PresentationSessionInfo::SendBinaryMsg(const nsACString& aData) {
+  if (NS_WARN_IF(!IsSessionReady())) {
+    return NS_ERROR_DOM_INVALID_STATE_ERR;
+  }
+
+  if (NS_WARN_IF(!mTransport)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  return mTransport->SendBinaryMsg(aData);
+}
+
+nsresult PresentationSessionInfo::SendBlob(Blob* aBlob) {
+  if (NS_WARN_IF(!IsSessionReady())) {
+    return NS_ERROR_DOM_INVALID_STATE_ERR;
+  }
+
+  if (NS_WARN_IF(!mTransport)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  return mTransport->SendBlob(aBlob);
+}
+
+nsresult PresentationSessionInfo::Close(nsresult aReason, uint32_t aState) {
+  // Do nothing if session is already terminated.
+  if (nsIPresentationSessionListener::STATE_TERMINATED == mState) {
+    return NS_OK;
+  }
+
+  SetStateWithReason(aState, aReason);
+
+  switch (aState) {
+    case nsIPresentationSessionListener::STATE_CLOSED: {
+      Shutdown(aReason);
+      break;
+    }
+    case nsIPresentationSessionListener::STATE_TERMINATED: {
+      if (!mControlChannel) {
+        nsCOMPtr<nsIPresentationControlChannel> ctrlChannel;
+        nsresult rv =
+            mDevice->EstablishControlChannel(getter_AddRefs(ctrlChannel));
+        if (NS_FAILED(rv)) {
+          Shutdown(rv);
+          return rv;
+        }
+
+        SetControlChannel(ctrlChannel);
+        return rv;
+      }
+
+      ContinueTermination();
+      return NS_OK;
+    }
+  }
+
+  return NS_OK;
+}
+
+void PresentationSessionInfo::OnTerminate(
+    nsIPresentationControlChannel* aControlChannel) {
+  mIsOnTerminating = true;  // Mark for terminating transport channel
+  SetStateWithReason(nsIPresentationSessionListener::STATE_TERMINATED, NS_OK);
+  SetControlChannel(aControlChannel);
+}
+
+nsresult PresentationSessionInfo::ReplySuccess() {
+  SetStateWithReason(nsIPresentationSessionListener::STATE_CONNECTED, NS_OK);
+  return NS_OK;
+}
+
+nsresult PresentationSessionInfo::ReplyError(nsresult aError) {
+  Shutdown(aError);
+
+  // Remove itself since it never succeeds.
+  return UntrackFromService();
+}
+
+/* virtual */
+nsresult PresentationSessionInfo::UntrackFromService() {
+  nsCOMPtr<nsIPresentationService> service =
+      do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+  if (NS_WARN_IF(!service)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+  static_cast<PresentationService*>(service.get())
+      ->UntrackSessionInfo(mSessionId, mRole);
+
+  return NS_OK;
+}
+
+nsPIDOMWindowInner* PresentationSessionInfo::GetWindow() {
+  nsCOMPtr<nsIPresentationService> service =
+      do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+  if (NS_WARN_IF(!service)) {
+    return nullptr;
+  }
+  uint64_t windowId = 0;
+  if (NS_WARN_IF(NS_FAILED(
+          service->GetWindowIdBySessionId(mSessionId, mRole, &windowId)))) {
+    return nullptr;
+  }
+
+  return nsGlobalWindowInner::GetInnerWindowWithId(windowId);
+}
+
+/* virtual */
+bool PresentationSessionInfo::IsAccessible(base::ProcessId aProcessId) {
+  // No restriction by default.
+  return true;
+}
+
+void PresentationSessionInfo::ContinueTermination() {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(mControlChannel);
+
+  if (NS_WARN_IF(NS_FAILED(mControlChannel->Terminate(mSessionId))) ||
+      mIsOnTerminating) {
+    Shutdown(NS_OK);
+  }
+}
+
+// nsIPresentationSessionTransportCallback
+NS_IMETHODIMP
+PresentationSessionInfo::NotifyTransportReady() {
+  PRES_DEBUG("%s:id[%s], role[%d], state[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(mSessionId).get(), mRole, mState);
+
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (mState != nsIPresentationSessionListener::STATE_CONNECTING &&
+      mState != nsIPresentationSessionListener::STATE_CONNECTED) {
+    return NS_OK;
+  }
+
+  mIsTransportReady = true;
+
+  // Established RTCDataChannel implies responder is ready.
+  if (mTransportType == nsIPresentationChannelDescription::TYPE_DATACHANNEL) {
+    mIsResponderReady = true;
+  }
+
+  // At sender side, session might not be ready at this point (waiting for
+  // receiver's answer). Yet at receiver side, session must be ready at this
+  // point since the data transport channel is created after the receiver page
+  // is ready for presentation use.
+  if (IsSessionReady()) {
+    return ReplySuccess();
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationSessionInfo::NotifyTransportClosed(nsresult aReason) {
+  PRES_DEBUG("%s:id[%s], reason[%" PRIx32 "], role[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(mSessionId).get(),
+             static_cast<uint32_t>(aReason), mRole);
+
+  MOZ_ASSERT(NS_IsMainThread());
+
+  // Nullify |mTransport| here so it won't try to re-close |mTransport| in
+  // potential subsequent |Shutdown| calls.
+  mTransport = nullptr;
+
+  if (NS_WARN_IF(!IsSessionReady() &&
+                 mState == nsIPresentationSessionListener::STATE_CONNECTING)) {
+    // It happens before the session is ready. Reply the callback.
+    return ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+  }
+
+  // Unset |mIsTransportReady| here so it won't affect |IsSessionReady()| above.
+  mIsTransportReady = false;
+
+  if (mState == nsIPresentationSessionListener::STATE_CONNECTED) {
+    // The transport channel is closed unexpectedly (not caused by a |Close|
+    // call).
+    SetStateWithReason(nsIPresentationSessionListener::STATE_CLOSED, aReason);
+  }
+
+  Shutdown(aReason);
+
+  if (mState == nsIPresentationSessionListener::STATE_TERMINATED) {
+    // Directly untrack the session info from the service.
+    return UntrackFromService();
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationSessionInfo::NotifyData(const nsACString& aData, bool aIsBinary) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (NS_WARN_IF(!IsSessionReady())) {
+    return NS_ERROR_DOM_INVALID_STATE_ERR;
+  }
+
+  if (NS_WARN_IF(!mListener)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  return mListener->NotifyMessage(mSessionId, aData, aIsBinary);
+}
+
+// nsIPresentationSessionTransportBuilderListener
+NS_IMETHODIMP
+PresentationSessionInfo::OnSessionTransport(
+    nsIPresentationSessionTransport* aTransport) {
+  PRES_DEBUG("%s:id[%s], role[%d], state[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(mSessionId).get(), mRole, mState);
+
+  ResetBuilder();
+
+  if (mState != nsIPresentationSessionListener::STATE_CONNECTING) {
+    return NS_ERROR_FAILURE;
+  }
+
+  if (NS_WARN_IF(!aTransport)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  mTransport = aTransport;
+
+  nsresult rv = mTransport->SetCallback(this);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  if (mListener) {
+    mTransport->EnableDataNotification();
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationSessionInfo::OnError(nsresult aReason) {
+  PRES_DEBUG("%s:id[%s], reason[%" PRIx32 "], role[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(mSessionId).get(),
+             static_cast<uint32_t>(aReason), mRole);
+
+  ResetBuilder();
+  return ReplyError(aReason);
+}
+
+NS_IMETHODIMP
+PresentationSessionInfo::SendOffer(nsIPresentationChannelDescription* aOffer) {
+  return mControlChannel->SendOffer(aOffer);
+}
+
+NS_IMETHODIMP
+PresentationSessionInfo::SendAnswer(
+    nsIPresentationChannelDescription* aAnswer) {
+  return mControlChannel->SendAnswer(aAnswer);
+}
+
+NS_IMETHODIMP
+PresentationSessionInfo::SendIceCandidate(const nsAString& candidate) {
+  return mControlChannel->SendIceCandidate(candidate);
+}
+
+NS_IMETHODIMP
+PresentationSessionInfo::Close(nsresult reason) {
+  return mControlChannel->Disconnect(reason);
+}
+
+/**
+ * Implementation of PresentationControllingInfo
+ *
+ * During presentation session establishment, the sender expects the following
+ * after trying to establish the control channel: (The order between step 3 and
+ * 4 is not guaranteed.)
+ * 1. |Init| is called to open a socket |mServerSocket| for data transport
+ *    channel.
+ * 2. |NotifyConnected| of |nsIPresentationControlChannelListener| is called to
+ *    indicate the control channel is ready to use. Then send the offer to the
+ *    receiver via the control channel.
+ * 3.1 |OnSocketAccepted| of |nsIServerSocketListener| is called to indicate the
+ *     data transport channel is connected. Then initialize |mTransport|.
+ * 3.2 |NotifyTransportReady| of |nsIPresentationSessionTransportCallback| is
+ *     called.
+ * 4. |OnAnswer| of |nsIPresentationControlChannelListener| is called to
+ *    indicate the receiver is ready. Close the control channel since it's no
+ *    longer needed.
+ * 5. Once both step 3 and 4 are done, the presentation session is ready to use.
+ *    So notify the listener of CONNECTED state.
+ */
+
+NS_IMPL_ISUPPORTS_INHERITED(PresentationControllingInfo,
+                            PresentationSessionInfo, nsIServerSocketListener)
+
+nsresult PresentationControllingInfo::Init(
+    nsIPresentationControlChannel* aControlChannel) {
+  PresentationSessionInfo::Init(aControlChannel);
+
+  // Initialize |mServerSocket| for bootstrapping the data transport channel and
+  // use |this| as the listener.
+  mServerSocket = do_CreateInstance(NS_SERVERSOCKET_CONTRACTID);
+  if (NS_WARN_IF(!mServerSocket)) {
+    return ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+  }
+
+  nsresult rv = mServerSocket->Init(-1, false, -1);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = mServerSocket->AsyncListen(this);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  int32_t port;
+  rv = mServerSocket->GetPort(&port);
+  if (!NS_WARN_IF(NS_FAILED(rv))) {
+    PRES_DEBUG("%s:ServerSocket created.port[%d]\n", __func__, port);
+  }
+
+  return NS_OK;
+}
+
+void PresentationControllingInfo::Shutdown(nsresult aReason) {
+  PresentationSessionInfo::Shutdown(aReason);
+
+  // Close the server socket if any.
+  if (mServerSocket) {
+    Unused << NS_WARN_IF(NS_FAILED(mServerSocket->Close()));
+    mServerSocket = nullptr;
+  }
+}
+
+nsresult PresentationControllingInfo::GetAddress() {
+  if (nsContentUtils::ShouldResistFingerprinting()) {
+    return NS_ERROR_FAILURE;
+  }
+
+#if defined(MOZ_WIDGET_ANDROID)
+  RefPtr<PresentationNetworkHelper> networkHelper =
+      new PresentationNetworkHelper(this,
+                                    &PresentationControllingInfo::OnGetAddress);
+  nsresult rv = networkHelper->GetWifiIPAddress();
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+#else
+  nsCOMPtr<nsINetworkInfoService> networkInfo =
+      do_GetService(NETWORKINFOSERVICE_CONTRACT_ID);
+  MOZ_ASSERT(networkInfo);
+
+  nsresult rv = networkInfo->ListNetworkAddresses(this);
+
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+#endif
+
+  return NS_OK;
+}
+
+nsresult PresentationControllingInfo::OnGetAddress(const nsACString& aAddress) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (NS_WARN_IF(!mServerSocket)) {
+    return NS_ERROR_FAILURE;
+  }
+  if (NS_WARN_IF(!mControlChannel)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  // Prepare and send the offer.
+  int32_t port;
+  nsresult rv = mServerSocket->GetPort(&port);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  RefPtr<TCPPresentationChannelDescription> description =
+      new TCPPresentationChannelDescription(aAddress,
+                                            static_cast<uint16_t>(port));
+  return mControlChannel->SendOffer(description);
+}
+
+// nsIPresentationControlChannelListener
+NS_IMETHODIMP
+PresentationControllingInfo::OnIceCandidate(const nsAString& aCandidate) {
+  if (mTransportType != nsIPresentationChannelDescription::TYPE_DATACHANNEL) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIPresentationDataChannelSessionTransportBuilder> builder =
+      do_QueryInterface(mBuilder);
+
+  if (NS_WARN_IF(!builder)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  return builder->OnIceCandidate(aCandidate);
+}
+
+NS_IMETHODIMP
+PresentationControllingInfo::OnOffer(
+    nsIPresentationChannelDescription* aDescription) {
+  MOZ_ASSERT(false, "Sender side should not receive offer.");
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+PresentationControllingInfo::OnAnswer(
+    nsIPresentationChannelDescription* aDescription) {
+  if (mTransportType == nsIPresentationChannelDescription::TYPE_DATACHANNEL) {
+    nsCOMPtr<nsIPresentationDataChannelSessionTransportBuilder> builder =
+        do_QueryInterface(mBuilder);
+
+    if (NS_WARN_IF(!builder)) {
+      return NS_ERROR_FAILURE;
+    }
+
+    return builder->OnAnswer(aDescription);
+  }
+
+  mIsResponderReady = true;
+
+  // Close the control channel since it's no longer needed.
+  nsresult rv = mControlChannel->Disconnect(NS_OK);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+  }
+
+  // Session might not be ready at this moment (waiting for the establishment of
+  // the data transport channel).
+  if (IsSessionReady()) {
+    return ReplySuccess();
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationControllingInfo::NotifyConnected() {
+  PRES_DEBUG("%s:id[%s], role[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(mSessionId).get(), mRole);
+
+  MOZ_ASSERT(NS_IsMainThread());
+
+  switch (mState) {
+    case nsIPresentationSessionListener::STATE_CONNECTING: {
+      if (mIsReconnecting) {
+        return ContinueReconnect();
+      }
+
+      nsresult rv = mControlChannel->Launch(GetSessionId(), GetUrl());
+      if (NS_WARN_IF(NS_FAILED(rv))) {
+        return rv;
+      }
+      Unused << NS_WARN_IF(NS_FAILED(BuildTransport()));
+      break;
+    }
+    case nsIPresentationSessionListener::STATE_TERMINATED: {
+      ContinueTermination();
+      break;
+    }
+    default:
+      break;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationControllingInfo::NotifyReconnected() {
+  PRES_DEBUG("%s:id[%s], role[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(mSessionId).get(), mRole);
+
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (NS_WARN_IF(mState != nsIPresentationSessionListener::STATE_CONNECTING)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  return NotifyReconnectResult(NS_OK);
+}
+
+nsresult PresentationControllingInfo::BuildTransport() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (mState != nsIPresentationSessionListener::STATE_CONNECTING) {
+    return NS_OK;
+  }
+
+  if (NS_WARN_IF(!mBuilderConstructor)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  if (!Preferences::GetBool(
+          "dom.presentation.session_transport.data_channel.enable")) {
+    // Build TCP session transport
+    return GetAddress();
+  }
+  /**
+   * Generally transport is maintained by the chrome process. However, data
+   * channel should be live with the DOM , which implies RTCDataChannel in an
+   * OOP page should be establish in the content process.
+   *
+   * |mBuilderConstructor| is responsible for creating a builder, which is for
+   * building a data channel transport.
+   *
+   * In the OOP case, |mBuilderConstructor| would create a builder which is
+   * an object of |PresentationBuilderParent|. So, |BuildDataChannelTransport|
+   * triggers an IPC call to make content process establish a RTCDataChannel
+   * transport.
+   */
+
+  mTransportType = nsIPresentationChannelDescription::TYPE_DATACHANNEL;
+  if (NS_WARN_IF(NS_FAILED(mBuilderConstructor->CreateTransportBuilder(
+          mTransportType, getter_AddRefs(mBuilder))))) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  nsCOMPtr<nsIPresentationDataChannelSessionTransportBuilder>
+      dataChannelBuilder(do_QueryInterface(mBuilder));
+  if (NS_WARN_IF(!dataChannelBuilder)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  // OOP window would be set from content process
+  nsPIDOMWindowInner* window = GetWindow();
+
+  nsresult rv = dataChannelBuilder->BuildDataChannelTransport(
+      nsIPresentationService::ROLE_CONTROLLER, window, this);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationControllingInfo::NotifyDisconnected(nsresult aReason) {
+  PRES_DEBUG("%s:id[%s], reason[%" PRIx32 "], role[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(mSessionId).get(),
+             static_cast<uint32_t>(aReason), mRole);
+
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (mTransportType == nsIPresentationChannelDescription::TYPE_DATACHANNEL) {
+    nsCOMPtr<nsIPresentationDataChannelSessionTransportBuilder> builder =
+        do_QueryInterface(mBuilder);
+    if (builder) {
+      Unused << NS_WARN_IF(NS_FAILED(builder->NotifyDisconnected(aReason)));
+    }
+  }
+
+  // Unset control channel here so it won't try to re-close it in potential
+  // subsequent |Shutdown| calls.
+  SetControlChannel(nullptr);
+
+  if (NS_WARN_IF(NS_FAILED(aReason) || !mIsResponderReady)) {
+    // The presentation session instance may already exist.
+    // Change the state to CLOSED if it is not terminated.
+    if (nsIPresentationSessionListener::STATE_TERMINATED != mState) {
+      SetStateWithReason(nsIPresentationSessionListener::STATE_CLOSED, aReason);
+    }
+
+    // If |aReason| is NS_OK, it implies that the user closes the connection
+    // before becomming connected. No need to call |ReplyError| in this case.
+    if (NS_FAILED(aReason)) {
+      if (mIsReconnecting) {
+        NotifyReconnectResult(NS_ERROR_DOM_OPERATION_ERR);
+      }
+      // Reply error for an abnormal close.
+      return ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+    }
+    Shutdown(aReason);
+  }
+
+  // This is the case for reconnecting a connection which is in
+  // connecting state and |mTransport| is not ready.
+  if (mDoReconnectAfterClose && !mTransport) {
+    mDoReconnectAfterClose = false;
+    return Reconnect(mReconnectCallback);
+  }
+
+  return NS_OK;
+}
+
+// nsIServerSocketListener
+NS_IMETHODIMP
+PresentationControllingInfo::OnSocketAccepted(nsIServerSocket* aServerSocket,
+                                              nsISocketTransport* aTransport) {
+  int32_t port;
+  nsresult rv = aTransport->GetPort(&port);
+  if (!NS_WARN_IF(NS_FAILED(rv))) {
+    PRES_DEBUG("%s:receive from port[%d]\n", __func__, port);
+  }
+
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (NS_WARN_IF(!mBuilderConstructor)) {
+    return ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+  }
+
+  // Initialize session transport builder and use |this| as the callback.
+  nsCOMPtr<nsIPresentationTCPSessionTransportBuilder> builder;
+  if (NS_SUCCEEDED(mBuilderConstructor->CreateTransportBuilder(
+          nsIPresentationChannelDescription::TYPE_TCP,
+          getter_AddRefs(mBuilder)))) {
+    builder = do_QueryInterface(mBuilder);
+  }
+
+  if (NS_WARN_IF(!builder)) {
+    return ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+  }
+
+  mTransportType = nsIPresentationChannelDescription::TYPE_TCP;
+  return builder->BuildTCPSenderTransport(aTransport, this);
+}
+
+NS_IMETHODIMP
+PresentationControllingInfo::OnStopListening(nsIServerSocket* aServerSocket,
+                                             nsresult aStatus) {
+  PRES_DEBUG("controller %s:status[%" PRIx32 "]\n", __func__,
+             static_cast<uint32_t>(aStatus));
+
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (aStatus ==
+      NS_BINDING_ABORTED) {  // The server socket was manually closed.
+    return NS_OK;
+  }
+
+  Shutdown(aStatus);
+
+  if (NS_WARN_IF(!IsSessionReady())) {
+    // It happens before the session is ready. Reply the callback.
+    return ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+  }
+
+  // It happens after the session is ready. Change the state to CLOSED.
+  SetStateWithReason(nsIPresentationSessionListener::STATE_CLOSED, aStatus);
+
+  return NS_OK;
+}
+
+/**
+ * The steps to reconnect a session are summarized below:
+ * 1. Change |mState| to CONNECTING.
+ * 2. Check whether |mControlChannel| is existed or not. Usually we have to
+ *    create a new control cahnnel.
+ * 3.1 |mControlChannel| is null, which means we have to create a new one.
+ *     |EstablishControlChannel| is called to create a new control channel.
+ *     At this point, |mControlChannel| is not able to use yet. Set
+ *     |mIsReconnecting| to true and wait until |NotifyConnected|.
+ * 3.2 |mControlChannel| is not null and is avaliable.
+ *     We can just call |ContinueReconnect| to send reconnect command.
+ * 4. |NotifyReconnected| of |nsIPresentationControlChannelListener| is called
+ *    to indicate the receiver is ready for reconnecting.
+ * 5. Once both step 3 and 4 are done, the rest is to build a new data
+ *    transport channel by following the same steps as starting a
+ *    new session.
+ */
+
+nsresult PresentationControllingInfo::Reconnect(
+    nsIPresentationServiceCallback* aCallback) {
+  PRES_DEBUG("%s:id[%s], role[%d], state[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(mSessionId).get(), mRole, mState);
+
+  if (!aCallback) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  mReconnectCallback = aCallback;
+
+  if (NS_WARN_IF(mState == nsIPresentationSessionListener::STATE_TERMINATED)) {
+    return NotifyReconnectResult(NS_ERROR_DOM_INVALID_STATE_ERR);
+  }
+
+  // If |mState| is not CLOSED, we have to close the connection before
+  // reconnecting. The process to reconnect will be continued after
+  // |NotifyDisconnected| or |NotifyTransportClosed| is invoked.
+  if (mState == nsIPresentationSessionListener::STATE_CONNECTING ||
+      mState == nsIPresentationSessionListener::STATE_CONNECTED) {
+    mDoReconnectAfterClose = true;
+    return Close(NS_OK, nsIPresentationSessionListener::STATE_CLOSED);
+  }
+
+  // Make sure |mState| is closed at this point.
+  MOZ_ASSERT(mState == nsIPresentationSessionListener::STATE_CLOSED);
+
+  mState = nsIPresentationSessionListener::STATE_CONNECTING;
+  mIsReconnecting = true;
+
+  nsresult rv = NS_OK;
+  if (!mControlChannel) {
+    nsCOMPtr<nsIPresentationControlChannel> ctrlChannel;
+    rv = mDevice->EstablishControlChannel(getter_AddRefs(ctrlChannel));
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return NotifyReconnectResult(NS_ERROR_DOM_OPERATION_ERR);
+    }
+
+    rv = Init(ctrlChannel);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return NotifyReconnectResult(NS_ERROR_DOM_OPERATION_ERR);
+    }
+  } else {
+    return ContinueReconnect();
+  }
+
+  return NS_OK;
+}
+
+nsresult PresentationControllingInfo::ContinueReconnect() {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(mControlChannel);
+
+  mIsReconnecting = false;
+  if (NS_WARN_IF(NS_FAILED(mControlChannel->Reconnect(mSessionId, GetUrl())))) {
+    return NotifyReconnectResult(NS_ERROR_DOM_OPERATION_ERR);
+  }
+
+  return NS_OK;
+}
+
+// nsIListNetworkAddressesListener
+NS_IMETHODIMP
+PresentationControllingInfo::OnListedNetworkAddresses(
+    const nsTArray<nsCString>& aAddressArray) {
+  if (aAddressArray.IsEmpty()) {
+    return OnListNetworkAddressesFailed();
+  }
+
+  // TODO bug 1228504 Take all IP addresses in PresentationChannelDescription
+  // into account.
+
+  // On Firefox desktop, the IP address is retrieved from a callback function.
+  // To make consistent code sequence, following function call is dispatched
+  // into main thread instead of calling it directly.
+  NS_DispatchToMainThread(NewRunnableMethod<nsCString>(
+      "dom::PresentationControllingInfo::OnGetAddress", this,
+      &PresentationControllingInfo::OnGetAddress, aAddressArray[0]));
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationControllingInfo::OnListNetworkAddressesFailed() {
+  PRES_ERROR("PresentationControllingInfo:OnListNetworkAddressesFailed");
+
+  // In 1-UA case, transport channel can still be established
+  // on loopback interface even if no network address available.
+  NS_DispatchToMainThread(NewRunnableMethod<nsCString>(
+      "dom::PresentationControllingInfo::OnGetAddress", this,
+      &PresentationControllingInfo::OnGetAddress, "127.0.0.1"));
+
+  return NS_OK;
+}
+
+nsresult PresentationControllingInfo::NotifyReconnectResult(nsresult aStatus) {
+  if (!mReconnectCallback) {
+    MOZ_ASSERT(false, "mReconnectCallback can not be null here.");
+    return NS_ERROR_FAILURE;
+  }
+
+  mIsReconnecting = false;
+  nsCOMPtr<nsIPresentationServiceCallback> callback =
+      std::move(mReconnectCallback);
+  if (NS_FAILED(aStatus)) {
+    return callback->NotifyError(aStatus);
+  }
+
+  return callback->NotifySuccess(GetUrl());
+}
+
+// nsIPresentationSessionTransportCallback
+NS_IMETHODIMP
+PresentationControllingInfo::NotifyTransportReady() {
+  return PresentationSessionInfo::NotifyTransportReady();
+}
+
+NS_IMETHODIMP
+PresentationControllingInfo::NotifyTransportClosed(nsresult aReason) {
+  if (!mDoReconnectAfterClose) {
+    return PresentationSessionInfo::NotifyTransportClosed(aReason);
+    ;
+  }
+
+  MOZ_ASSERT(mState == nsIPresentationSessionListener::STATE_CLOSED);
+
+  mTransport = nullptr;
+  mIsTransportReady = false;
+  mDoReconnectAfterClose = false;
+  return Reconnect(mReconnectCallback);
+}
+
+NS_IMETHODIMP
+PresentationControllingInfo::NotifyData(const nsACString& aData,
+                                        bool aIsBinary) {
+  return PresentationSessionInfo::NotifyData(aData, aIsBinary);
+}
+
+/**
+ * Implementation of PresentationPresentingInfo
+ *
+ * During presentation session establishment, the receiver expects the following
+ * after trying to launch the app by notifying "presentation-launch-receiver":
+ * (The order between step 2 and 3 is not guaranteed.)
+ * 1. |Observe| of |nsIObserver| is called with
+ *    "presentation-receiver-launched".
+ *    Then start listen to document |STATE_TRANSFERRING| event.
+ * 2. |NotifyResponderReady| is called to indicate the receiver page is ready
+ *    for presentation use.
+ * 3. |OnOffer| of |nsIPresentationControlChannelListener| is called.
+ * 4. Once both step 2 and 3 are done, establish the data transport channel and
+ *    send the answer. (The control channel will be closed by the sender once it
+ *    receives the answer.)
+ * 5. |NotifyTransportReady| of |nsIPresentationSessionTransportCallback| is
+ *    called. The presentation session is ready to use, so notify the listener
+ *    of CONNECTED state.
+ */
+
+NS_IMPL_ISUPPORTS_INHERITED(PresentationPresentingInfo, PresentationSessionInfo,
+                            nsITimerCallback, nsINamed)
+
+nsresult PresentationPresentingInfo::Init(
+    nsIPresentationControlChannel* aControlChannel) {
+  PresentationSessionInfo::Init(aControlChannel);
+
+  // Add a timer to prevent waiting indefinitely in case the receiver page fails
+  // to become ready.
+  nsresult rv;
+  int32_t timeout =
+      Preferences::GetInt("presentation.receiver.loading.timeout", 10000);
+  rv = NS_NewTimerWithCallback(getter_AddRefs(mTimer), this, timeout,
+                               nsITimer::TYPE_ONE_SHOT);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+void PresentationPresentingInfo::Shutdown(nsresult aReason) {
+  PresentationSessionInfo::Shutdown(aReason);
+
+  if (mTimer) {
+    mTimer->Cancel();
+  }
+
+  mLoadingCallback = nullptr;
+  mRequesterDescription = nullptr;
+  mPendingCandidates.Clear();
+  mPromise = nullptr;
+  mHasFlushPendingEvents = false;
+}
+
+// nsIPresentationSessionTransportBuilderListener
+NS_IMETHODIMP
+PresentationPresentingInfo::OnSessionTransport(
+    nsIPresentationSessionTransport* aTransport) {
+  nsresult rv = PresentationSessionInfo::OnSessionTransport(aTransport);
+
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // The session transport is managed by content process
+  if (NS_WARN_IF(!aTransport)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  // send answer for TCP session transport
+  if (mTransportType == nsIPresentationChannelDescription::TYPE_TCP) {
+    // Prepare and send the answer.
+    // In the current implementation of |PresentationSessionTransport|,
+    // |GetSelfAddress| cannot return the real info when it's initialized via
+    // |buildTCPReceiverTransport|. Yet this deficiency only affects the channel
+    // description for the answer, which is not actually checked at requester
+    // side.
+    nsCOMPtr<nsINetAddr> selfAddr;
+    rv = mTransport->GetSelfAddress(getter_AddRefs(selfAddr));
+    NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "GetSelfAddress failed");
+
+    nsCString address;
+    uint16_t port = 0;
+    if (NS_SUCCEEDED(rv)) {
+      selfAddr->GetAddress(address);
+      selfAddr->GetPort(&port);
+    }
+    nsCOMPtr<nsIPresentationChannelDescription> description =
+        new TCPPresentationChannelDescription(address, port);
+
+    return mControlChannel->SendAnswer(description);
+  }
+
+  return NS_OK;
+}
+
+// Delegate the pending offer and ICE candidates to builder.
+NS_IMETHODIMP
+PresentationPresentingInfo::FlushPendingEvents(
+    nsIPresentationDataChannelSessionTransportBuilder* builder) {
+  if (NS_WARN_IF(!builder)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  mHasFlushPendingEvents = true;
+
+  if (mRequesterDescription) {
+    builder->OnOffer(mRequesterDescription);
+  }
+  mRequesterDescription = nullptr;
+
+  for (size_t i = 0; i < mPendingCandidates.Length(); ++i) {
+    builder->OnIceCandidate(mPendingCandidates[i]);
+  }
+  mPendingCandidates.Clear();
+  return NS_OK;
+}
+
+nsresult PresentationPresentingInfo::InitTransportAndSendAnswer() {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(mState == nsIPresentationSessionListener::STATE_CONNECTING);
+
+  uint8_t type = 0;
+  nsresult rv = mRequesterDescription->GetType(&type);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  if (NS_WARN_IF(!mBuilderConstructor)) {
+    return ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+  }
+
+  if (NS_WARN_IF(NS_FAILED(mBuilderConstructor->CreateTransportBuilder(
+          type, getter_AddRefs(mBuilder))))) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  if (type == nsIPresentationChannelDescription::TYPE_TCP) {
+    // Establish a data transport channel |mTransport| to the sender and use
+    // |this| as the callback.
+    nsCOMPtr<nsIPresentationTCPSessionTransportBuilder> builder =
+        do_QueryInterface(mBuilder);
+    if (NS_WARN_IF(!builder)) {
+      return NS_ERROR_NOT_AVAILABLE;
+    }
+
+    mTransportType = nsIPresentationChannelDescription::TYPE_TCP;
+    return builder->BuildTCPReceiverTransport(mRequesterDescription, this);
+  }
+
+  if (type == nsIPresentationChannelDescription::TYPE_DATACHANNEL) {
+    if (!Preferences::GetBool(
+            "dom.presentation.session_transport.data_channel.enable")) {
+      return NS_ERROR_NOT_IMPLEMENTED;
+    }
+    /**
+     * Generally transport is maintained by the chrome process. However, data
+     * channel should be live with the DOM , which implies RTCDataChannel in an
+     * OOP page should be establish in the content process.
+     *
+     * |mBuilderConstructor| is responsible for creating a builder, which is for
+     * building a data channel transport.
+     *
+     * In the OOP case, |mBuilderConstructor| would create a builder which is
+     * an object of |PresentationBuilderParent|. So, |BuildDataChannelTransport|
+     * triggers an IPC call to make content process establish a RTCDataChannel
+     * transport.
+     */
+
+    mTransportType = nsIPresentationChannelDescription::TYPE_DATACHANNEL;
+
+    nsCOMPtr<nsIPresentationDataChannelSessionTransportBuilder>
+        dataChannelBuilder = do_QueryInterface(mBuilder);
+    if (NS_WARN_IF(!dataChannelBuilder)) {
+      return NS_ERROR_NOT_AVAILABLE;
+    }
+
+    nsPIDOMWindowInner* window = GetWindow();
+
+    rv = dataChannelBuilder->BuildDataChannelTransport(
+        nsIPresentationService::ROLE_RECEIVER, window, this);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    rv = FlushPendingEvents(dataChannelBuilder);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return rv;
+    }
+
+    return NS_OK;
+  }
+
+  MOZ_ASSERT(false, "Unknown nsIPresentationChannelDescription type!");
+  return NS_ERROR_UNEXPECTED;
+}
+
+nsresult PresentationPresentingInfo::UntrackFromService() {
+  // Remove the OOP responding info (if it has never been used).
+  if (mContentParent) {
+    Unused << NS_WARN_IF(
+        !static_cast<ContentParent*>(mContentParent.get())
+             ->SendNotifyPresentationReceiverCleanUp(mSessionId));
+  }
+
+  // Receiver device might need clean up after session termination.
+  if (mDevice) {
+    mDevice->Disconnect();
+  }
+  mDevice = nullptr;
+
+  // Remove the session info (and the in-process responding info if there's
+  // any).
+  nsCOMPtr<nsIPresentationService> service =
+      do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+  if (NS_WARN_IF(!service)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+  static_cast<PresentationService*>(service.get())
+      ->UntrackSessionInfo(mSessionId, mRole);
+
+  return NS_OK;
+}
+
+bool PresentationPresentingInfo::IsAccessible(base::ProcessId aProcessId) {
+  // Only the specific content process should access the responder info.
+  return (mContentParent)
+             ? aProcessId ==
+                   static_cast<ContentParent*>(mContentParent.get())->OtherPid()
+             : false;
+}
+
+nsresult PresentationPresentingInfo::NotifyResponderReady() {
+  PRES_DEBUG("%s:id[%s], role[%d], state[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(mSessionId).get(), mRole, mState);
+
+  if (mTimer) {
+    mTimer->Cancel();
+    mTimer = nullptr;
+  }
+
+  mIsResponderReady = true;
+
+  // Initialize |mTransport| and send the answer to the sender if sender's
+  // description is already offered.
+  if (mRequesterDescription) {
+    nsresult rv = InitTransportAndSendAnswer();
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+    }
+  }
+
+  return NS_OK;
+}
+
+nsresult PresentationPresentingInfo::NotifyResponderFailure() {
+  PRES_DEBUG("%s:id[%s], role[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(mSessionId).get(), mRole);
+
+  if (mTimer) {
+    mTimer->Cancel();
+    mTimer = nullptr;
+  }
+
+  return ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+}
+
+nsresult PresentationPresentingInfo::DoReconnect() {
+  PRES_DEBUG("%s:id[%s], role[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(mSessionId).get(), mRole);
+
+  MOZ_ASSERT(mState == nsIPresentationSessionListener::STATE_CLOSED);
+
+  SetStateWithReason(nsIPresentationSessionListener::STATE_CONNECTING, NS_OK);
+
+  return NotifyResponderReady();
+}
+
+// nsIPresentationControlChannelListener
+NS_IMETHODIMP
+PresentationPresentingInfo::OnOffer(
+    nsIPresentationChannelDescription* aDescription) {
+  if (NS_WARN_IF(mHasFlushPendingEvents)) {
+    return ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+  }
+
+  if (NS_WARN_IF(!aDescription)) {
+    return ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+  }
+
+  mRequesterDescription = aDescription;
+
+  // Initialize |mTransport| and send the answer to the sender if the receiver
+  // page is ready for presentation use.
+  if (mIsResponderReady) {
+    nsresult rv = InitTransportAndSendAnswer();
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      return ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationPresentingInfo::OnAnswer(
+    nsIPresentationChannelDescription* aDescription) {
+  MOZ_ASSERT(false, "Receiver side should not receive answer.");
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+PresentationPresentingInfo::OnIceCandidate(const nsAString& aCandidate) {
+  if (!mBuilder && !mHasFlushPendingEvents) {
+    mPendingCandidates.AppendElement(nsString(aCandidate));
+    return NS_OK;
+  }
+
+  if (NS_WARN_IF(!mBuilder && mHasFlushPendingEvents)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIPresentationDataChannelSessionTransportBuilder> builder =
+      do_QueryInterface(mBuilder);
+
+  return builder->OnIceCandidate(aCandidate);
+}
+
+NS_IMETHODIMP
+PresentationPresentingInfo::NotifyConnected() {
+  PRES_DEBUG("%s:id[%s], role[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(mSessionId).get(), mRole);
+
+  if (nsIPresentationSessionListener::STATE_TERMINATED == mState) {
+    ContinueTermination();
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationPresentingInfo::NotifyReconnected() {
+  MOZ_ASSERT(false, "NotifyReconnected should not be called at receiver side.");
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationPresentingInfo::NotifyDisconnected(nsresult aReason) {
+  PRES_DEBUG("%s:id[%s], reason[%" PRIx32 "], role[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(mSessionId).get(),
+             static_cast<uint32_t>(aReason), mRole);
+
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (mTransportType == nsIPresentationChannelDescription::TYPE_DATACHANNEL) {
+    nsCOMPtr<nsIPresentationDataChannelSessionTransportBuilder> builder =
+        do_QueryInterface(mBuilder);
+    if (builder) {
+      Unused << NS_WARN_IF(NS_FAILED(builder->NotifyDisconnected(aReason)));
+    }
+  }
+
+  // Unset control channel here so it won't try to re-close it in potential
+  // subsequent |Shutdown| calls.
+  SetControlChannel(nullptr);
+
+  if (NS_WARN_IF(NS_FAILED(aReason))) {
+    // The presentation session instance may already exist.
+    // Change the state to TERMINATED since it never succeeds.
+    SetStateWithReason(nsIPresentationSessionListener::STATE_TERMINATED,
+                       aReason);
+
+    // Reply error for an abnormal close.
+    return ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+  }
+
+  return NS_OK;
+}
+
+// nsITimerCallback
+NS_IMETHODIMP
+PresentationPresentingInfo::Notify(nsITimer* aTimer) {
+  MOZ_ASSERT(NS_IsMainThread());
+  NS_WARNING("The receiver page fails to become ready before timeout.");
+
+  mTimer = nullptr;
+  return ReplyError(NS_ERROR_DOM_TIMEOUT_ERR);
+}
+
+// nsITimerCallback
+NS_IMETHODIMP
+PresentationPresentingInfo::GetName(nsACString& aName) {
+  aName.AssignLiteral("PresentationPresentingInfo");
+  return NS_OK;
+}
+
+// PromiseNativeHandler
+void PresentationPresentingInfo::ResolvedCallback(
+    JSContext* aCx, JS::Handle<JS::Value> aValue) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (NS_WARN_IF(!aValue.isObject())) {
+    ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+    return;
+  }
+
+  JS::Rooted<JSObject*> obj(aCx, &aValue.toObject());
+  if (NS_WARN_IF(!obj)) {
+    ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+    return;
+  }
+
+  // Start to listen to document state change event |STATE_TRANSFERRING|.
+  // Use Element to support both HTMLIFrameElement and nsXULElement.
+  Element* frame = nullptr;
+  nsresult rv = UNWRAP_OBJECT(Element, &obj, frame);
+  if (NS_WARN_IF(!frame)) {
+    ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+    return;
+  }
+
+  RefPtr<nsFrameLoaderOwner> owner = do_QueryObject(frame);
+  if (NS_WARN_IF(!owner)) {
+    ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+    return;
+  }
+
+  RefPtr<nsFrameLoader> frameLoader = owner->GetFrameLoader();
+  if (NS_WARN_IF(!frameLoader)) {
+    ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+    return;
+  }
+
+  RefPtr<BrowserParent> browserParent = BrowserParent::GetFrom(frameLoader);
+  if (browserParent) {
+    // OOP frame
+    // Notify the content process that a receiver page has launched, so it can
+    // start monitoring the loading progress.
+    mContentParent = browserParent->Manager();
+    Unused << NS_WARN_IF(!static_cast<ContentParent*>(mContentParent.get())
+                              ->SendNotifyPresentationReceiverLaunched(
+                                  browserParent, mSessionId));
+  } else {
+    // In-process frame
+    IgnoredErrorResult error;
+    nsCOMPtr<nsIDocShell> docShell = frameLoader->GetDocShell(error);
+    if (NS_WARN_IF(error.Failed())) {
+      ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+      return;
+    }
+
+    // Keep an eye on the loading progress of the receiver page.
+    mLoadingCallback = new PresentationResponderLoadingCallback(mSessionId);
+    rv = mLoadingCallback->Init(docShell);
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+      return;
+    }
+  }
+}
+
+void PresentationPresentingInfo::RejectedCallback(
+    JSContext* aCx, JS::Handle<JS::Value> aValue) {
+  MOZ_ASSERT(NS_IsMainThread());
+  NS_WARNING("Launching the receiver page has been rejected.");
+
+  if (mTimer) {
+    mTimer->Cancel();
+    mTimer = nullptr;
+  }
+
+  ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+}
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/presentation/PresentationSessionInfo.h b/dom/presentation/PresentationSessionInfo.h
new file mode 100644
index 0000000000..c1d530c251
--- /dev/null
+++ b/dom/presentation/PresentationSessionInfo.h
@@ -0,0 +1,268 @@
+/* -*- 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_PresentationSessionInfo_h
+#define mozilla_dom_PresentationSessionInfo_h
+
+#include "base/process.h"
+#include "mozilla/dom/ContentParent.h"
+#include "mozilla/dom/Promise.h"
+#include "mozilla/dom/PromiseNativeHandler.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/RefPtr.h"
+#include "nsCOMPtr.h"
+#include "nsINamed.h"
+#include "nsINetworkInfoService.h"
+#include "nsIPresentationControlChannel.h"
+#include "nsIPresentationDevice.h"
+#include "nsIPresentationListener.h"
+#include "nsIPresentationService.h"
+#include "nsIPresentationSessionTransport.h"
+#include "nsIPresentationSessionTransportBuilder.h"
+#include "nsIServerSocket.h"
+#include "nsITimer.h"
+#include "nsString.h"
+#include "PresentationCallbacks.h"
+
+namespace mozilla {
+namespace dom {
+
+class PresentationSessionInfo
+    : public nsIPresentationSessionTransportCallback,
+      public nsIPresentationControlChannelListener,
+      public nsIPresentationSessionTransportBuilderListener {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPRESENTATIONSESSIONTRANSPORTCALLBACK
+  NS_DECL_NSIPRESENTATIONSESSIONTRANSPORTBUILDERLISTENER
+
+  PresentationSessionInfo(const nsAString& aUrl, const nsAString& aSessionId,
+                          const uint8_t aRole)
+      : mUrl(aUrl),
+        mSessionId(aSessionId),
+        mIsResponderReady(false),
+        mIsTransportReady(false),
+        mState(nsIPresentationSessionListener::STATE_CONNECTING),
+        mReason(NS_OK) {
+    MOZ_ASSERT(!mUrl.IsEmpty());
+    MOZ_ASSERT(!mSessionId.IsEmpty());
+    MOZ_ASSERT(aRole == nsIPresentationService::ROLE_CONTROLLER ||
+               aRole == nsIPresentationService::ROLE_RECEIVER);
+    mRole = aRole;
+  }
+
+  virtual nsresult Init(nsIPresentationControlChannel* aControlChannel);
+
+  const nsAString& GetUrl() const { return mUrl; }
+
+  const nsAString& GetSessionId() const { return mSessionId; }
+
+  uint8_t GetRole() const { return mRole; }
+
+  nsresult SetListener(nsIPresentationSessionListener* aListener);
+
+  void SetDevice(nsIPresentationDevice* aDevice) { mDevice = aDevice; }
+
+  already_AddRefed<nsIPresentationDevice> GetDevice() const {
+    nsCOMPtr<nsIPresentationDevice> device = mDevice;
+    return device.forget();
+  }
+
+  void SetControlChannel(nsIPresentationControlChannel* aControlChannel) {
+    if (mControlChannel) {
+      mControlChannel->SetListener(nullptr);
+    }
+
+    mControlChannel = aControlChannel;
+    if (mControlChannel) {
+      mControlChannel->SetListener(this);
+    }
+  }
+
+  nsresult Send(const nsAString& aData);
+
+  nsresult SendBinaryMsg(const nsACString& aData);
+
+  nsresult SendBlob(Blob* aBlob);
+
+  nsresult Close(nsresult aReason, uint32_t aState);
+
+  void OnTerminate(nsIPresentationControlChannel* aControlChannel);
+
+  nsresult ReplyError(nsresult aReason);
+
+  virtual bool IsAccessible(base::ProcessId aProcessId);
+
+  void SetTransportBuilderConstructor(
+      nsIPresentationTransportBuilderConstructor* aBuilderConstructor) {
+    mBuilderConstructor = aBuilderConstructor;
+  }
+
+ protected:
+  virtual ~PresentationSessionInfo() { Shutdown(NS_OK); }
+
+  virtual void Shutdown(nsresult aReason);
+
+  nsresult ReplySuccess();
+
+  bool IsSessionReady() { return mIsResponderReady && mIsTransportReady; }
+
+  virtual nsresult UntrackFromService();
+
+  void SetStateWithReason(uint32_t aState, nsresult aReason) {
+    if (mState == aState) {
+      return;
+    }
+
+    mState = aState;
+    mReason = aReason;
+
+    // Notify session state change.
+    if (mListener) {
+      DebugOnly<nsresult> rv =
+          mListener->NotifyStateChange(mSessionId, mState, aReason);
+      NS_WARNING_ASSERTION(NS_SUCCEEDED(rv), "NotifyStateChanged");
+    }
+  }
+
+  void ContinueTermination();
+
+  void ResetBuilder() { mBuilder = nullptr; }
+
+  // Should be nsIPresentationChannelDescription::TYPE_TCP/TYPE_DATACHANNEL
+  uint8_t mTransportType = 0;
+
+  nsPIDOMWindowInner* GetWindow();
+
+  nsString mUrl;
+  nsString mSessionId;
+  // mRole should be nsIPresentationService::ROLE_CONTROLLER
+  //              or nsIPresentationService::ROLE_RECEIVER.
+  uint8_t mRole;
+  bool mIsResponderReady;
+  bool mIsTransportReady;
+  bool mIsOnTerminating = false;
+  uint32_t mState;  // CONNECTED, CLOSED, TERMINATED
+  nsresult mReason;
+  nsCOMPtr<nsIPresentationSessionListener> mListener;
+  nsCOMPtr<nsIPresentationDevice> mDevice;
+  nsCOMPtr<nsIPresentationSessionTransport> mTransport;
+  nsCOMPtr<nsIPresentationControlChannel> mControlChannel;
+  nsCOMPtr<nsIPresentationSessionTransportBuilder> mBuilder;
+  nsCOMPtr<nsIPresentationTransportBuilderConstructor> mBuilderConstructor;
+};
+
+// Session info with controlling browsing context (sender side) behaviors.
+class PresentationControllingInfo final
+    : public PresentationSessionInfo,
+      public nsIServerSocketListener,
+      public nsIListNetworkAddressesListener {
+ public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_NSIPRESENTATIONCONTROLCHANNELLISTENER
+  NS_DECL_NSISERVERSOCKETLISTENER
+  NS_DECL_NSILISTNETWORKADDRESSESLISTENER
+  NS_DECL_NSIPRESENTATIONSESSIONTRANSPORTCALLBACK
+
+  PresentationControllingInfo(const nsAString& aUrl,
+                              const nsAString& aSessionId)
+      : PresentationSessionInfo(aUrl, aSessionId,
+                                nsIPresentationService::ROLE_CONTROLLER) {}
+
+  nsresult Init(nsIPresentationControlChannel* aControlChannel) override;
+
+  nsresult Reconnect(nsIPresentationServiceCallback* aCallback);
+
+  nsresult BuildTransport();
+
+ private:
+  ~PresentationControllingInfo() { Shutdown(NS_OK); }
+
+  void Shutdown(nsresult aReason) override;
+
+  nsresult GetAddress();
+
+  nsresult OnGetAddress(const nsACString& aAddress);
+
+  nsresult ContinueReconnect();
+
+  nsresult NotifyReconnectResult(nsresult aStatus);
+
+  nsCOMPtr<nsIServerSocket> mServerSocket;
+  nsCOMPtr<nsIPresentationServiceCallback> mReconnectCallback;
+  bool mIsReconnecting = false;
+  bool mDoReconnectAfterClose = false;
+};
+
+// Session info with presenting browsing context (receiver side) behaviors.
+class PresentationPresentingInfo final : public PresentationSessionInfo,
+                                         public PromiseNativeHandler,
+                                         public nsITimerCallback,
+                                         public nsINamed {
+ public:
+  NS_DECL_ISUPPORTS_INHERITED
+  NS_DECL_NSIPRESENTATIONCONTROLCHANNELLISTENER
+  NS_DECL_NSITIMERCALLBACK
+  NS_DECL_NSINAMED
+
+  PresentationPresentingInfo(const nsAString& aUrl, const nsAString& aSessionId,
+                             nsIPresentationDevice* aDevice)
+      : PresentationSessionInfo(aUrl, aSessionId,
+                                nsIPresentationService::ROLE_RECEIVER) {
+    MOZ_ASSERT(aDevice);
+    SetDevice(aDevice);
+  }
+
+  nsresult Init(nsIPresentationControlChannel* aControlChannel) override;
+
+  nsresult NotifyResponderReady();
+  nsresult NotifyResponderFailure();
+
+  NS_IMETHODIMP OnSessionTransport(
+      nsIPresentationSessionTransport* transport) override;
+
+  void ResolvedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override;
+
+  void RejectedCallback(JSContext* aCx, JS::Handle<JS::Value> aValue) override;
+
+  void SetPromise(Promise* aPromise) {
+    mPromise = aPromise;
+    mPromise->AppendNativeHandler(this);
+  }
+
+  bool IsAccessible(base::ProcessId aProcessId) override;
+
+  nsresult DoReconnect();
+
+ private:
+  ~PresentationPresentingInfo() { Shutdown(NS_OK); }
+
+  void Shutdown(nsresult aReason) override;
+
+  nsresult InitTransportAndSendAnswer();
+
+  nsresult UntrackFromService() override;
+
+  NS_IMETHODIMP
+  FlushPendingEvents(
+      nsIPresentationDataChannelSessionTransportBuilder* builder);
+
+  bool mHasFlushPendingEvents = false;
+  RefPtr<PresentationResponderLoadingCallback> mLoadingCallback;
+  nsCOMPtr<nsITimer> mTimer;
+  nsCOMPtr<nsIPresentationChannelDescription> mRequesterDescription;
+  nsTArray<nsString> mPendingCandidates;
+  RefPtr<Promise> mPromise;
+
+  // The content parent communicating with the content process which the OOP
+  // receiver page belongs to.
+  RefPtr<ContentParent> mContentParent;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_PresentationSessionInfo_h
diff --git a/dom/presentation/PresentationSessionRequest.cpp b/dom/presentation/PresentationSessionRequest.cpp
new file mode 100644
index 0000000000..fafc66140a
--- /dev/null
+++ b/dom/presentation/PresentationSessionRequest.cpp
@@ -0,0 +1,66 @@
+/* -*- 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 "PresentationSessionRequest.h"
+
+#include "nsIPresentationControlChannel.h"
+#include "nsIPresentationDevice.h"
+
+namespace mozilla {
+namespace dom {
+
+NS_IMPL_ISUPPORTS(PresentationSessionRequest, nsIPresentationSessionRequest)
+
+PresentationSessionRequest::PresentationSessionRequest(
+    nsIPresentationDevice* aDevice, const nsAString& aUrl,
+    const nsAString& aPresentationId,
+    nsIPresentationControlChannel* aControlChannel)
+    : mUrl(aUrl),
+      mPresentationId(aPresentationId),
+      mDevice(aDevice),
+      mControlChannel(aControlChannel) {}
+
+PresentationSessionRequest::~PresentationSessionRequest() = default;
+
+// nsIPresentationSessionRequest
+
+NS_IMETHODIMP
+PresentationSessionRequest::GetDevice(nsIPresentationDevice** aRetVal) {
+  NS_ENSURE_ARG_POINTER(aRetVal);
+
+  nsCOMPtr<nsIPresentationDevice> device = mDevice;
+  device.forget(aRetVal);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationSessionRequest::GetUrl(nsAString& aRetVal) {
+  aRetVal = mUrl;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationSessionRequest::GetPresentationId(nsAString& aRetVal) {
+  aRetVal = mPresentationId;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationSessionRequest::GetControlChannel(
+    nsIPresentationControlChannel** aRetVal) {
+  NS_ENSURE_ARG_POINTER(aRetVal);
+
+  nsCOMPtr<nsIPresentationControlChannel> controlChannel = mControlChannel;
+  controlChannel.forget(aRetVal);
+
+  return NS_OK;
+}
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/presentation/PresentationSessionRequest.h b/dom/presentation/PresentationSessionRequest.h
new file mode 100644
index 0000000000..f90a7f160d
--- /dev/null
+++ b/dom/presentation/PresentationSessionRequest.h
@@ -0,0 +1,39 @@
+/* -*- 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_PresentationSessionRequest_h__
+#define mozilla_dom_PresentationSessionRequest_h__
+
+#include "nsIPresentationSessionRequest.h"
+#include "nsCOMPtr.h"
+#include "nsString.h"
+
+namespace mozilla {
+namespace dom {
+
+class PresentationSessionRequest final : public nsIPresentationSessionRequest {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPRESENTATIONSESSIONREQUEST
+
+  PresentationSessionRequest(nsIPresentationDevice* aDevice,
+                             const nsAString& aUrl,
+                             const nsAString& aPresentationId,
+                             nsIPresentationControlChannel* aControlChannel);
+
+ private:
+  virtual ~PresentationSessionRequest();
+
+  nsString mUrl;
+  nsString mPresentationId;
+  nsCOMPtr<nsIPresentationDevice> mDevice;
+  nsCOMPtr<nsIPresentationControlChannel> mControlChannel;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif /* mozilla_dom_PresentationSessionRequest_h__ */
diff --git a/dom/presentation/PresentationTCPSessionTransport.cpp b/dom/presentation/PresentationTCPSessionTransport.cpp
new file mode 100644
index 0000000000..3dbe8fceab
--- /dev/null
+++ b/dom/presentation/PresentationTCPSessionTransport.cpp
@@ -0,0 +1,561 @@
+/* -*- 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 "mozilla/Logging.h"
+#include "nsArrayUtils.h"
+#include "nsComponentManagerUtils.h"
+#include "nsIAsyncStreamCopier.h"
+#include "nsIInputStreamPump.h"
+#include "nsIMultiplexInputStream.h"
+#include "nsIOutputStream.h"
+#include "nsIPresentationControlChannel.h"
+#include "nsIPresentationService.h"
+#include "nsIScriptableInputStream.h"
+#include "nsISocketTransport.h"
+#include "nsISocketTransportService.h"
+#include "nsIStringStream.h"
+#include "nsISupportsPrimitives.h"
+#include "nsNetUtil.h"
+#include "nsQueryObject.h"
+#include "nsServiceManagerUtils.h"
+#include "nsStreamUtils.h"
+#include "nsStringStream.h"
+#include "nsThreadUtils.h"
+#include "PresentationLog.h"
+#include "PresentationTCPSessionTransport.h"
+
+#define BUFFER_SIZE 65536
+
+namespace mozilla {
+namespace dom {
+
+class CopierCallbacks final : public nsIRequestObserver {
+ public:
+  explicit CopierCallbacks(PresentationTCPSessionTransport* aTransport)
+      : mOwner(aTransport) {}
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIREQUESTOBSERVER
+ private:
+  ~CopierCallbacks() = default;
+
+  RefPtr<PresentationTCPSessionTransport> mOwner;
+};
+
+NS_IMPL_ISUPPORTS(CopierCallbacks, nsIRequestObserver)
+
+NS_IMETHODIMP
+CopierCallbacks::OnStartRequest(nsIRequest* aRequest) { return NS_OK; }
+
+NS_IMETHODIMP
+CopierCallbacks::OnStopRequest(nsIRequest* aRequest, nsresult aStatus) {
+  mOwner->NotifyCopyComplete(aStatus);
+  return NS_OK;
+}
+
+NS_IMPL_CYCLE_COLLECTION(PresentationTCPSessionTransport, mTransport,
+                         mSocketInputStream, mSocketOutputStream,
+                         mInputStreamPump, mInputStreamScriptable, mCallback)
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(PresentationTCPSessionTransport)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(PresentationTCPSessionTransport)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PresentationTCPSessionTransport)
+  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIPresentationSessionTransport)
+  NS_INTERFACE_MAP_ENTRY(nsIInputStreamCallback)
+  NS_INTERFACE_MAP_ENTRY(nsIPresentationSessionTransport)
+  NS_INTERFACE_MAP_ENTRY(nsIPresentationSessionTransportBuilder)
+  NS_INTERFACE_MAP_ENTRY(nsIPresentationTCPSessionTransportBuilder)
+  NS_INTERFACE_MAP_ENTRY(nsIRequestObserver)
+  NS_INTERFACE_MAP_ENTRY(nsIStreamListener)
+  NS_INTERFACE_MAP_ENTRY(nsITransportEventSink)
+NS_INTERFACE_MAP_END
+
+PresentationTCPSessionTransport::PresentationTCPSessionTransport()
+    : mReadyState(ReadyState::CLOSED),
+      mAsyncCopierActive(false),
+      mCloseStatus(NS_OK),
+      mDataNotificationEnabled(false) {}
+
+PresentationTCPSessionTransport::~PresentationTCPSessionTransport() = default;
+
+NS_IMETHODIMP
+PresentationTCPSessionTransport::BuildTCPSenderTransport(
+    nsISocketTransport* aTransport,
+    nsIPresentationSessionTransportBuilderListener* aListener) {
+  if (NS_WARN_IF(!aTransport)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+  mTransport = aTransport;
+
+  if (NS_WARN_IF(!aListener)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+  mListener = aListener;
+
+  nsresult rv = CreateStream();
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  mRole = nsIPresentationService::ROLE_CONTROLLER;
+
+  nsCOMPtr<nsIPresentationSessionTransport> sessionTransport =
+      do_QueryObject(this);
+  nsCOMPtr<nsIRunnable> onSessionTransportRunnable =
+      NewRunnableMethod<nsIPresentationSessionTransport*>(
+          "nsIPresentationSessionTransportBuilderListener::OnSessionTransport",
+          mListener,
+          &nsIPresentationSessionTransportBuilderListener::OnSessionTransport,
+          sessionTransport);
+
+  NS_DispatchToCurrentThread(onSessionTransportRunnable.forget());
+
+  nsCOMPtr<nsIRunnable> setReadyStateRunnable = NewRunnableMethod<ReadyState>(
+      "dom::PresentationTCPSessionTransport::SetReadyState", this,
+      &PresentationTCPSessionTransport::SetReadyState, ReadyState::OPEN);
+  return NS_DispatchToCurrentThread(setReadyStateRunnable.forget());
+}
+
+NS_IMETHODIMP
+PresentationTCPSessionTransport::BuildTCPReceiverTransport(
+    nsIPresentationChannelDescription* aDescription,
+    nsIPresentationSessionTransportBuilderListener* aListener) {
+  if (NS_WARN_IF(!aDescription)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  if (NS_WARN_IF(!aListener)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+  mListener = aListener;
+
+  uint16_t serverPort;
+  nsresult rv = aDescription->GetTcpPort(&serverPort);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  nsCOMPtr<nsIArray> serverHosts;
+  rv = aDescription->GetTcpAddress(getter_AddRefs(serverHosts));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // TODO bug 1228504 Take all IP addresses in PresentationChannelDescription
+  // into account. And at the first stage Presentation API is only exposed on
+  // Firefox OS where the first IP appears enough for most scenarios.
+  nsCOMPtr<nsISupportsCString> supportStr = do_QueryElementAt(serverHosts, 0);
+  if (NS_WARN_IF(!supportStr)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  nsAutoCString serverHost;
+  supportStr->GetData(serverHost);
+  if (serverHost.IsEmpty()) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  PRES_DEBUG("%s:ServerHost[%s],ServerPort[%d]\n", __func__, serverHost.get(),
+             serverPort);
+
+  SetReadyState(ReadyState::CONNECTING);
+
+  nsCOMPtr<nsISocketTransportService> sts =
+      do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID);
+  if (NS_WARN_IF(!sts)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+  rv = sts->CreateTransport(nsTArray<nsCString>(), serverHost, serverPort,
+                            nullptr, getter_AddRefs(mTransport));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  nsCOMPtr<nsIEventTarget> mainTarget = GetMainThreadEventTarget();
+  mTransport->SetEventSink(this, mainTarget);
+
+  rv = CreateStream();
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  mRole = nsIPresentationService::ROLE_RECEIVER;
+
+  nsCOMPtr<nsIPresentationSessionTransport> sessionTransport =
+      do_QueryObject(this);
+  nsCOMPtr<nsIRunnable> runnable =
+      NewRunnableMethod<nsIPresentationSessionTransport*>(
+          "nsIPresentationSessionTransportBuilderListener::OnSessionTransport",
+          mListener,
+          &nsIPresentationSessionTransportBuilderListener::OnSessionTransport,
+          sessionTransport);
+  return NS_DispatchToCurrentThread(runnable.forget());
+}
+
+nsresult PresentationTCPSessionTransport::CreateStream() {
+  nsresult rv =
+      mTransport->OpenInputStream(0, 0, 0, getter_AddRefs(mSocketInputStream));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+  rv = mTransport->OpenOutputStream(nsITransport::OPEN_UNBUFFERED, 0, 0,
+                                    getter_AddRefs(mSocketOutputStream));
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // If the other side is not listening, we will get an |onInputStreamReady|
+  // callback where |available| raises to indicate the connection was refused.
+  nsCOMPtr<nsIAsyncInputStream> asyncStream =
+      do_QueryInterface(mSocketInputStream);
+  if (NS_WARN_IF(!asyncStream)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  nsCOMPtr<nsIEventTarget> mainTarget = GetMainThreadEventTarget();
+  rv = asyncStream->AsyncWait(this, nsIAsyncInputStream::WAIT_CLOSURE_ONLY, 0,
+                              mainTarget);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  mInputStreamScriptable =
+      do_CreateInstance("@mozilla.org/scriptableinputstream;1", &rv);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+  rv = mInputStreamScriptable->Init(mSocketInputStream);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+nsresult PresentationTCPSessionTransport::CreateInputStreamPump() {
+  if (NS_WARN_IF(mInputStreamPump)) {
+    return NS_OK;
+  }
+
+  nsresult rv;
+  mInputStreamPump = do_CreateInstance(NS_INPUTSTREAMPUMP_CONTRACTID, &rv);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = mInputStreamPump->Init(mSocketInputStream, 0, 0, false, nullptr);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  rv = mInputStreamPump->AsyncRead(this);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationTCPSessionTransport::EnableDataNotification() {
+  if (NS_WARN_IF(!mCallback)) {
+    return NS_ERROR_DOM_INVALID_STATE_ERR;
+  }
+
+  if (mDataNotificationEnabled) {
+    return NS_OK;
+  }
+
+  mDataNotificationEnabled = true;
+
+  if (IsReadyToNotifyData()) {
+    return CreateInputStreamPump();
+  }
+
+  return NS_OK;
+}
+
+// nsIPresentationSessionTransportBuilderListener
+NS_IMETHODIMP
+PresentationTCPSessionTransport::GetCallback(
+    nsIPresentationSessionTransportCallback** aCallback) {
+  nsCOMPtr<nsIPresentationSessionTransportCallback> callback = mCallback;
+  callback.forget(aCallback);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationTCPSessionTransport::SetCallback(
+    nsIPresentationSessionTransportCallback* aCallback) {
+  mCallback = aCallback;
+
+  if (!!mCallback && ReadyState::OPEN == mReadyState) {
+    // Notify the transport channel is ready.
+    Unused << NS_WARN_IF(NS_FAILED(mCallback->NotifyTransportReady()));
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationTCPSessionTransport::GetSelfAddress(nsINetAddr** aSelfAddress) {
+  if (NS_WARN_IF(!mTransport)) {
+    return NS_ERROR_DOM_INVALID_STATE_ERR;
+  }
+
+  return mTransport->GetScriptableSelfAddr(aSelfAddress);
+}
+
+nsresult PresentationTCPSessionTransport::EnsureCopying() {
+  if (mAsyncCopierActive) {
+    return NS_OK;
+  }
+
+  mAsyncCopierActive = true;
+
+  nsresult rv;
+
+  nsCOMPtr<nsIMultiplexInputStream> multiplexStream =
+      do_CreateInstance("@mozilla.org/io/multiplex-input-stream;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsIInputStream> stream = do_QueryInterface(multiplexStream);
+
+  while (!mPendingData.IsEmpty()) {
+    nsCOMPtr<nsIInputStream> stream = mPendingData[0];
+    multiplexStream->AppendStream(stream);
+    mPendingData.RemoveElementAt(0);
+  }
+
+  nsCOMPtr<nsIAsyncStreamCopier> copier =
+      do_CreateInstance("@mozilla.org/network/async-stream-copier;1", &rv);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  nsCOMPtr<nsISocketTransportService> sts =
+      do_GetService("@mozilla.org/network/socket-transport-service;1");
+
+  nsCOMPtr<nsIEventTarget> target = do_QueryInterface(sts);
+  rv = copier->Init(stream, mSocketOutputStream, target,
+                    true,               /* source buffered */
+                    false,              /* sink buffered */
+                    BUFFER_SIZE, false, /* close source */
+                    false);             /* close sink */
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  RefPtr<CopierCallbacks> callbacks = new CopierCallbacks(this);
+  rv = copier->AsyncCopy(callbacks, nullptr);
+  NS_ENSURE_SUCCESS(rv, rv);
+
+  return NS_OK;
+}
+
+void PresentationTCPSessionTransport::NotifyCopyComplete(nsresult aStatus) {
+  mAsyncCopierActive = false;
+
+  if (NS_WARN_IF(NS_FAILED(aStatus))) {
+    if (mReadyState != ReadyState::CLOSED) {
+      mCloseStatus = aStatus;
+      SetReadyState(ReadyState::CLOSED);
+    }
+    return;
+  }
+
+  if (!mPendingData.IsEmpty()) {
+    EnsureCopying();
+    return;
+  }
+
+  if (mReadyState == ReadyState::CLOSING) {
+    mSocketOutputStream->Close();
+    mCloseStatus = NS_OK;
+    SetReadyState(ReadyState::CLOSED);
+  }
+}
+
+NS_IMETHODIMP
+PresentationTCPSessionTransport::Send(const nsAString& aData) {
+  if (NS_WARN_IF(mReadyState != ReadyState::OPEN)) {
+    return NS_ERROR_DOM_INVALID_STATE_ERR;
+  }
+
+  nsresult rv;
+  nsCOMPtr<nsIStringInputStream> stream =
+      do_CreateInstance(NS_STRINGINPUTSTREAM_CONTRACTID, &rv);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return NS_ERROR_DOM_INVALID_STATE_ERR;
+  }
+
+  NS_ConvertUTF16toUTF8 msgString(aData);
+  rv = stream->SetData(msgString.BeginReading(), msgString.Length());
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return NS_ERROR_DOM_INVALID_STATE_ERR;
+  }
+
+  mPendingData.AppendElement(stream);
+
+  EnsureCopying();
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationTCPSessionTransport::SendBinaryMsg(const nsACString& aData) {
+  return NS_ERROR_DOM_NOT_SUPPORTED_ERR;
+}
+
+NS_IMETHODIMP
+PresentationTCPSessionTransport::SendBlob(Blob* aBlob) {
+  return NS_ERROR_DOM_NOT_SUPPORTED_ERR;
+}
+
+NS_IMETHODIMP
+PresentationTCPSessionTransport::Close(nsresult aReason) {
+  PRES_DEBUG("%s:reason[%" PRIx32 "]\n", __func__,
+             static_cast<uint32_t>(aReason));
+
+  if (mReadyState == ReadyState::CLOSED || mReadyState == ReadyState::CLOSING) {
+    return NS_OK;
+  }
+
+  mCloseStatus = aReason;
+  SetReadyState(ReadyState::CLOSING);
+
+  if (!mAsyncCopierActive) {
+    mPendingData.Clear();
+    mSocketOutputStream->Close();
+  }
+
+  mSocketInputStream->Close();
+  mDataNotificationEnabled = false;
+
+  mListener = nullptr;
+
+  return NS_OK;
+}
+
+void PresentationTCPSessionTransport::SetReadyState(ReadyState aReadyState) {
+  mReadyState = aReadyState;
+
+  if (mReadyState == ReadyState::OPEN) {
+    if (IsReadyToNotifyData()) {
+      CreateInputStreamPump();
+    }
+
+    if (NS_WARN_IF(!mCallback)) {
+      return;
+    }
+
+    // Notify the transport channel is ready.
+    Unused << NS_WARN_IF(NS_FAILED(mCallback->NotifyTransportReady()));
+  } else if (mReadyState == ReadyState::CLOSED && mCallback) {
+    if (NS_WARN_IF(!mCallback)) {
+      return;
+    }
+
+    // Notify the transport channel has been shut down.
+    Unused << NS_WARN_IF(
+        NS_FAILED(mCallback->NotifyTransportClosed(mCloseStatus)));
+    mCallback = nullptr;
+  }
+}
+
+// nsITransportEventSink
+NS_IMETHODIMP
+PresentationTCPSessionTransport::OnTransportStatus(nsITransport* aTransport,
+                                                   nsresult aStatus,
+                                                   int64_t aProgress,
+                                                   int64_t aProgressMax) {
+  PRES_DEBUG("%s:aStatus[%" PRIx32 "]\n", __func__,
+             static_cast<uint32_t>(aStatus));
+
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (aStatus != NS_NET_STATUS_CONNECTED_TO) {
+    return NS_OK;
+  }
+
+  SetReadyState(ReadyState::OPEN);
+
+  return NS_OK;
+}
+
+// nsIInputStreamCallback
+NS_IMETHODIMP
+PresentationTCPSessionTransport::OnInputStreamReady(
+    nsIAsyncInputStream* aStream) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  // Only used for detecting if the connection was refused.
+  uint64_t dummy;
+  nsresult rv = aStream->Available(&dummy);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    if (mReadyState != ReadyState::CLOSED) {
+      mCloseStatus = NS_ERROR_CONNECTION_REFUSED;
+      SetReadyState(ReadyState::CLOSED);
+    }
+  }
+
+  return NS_OK;
+}
+
+// nsIRequestObserver
+NS_IMETHODIMP
+PresentationTCPSessionTransport::OnStartRequest(nsIRequest* aRequest) {
+  // Do nothing.
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationTCPSessionTransport::OnStopRequest(nsIRequest* aRequest,
+                                               nsresult aStatusCode) {
+  PRES_DEBUG("%s:aStatusCode[%" PRIx32 "]\n", __func__,
+             static_cast<uint32_t>(aStatusCode));
+
+  MOZ_ASSERT(NS_IsMainThread());
+
+  mInputStreamPump = nullptr;
+
+  if (mAsyncCopierActive && NS_SUCCEEDED(aStatusCode)) {
+    // If we have some buffered output still, and status is not an error, the
+    // other side has done a half-close, but we don't want to be in the close
+    // state until we are done sending everything that was buffered. We also
+    // don't want to call |NotifyTransportClosed| yet.
+    return NS_OK;
+  }
+
+  // We call this even if there is no error.
+  if (mReadyState != ReadyState::CLOSED) {
+    mCloseStatus = aStatusCode;
+    SetReadyState(ReadyState::CLOSED);
+  }
+  return NS_OK;
+}
+
+// nsIStreamListener
+NS_IMETHODIMP
+PresentationTCPSessionTransport::OnDataAvailable(nsIRequest* aRequest,
+                                                 nsIInputStream* aStream,
+                                                 uint64_t aOffset,
+                                                 uint32_t aCount) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (NS_WARN_IF(!mCallback)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  nsCString data;
+  nsresult rv = mInputStreamScriptable->ReadBytes(aCount, data);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  // Pass the incoming data to the listener.
+  return mCallback->NotifyData(data, false);
+}
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/presentation/PresentationTCPSessionTransport.h b/dom/presentation/PresentationTCPSessionTransport.h
new file mode 100644
index 0000000000..c8662d4852
--- /dev/null
+++ b/dom/presentation/PresentationTCPSessionTransport.h
@@ -0,0 +1,104 @@
+/* -*- 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_PresentationSessionTransport_h
+#define mozilla_dom_PresentationSessionTransport_h
+
+#include "mozilla/RefPtr.h"
+#include "nsCOMPtr.h"
+#include "nsCycleCollectionParticipant.h"
+#include "nsIAsyncInputStream.h"
+#include "nsIPresentationSessionTransport.h"
+#include "nsIPresentationSessionTransportBuilder.h"
+#include "nsIStreamListener.h"
+#include "nsISupportsImpl.h"
+#include "nsITransport.h"
+
+class nsISocketTransport;
+class nsIInputStreamPump;
+class nsIScriptableInputStream;
+class nsIMultiplexInputStream;
+class nsIAsyncStreamCopier;
+class nsIInputStream;
+
+namespace mozilla {
+namespace dom {
+
+/*
+ * App-to-App transport channel for the presentation session. It's usually
+ * initialized with an |InitWithSocketTransport| call if at the presenting
+ * sender side; whereas it's initialized with an |InitWithChannelDescription| if
+ * at the presenting receiver side. The lifetime is managed in either
+ * |PresentationControllingInfo| (sender side) or |PresentationPresentingInfo|
+ * (receiver side) in PresentationSessionInfo.cpp.
+ */
+class PresentationTCPSessionTransport final
+    : public nsIPresentationSessionTransport,
+      public nsIPresentationTCPSessionTransportBuilder,
+      public nsITransportEventSink,
+      public nsIInputStreamCallback,
+      public nsIStreamListener {
+ public:
+  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
+  NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(PresentationTCPSessionTransport,
+                                           nsIPresentationSessionTransport)
+
+  NS_DECL_NSIPRESENTATIONSESSIONTRANSPORT
+  NS_DECL_NSIPRESENTATIONSESSIONTRANSPORTBUILDER
+  NS_DECL_NSIPRESENTATIONTCPSESSIONTRANSPORTBUILDER
+  NS_DECL_NSITRANSPORTEVENTSINK
+  NS_DECL_NSIINPUTSTREAMCALLBACK
+  NS_DECL_NSIREQUESTOBSERVER
+  NS_DECL_NSISTREAMLISTENER
+
+  PresentationTCPSessionTransport();
+
+  void NotifyCopyComplete(nsresult aStatus);
+
+ private:
+  ~PresentationTCPSessionTransport();
+
+  nsresult CreateStream();
+
+  nsresult CreateInputStreamPump();
+
+  nsresult EnsureCopying();
+
+  enum class ReadyState { CONNECTING, OPEN, CLOSING, CLOSED };
+
+  void SetReadyState(ReadyState aReadyState);
+
+  bool IsReadyToNotifyData() {
+    return mDataNotificationEnabled && mReadyState == ReadyState::OPEN;
+  }
+
+  ReadyState mReadyState;
+  bool mAsyncCopierActive;
+  nsresult mCloseStatus;
+  bool mDataNotificationEnabled;
+
+  uint8_t mRole = 0;
+
+  // Raw socket streams
+  nsCOMPtr<nsISocketTransport> mTransport;
+  nsCOMPtr<nsIInputStream> mSocketInputStream;
+  nsCOMPtr<nsIOutputStream> mSocketOutputStream;
+
+  // Input stream machinery
+  nsCOMPtr<nsIInputStreamPump> mInputStreamPump;
+  nsCOMPtr<nsIScriptableInputStream> mInputStreamScriptable;
+
+  nsCOMPtr<nsIPresentationSessionTransportCallback> mCallback;
+  nsCOMPtr<nsIPresentationSessionTransportBuilderListener> mListener;
+
+  // The data to be sent.
+  nsTArray<nsCOMPtr<nsIInputStream>> mPendingData;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_PresentationSessionTransport_h
diff --git a/dom/presentation/PresentationTerminateRequest.cpp b/dom/presentation/PresentationTerminateRequest.cpp
new file mode 100644
index 0000000000..0a641dd095
--- /dev/null
+++ b/dom/presentation/PresentationTerminateRequest.cpp
@@ -0,0 +1,63 @@
+/* -*- 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 "PresentationTerminateRequest.h"
+#include "nsIPresentationControlChannel.h"
+#include "nsIPresentationDevice.h"
+
+namespace mozilla {
+namespace dom {
+
+NS_IMPL_ISUPPORTS(PresentationTerminateRequest, nsIPresentationTerminateRequest)
+
+PresentationTerminateRequest::PresentationTerminateRequest(
+    nsIPresentationDevice* aDevice, const nsAString& aPresentationId,
+    nsIPresentationControlChannel* aControlChannel, bool aIsFromReceiver)
+    : mPresentationId(aPresentationId),
+      mDevice(aDevice),
+      mControlChannel(aControlChannel),
+      mIsFromReceiver(aIsFromReceiver) {}
+
+PresentationTerminateRequest::~PresentationTerminateRequest() = default;
+
+// nsIPresentationTerminateRequest
+NS_IMETHODIMP
+PresentationTerminateRequest::GetDevice(nsIPresentationDevice** aRetVal) {
+  NS_ENSURE_ARG_POINTER(aRetVal);
+
+  nsCOMPtr<nsIPresentationDevice> device = mDevice;
+  device.forget(aRetVal);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationTerminateRequest::GetPresentationId(nsAString& aRetVal) {
+  aRetVal = mPresentationId;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationTerminateRequest::GetControlChannel(
+    nsIPresentationControlChannel** aRetVal) {
+  NS_ENSURE_ARG_POINTER(aRetVal);
+
+  nsCOMPtr<nsIPresentationControlChannel> controlChannel = mControlChannel;
+  controlChannel.forget(aRetVal);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationTerminateRequest::GetIsFromReceiver(bool* aRetVal) {
+  *aRetVal = mIsFromReceiver;
+
+  return NS_OK;
+}
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/presentation/PresentationTerminateRequest.h b/dom/presentation/PresentationTerminateRequest.h
new file mode 100644
index 0000000000..bd6e29fb78
--- /dev/null
+++ b/dom/presentation/PresentationTerminateRequest.h
@@ -0,0 +1,40 @@
+/* -*- 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_PresentationTerminateRequest_h__
+#define mozilla_dom_PresentationTerminateRequest_h__
+
+#include "nsIPresentationTerminateRequest.h"
+#include "nsCOMPtr.h"
+#include "nsString.h"
+
+namespace mozilla {
+namespace dom {
+
+class PresentationTerminateRequest final
+    : public nsIPresentationTerminateRequest {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPRESENTATIONTERMINATEREQUEST
+
+  PresentationTerminateRequest(nsIPresentationDevice* aDevice,
+                               const nsAString& aPresentationId,
+                               nsIPresentationControlChannel* aControlChannel,
+                               bool aIsFromReceiver);
+
+ private:
+  virtual ~PresentationTerminateRequest();
+
+  nsString mPresentationId;
+  nsCOMPtr<nsIPresentationDevice> mDevice;
+  nsCOMPtr<nsIPresentationControlChannel> mControlChannel;
+  bool mIsFromReceiver;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif /* mozilla_dom_PresentationTerminateRequest_h__ */
diff --git a/dom/presentation/PresentationTransportBuilderConstructor.cpp b/dom/presentation/PresentationTransportBuilderConstructor.cpp
new file mode 100644
index 0000000000..7ceaf167cd
--- /dev/null
+++ b/dom/presentation/PresentationTransportBuilderConstructor.cpp
@@ -0,0 +1,78 @@
+/* -*- 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 "PresentationTransportBuilderConstructor.h"
+
+#include "nsComponentManagerUtils.h"
+#include "nsIPresentationControlChannel.h"
+#include "nsIPresentationSessionTransport.h"
+#include "nsXULAppAPI.h"
+
+namespace mozilla {
+namespace dom {
+
+NS_IMPL_ISUPPORTS(DummyPresentationTransportBuilderConstructor,
+                  nsIPresentationTransportBuilderConstructor)
+
+NS_IMETHODIMP
+DummyPresentationTransportBuilderConstructor::CreateTransportBuilder(
+    uint8_t aType, nsIPresentationSessionTransportBuilder** aRetval) {
+  MOZ_ASSERT(false, "Unexpected to be invoked.");
+  return NS_OK;
+}
+
+/* static */
+already_AddRefed<nsIPresentationTransportBuilderConstructor>
+PresentationTransportBuilderConstructor::Create() {
+  nsCOMPtr<nsIPresentationTransportBuilderConstructor> constructor;
+  if (XRE_IsContentProcess()) {
+    constructor = new DummyPresentationTransportBuilderConstructor();
+  } else {
+    constructor = new PresentationTransportBuilderConstructor();
+  }
+
+  return constructor.forget();
+}
+
+NS_IMETHODIMP
+PresentationTransportBuilderConstructor::CreateTransportBuilder(
+    uint8_t aType, nsIPresentationSessionTransportBuilder** aRetval) {
+  if (NS_WARN_IF(!aRetval)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  *aRetval = nullptr;
+
+  if (NS_WARN_IF(aType != nsIPresentationChannelDescription::TYPE_TCP &&
+                 aType !=
+                     nsIPresentationChannelDescription::TYPE_DATACHANNEL)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  if (XRE_IsContentProcess()) {
+    MOZ_ASSERT(false,
+               "CreateTransportBuilder can only be invoked in parent process.");
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIPresentationSessionTransportBuilder> builder;
+  if (aType == nsIPresentationChannelDescription::TYPE_TCP) {
+    builder = do_CreateInstance(PRESENTATION_TCP_SESSION_TRANSPORT_CONTRACTID);
+  } else {
+    builder = do_CreateInstance(
+        "@mozilla.org/presentation/datachanneltransportbuilder;1");
+  }
+
+  if (NS_WARN_IF(!builder)) {
+    return NS_ERROR_DOM_OPERATION_ERR;
+  }
+
+  builder.forget(aRetval);
+  return NS_OK;
+}
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/presentation/PresentationTransportBuilderConstructor.h b/dom/presentation/PresentationTransportBuilderConstructor.h
new file mode 100644
index 0000000000..c57542e201
--- /dev/null
+++ b/dom/presentation/PresentationTransportBuilderConstructor.h
@@ -0,0 +1,47 @@
+/* -*- 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_PresentationTransportBuilderConstructor_h
+#define mozilla_dom_PresentationTransportBuilderConstructor_h
+
+#include "nsCOMPtr.h"
+#include "nsIPresentationSessionTransportBuilder.h"
+#include "nsISupportsImpl.h"
+
+namespace mozilla {
+namespace dom {
+
+class DummyPresentationTransportBuilderConstructor
+    : public nsIPresentationTransportBuilderConstructor {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPRESENTATIONTRANSPORTBUILDERCONSTRUCTOR
+
+  DummyPresentationTransportBuilderConstructor() = default;
+
+ protected:
+  virtual ~DummyPresentationTransportBuilderConstructor() = default;
+};
+
+class PresentationTransportBuilderConstructor final
+    : public DummyPresentationTransportBuilderConstructor {
+ public:
+  NS_INLINE_DECL_REFCOUNTING_INHERITED(
+      PresentationTransportBuilderConstructor,
+      DummyPresentationTransportBuilderConstructor)
+  NS_DECL_NSIPRESENTATIONTRANSPORTBUILDERCONSTRUCTOR
+
+  static already_AddRefed<nsIPresentationTransportBuilderConstructor> Create();
+
+ private:
+  PresentationTransportBuilderConstructor() = default;
+  virtual ~PresentationTransportBuilderConstructor() = default;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_PresentationTransportBuilderConstructor_h
diff --git a/dom/presentation/components.conf b/dom/presentation/components.conf
new file mode 100644
index 0000000000..c71ad39ef4
--- /dev/null
+++ b/dom/presentation/components.conf
@@ -0,0 +1,36 @@
+# -*- 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/.
+
+Classes = [
+    {
+        'cid': '{a2b5ef38-a650-4bee-b488-3739f1f3afe7}',
+        'contract_ids': ['@mozilla.org/presentation/mockedsockettransport;1'],
+        'headers': ['/dom/presentation/MockedSocketTransport.h'],
+        'type': 'mozilla::dom::MockedSocketTransport',
+    },
+    {
+        'cid': '{dd2bbf2f-3399-4389-8f5f-d382afb8b2d6}',
+        'contract_ids': ['@mozilla.org/presentation/datachanneltransport;1'],
+        'jsm': 'resource://gre/modules/PresentationDataChannelSessionTransport.jsm',
+        'constructor': 'PresentationTransport',
+    },
+    {
+        'cid': '{215b2f62-46e2-4004-a3d1-6858e56c20f3}',
+        'contract_ids': ['@mozilla.org/presentation/datachanneltransportbuilder;1'],
+        'jsm': 'resource://gre/modules/PresentationDataChannelSessionTransport.jsm',
+        'constructor': 'PresentationTransportBuilder',
+    },
+]
+
+if buildconfig.substs['MOZ_WIDGET_TOOLKIT'] == 'android':
+    Classes += [
+        {
+            'cid': '{5fb96caa-6d49-4f6b-9a4b-65dd0d51f92d}',
+            'contract_ids': ['@mozilla.org/presentation-device/networkHelper;1'],
+            'jsm': 'resource://gre/modules/PresentationNetworkHelper.jsm',
+            'constructor': 'PresentationNetworkHelper',
+        },
+    ]
diff --git a/dom/presentation/interfaces/moz.build b/dom/presentation/interfaces/moz.build
new file mode 100644
index 0000000000..bc09f5679f
--- /dev/null
+++ b/dom/presentation/interfaces/moz.build
@@ -0,0 +1,29 @@
+# -*- 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/.
+
+XPIDL_SOURCES += [
+    "nsIPresentationControlChannel.idl",
+    "nsIPresentationControlService.idl",
+    "nsIPresentationDevice.idl",
+    "nsIPresentationDeviceManager.idl",
+    "nsIPresentationDevicePrompt.idl",
+    "nsIPresentationDeviceProvider.idl",
+    "nsIPresentationListener.idl",
+    "nsIPresentationLocalDevice.idl",
+    "nsIPresentationRequestUIGlue.idl",
+    "nsIPresentationService.idl",
+    "nsIPresentationSessionRequest.idl",
+    "nsIPresentationSessionTransport.idl",
+    "nsIPresentationSessionTransportBuilder.idl",
+    "nsIPresentationTerminateRequest.idl",
+]
+
+if CONFIG["MOZ_WIDGET_TOOLKIT"] == "android":
+    XPIDL_SOURCES += [
+        "nsIPresentationNetworkHelper.idl",
+    ]
+
+XPIDL_MODULE = "dom_presentation"
diff --git a/dom/presentation/interfaces/nsIPresentationControlChannel.idl b/dom/presentation/interfaces/nsIPresentationControlChannel.idl
new file mode 100644
index 0000000000..2b44fbd412
--- /dev/null
+++ b/dom/presentation/interfaces/nsIPresentationControlChannel.idl
@@ -0,0 +1,139 @@
+/* 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 "nsISupports.idl"
+
+interface nsIArray;
+interface nsIInputStream;
+
+[scriptable, uuid(ae318e05-2a4e-4f85-95c0-e8b191ad812c)]
+interface nsIPresentationChannelDescription: nsISupports
+{
+  const unsigned short TYPE_TCP = 1;
+  const unsigned short TYPE_DATACHANNEL = 2;
+
+  // Type of transport channel.
+  readonly attribute uint8_t type;
+
+  // Addresses for TCP channel (as a list of nsISupportsCString).
+  // Should only be used while type == TYPE_TCP.
+  readonly attribute nsIArray tcpAddress;
+
+  // Port number for TCP channel.
+  // Should only be used while type == TYPE_TCP.
+  readonly attribute uint16_t tcpPort;
+
+  // SDP for Data Channel.
+  // Should only be used while type == TYPE_DATACHANNEL.
+  readonly attribute AString dataChannelSDP;
+};
+
+/*
+ * The callbacks for events on control channel.
+ */
+[scriptable, uuid(96dd548f-7d0f-43c1-b1ad-28e666cf1e82)]
+interface nsIPresentationControlChannelListener: nsISupports
+{
+  /*
+   * Callback for receiving offer from remote endpoint.
+   * @param offer The received offer.
+   */
+  void onOffer(in nsIPresentationChannelDescription offer);
+
+  /*
+   * Callback for receiving answer from remote endpoint.
+   * @param answer The received answer.
+   */
+  void onAnswer(in nsIPresentationChannelDescription answer);
+
+  /*
+   * Callback for receiving ICE candidate from remote endpoint.
+   * @param answer The received answer.
+   */
+  void onIceCandidate(in AString candidate);
+
+  /*
+   * The callback for notifying channel connected. This should be async called
+   * after nsIPresentationDevice::establishControlChannel.
+   */
+  void notifyConnected();
+
+  /*
+   * The callback for notifying channel disconnected.
+   * @param reason The reason of channel close, NS_OK represents normal close.
+   */
+  void notifyDisconnected(in nsresult reason);
+
+  /*
+   * The callback for notifying the reconnect command is acknowledged.
+   */
+  void notifyReconnected();
+};
+
+/*
+ * The control channel for establishing RTCPeerConnection for a presentation
+ * session. SDP Offer/Answer will be exchanged through this interface. The
+ * control channel should be in-order.
+ */
+[scriptable, uuid(e60e208c-a9f5-4bc6-9a3e-47f3e4ae9c57)]
+interface nsIPresentationControlChannel: nsISupports
+{
+  // The listener for handling events of this control channel.
+  // All the events should be pending until listener is assigned.
+  attribute nsIPresentationControlChannelListener listener;
+
+  /*
+   * Send offer to remote endpoint. |onOffer| should be invoked on remote
+   * endpoint.
+   * @param offer The offer to send.
+   * @throws  NS_ERROR_FAILURE on failure
+   */
+  void sendOffer(in nsIPresentationChannelDescription offer);
+
+  /*
+   * Send answer to remote endpoint. |onAnswer| should be invoked on remote
+   * endpoint.
+   * @param answer The answer to send.
+   * @throws  NS_ERROR_FAILURE on failure
+   */
+  void sendAnswer(in nsIPresentationChannelDescription answer);
+
+  /*
+   * Send ICE candidate to remote endpoint. |onIceCandidate| should be invoked
+   * on remote endpoint.
+   * @param candidate The candidate to send
+   * @throws NS_ERROR_FAILURE on failure
+   */
+  void sendIceCandidate(in AString candidate);
+
+  /*
+   * Launch a presentation on remote endpoint.
+   * @param presentationId The Id for representing this session.
+   * @param url The URL requested to open by remote device.
+   * @throws NS_ERROR_FAILURE on failure
+   */
+  void launch(in AString presentationId, in AString url);
+
+  /*
+   * Terminate a presentation on remote endpoint.
+   * @param presentationId The Id for representing this session.
+   * @throws NS_ERROR_FAILURE on failure
+   */
+  void terminate(in AString presentationId);
+
+  /*
+   * Disconnect the control channel.
+   * @param reason The reason of disconnecting channel; NS_OK represents normal.
+   */
+  void disconnect(in nsresult reason);
+
+  /*
+   * Reconnect a presentation on remote endpoint.
+   * Note that only controller is allowed to reconnect a session.
+   * @param presentationId The Id for representing this session.
+   * @param url The URL requested to open by remote device.
+   * @throws NS_ERROR_FAILURE on failure
+   */
+  void reconnect(in AString presentationId, in AString url);
+};
diff --git a/dom/presentation/interfaces/nsIPresentationControlService.idl b/dom/presentation/interfaces/nsIPresentationControlService.idl
new file mode 100644
index 0000000000..6602b49776
--- /dev/null
+++ b/dom/presentation/interfaces/nsIPresentationControlService.idl
@@ -0,0 +1,156 @@
+/* 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 "nsISupports.idl"
+
+interface nsIPresentationControlChannel;
+
+%{C++
+#define PRESENTATION_CONTROL_SERVICE_CONTACT_ID \
+  "@mozilla.org/presentation/control-service;1"
+%}
+
+/*
+ * The device information required for establishing control channel.
+ */
+[scriptable, uuid(296fd171-e4d0-4de0-99ff-ad8ed52ddef3)]
+interface nsITCPDeviceInfo: nsISupports
+{
+  readonly attribute AUTF8String id;
+  readonly attribute AUTF8String address;
+  readonly attribute uint16_t port;
+  // SHA-256 fingerprint of server certificate. Empty string represents
+  // server doesn't support TLS or not available.
+  readonly attribute AUTF8String certFingerprint;
+};
+
+[scriptable, uuid(09bddfaf-fcc2-4dc9-b33e-a509a1c2fb6d)]
+interface nsIPresentationControlServerListener: nsISupports
+{
+  /**
+   * Callback while the server is ready or restarted.
+   * @param   aPort
+   *          The port of the server socket.
+   * @param   aCertFingerprint
+   *          The SHA-256 fingerprint of TLS server certificate.
+   *          Empty string represents server started without encryption.
+   */
+  void onServerReady(in uint16_t aPort, in AUTF8String aCertFingerprint);
+
+  /**
+   * Callback while the server is stopped or fails to start.
+   * @param   aResult
+   *          The error cause of server stopped or the reason of
+   *          start failure.
+   *          NS_OK means the server is stopped by close.
+   */
+  void onServerStopped(in nsresult aResult);
+
+  /**
+   * Callback while the remote host is requesting to start a presentation session.
+   * @param aDeviceInfo The device information related to the remote host.
+   * @param aUrl The URL requested to open by remote device.
+   * @param aPresentationId The Id for representing this session.
+   * @param aControlChannel The control channel for this session.
+   */
+  void onSessionRequest(in nsITCPDeviceInfo aDeviceInfo,
+                        in AString aUrl,
+                        in AString aPresentationId,
+                        in nsIPresentationControlChannel aControlChannel);
+
+  /**
+   * Callback while the remote host is requesting to terminate a presentation session.
+   * @param aDeviceInfo The device information related to the remote host.
+   * @param aPresentationId The Id for representing this session.
+   * @param aControlChannel The control channel for this session.
+   * @param aIsFromReceiver true if termination is initiated by receiver.
+   */
+  void onTerminateRequest(in nsITCPDeviceInfo aDeviceInfo,
+                          in AString aPresentationId,
+                          in nsIPresentationControlChannel aControlChannel,
+                          in boolean aIsFromReceiver);
+
+  /**
+   * Callback while the remote host is requesting to reconnect a presentation session.
+   * @param aDeviceInfo The device information related to the remote host.
+   * @param aUrl The URL requested to open by remote device.
+   * @param aPresentationId The Id for representing this session.
+   * @param aControlChannel The control channel for this session.
+   */
+  void onReconnectRequest(in nsITCPDeviceInfo aDeviceInfo,
+                          in AString url,
+                          in AString aPresentationId,
+                          in nsIPresentationControlChannel aControlChannel);
+};
+
+/**
+ * Presentation control service which can be used for both presentation
+ * control client and server.
+ */
+[scriptable, uuid(55d6b605-2389-4aae-a8fe-60d4440540ea)]
+interface nsIPresentationControlService: nsISupports
+{
+  /**
+   * This method initializes server socket. Caller should set listener and
+   * monitor onServerReady event to get the correct server info.
+   * @param   aEncrypted
+   *          True for using TLS control channel.
+   * @param   aPort
+   *          The port of the server socket.  Pass 0 or opt-out to indicate no
+   *          preference, and a port will be selected automatically.
+   * @throws  NS_ERROR_FAILURE if the server socket has been inited or the
+   *          server socket can not be inited.
+   */
+  void startServer(in boolean aEncrypted, [optional] in uint16_t aPort);
+
+  /**
+   * Request connection to designated remote presentation control receiver.
+   * @param   aDeviceInfo
+   *          The remtoe device info for establish connection.
+   * @returns The control channel for this session.
+   * @throws  NS_ERROR_FAILURE if the Id hasn't been inited.
+   */
+  nsIPresentationControlChannel connect(in nsITCPDeviceInfo aDeviceInfo);
+
+  /**
+   * Check the compatibility to remote presentation control server.
+   * @param  aVersion
+   *         The version of remote server.
+   */
+  boolean isCompatibleServer(in uint32_t aVersion);
+
+  /**
+   * Close server socket and call |listener.onClose(NS_OK)|
+   */
+  void close();
+
+  /**
+   * Get the listen port of the TCP socket, valid after the server is ready.
+   * 0 indicates the server socket is not ready or is closed.
+   */
+  readonly attribute uint16_t port;
+
+  /**
+   * The protocol version implemented by this server.
+   */
+  readonly attribute uint32_t version;
+
+  /**
+   * The id of the TCP presentation server. |requestSession| won't
+   * work until the |id| is set.
+   */
+  attribute AUTF8String id;
+
+  /**
+   * The fingerprint of the TLS server certificate.
+   * Empty string indicates the server is not ready or not encrypted.
+   */
+  attribute AUTF8String certFingerprint;
+
+  /**
+   * The listener for handling events of this presentation control server.
+   * Listener must be provided before invoke |startServer| and |close|.
+   */
+  attribute nsIPresentationControlServerListener listener;
+};
diff --git a/dom/presentation/interfaces/nsIPresentationDevice.idl b/dom/presentation/interfaces/nsIPresentationDevice.idl
new file mode 100644
index 0000000000..e70820270a
--- /dev/null
+++ b/dom/presentation/interfaces/nsIPresentationDevice.idl
@@ -0,0 +1,43 @@
+/* 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 "nsISupports.idl"
+
+interface nsIPresentationControlChannel;
+
+/*
+ * Remote device.
+ */
+[scriptable, uuid(b1e0a7af-5936-4066-8f2e-f789fb9a7e8f)]
+interface nsIPresentationDevice : nsISupports
+{
+  // The unique Id for the device. UUID is recommanded.
+  readonly attribute AUTF8String id;
+
+  // The human-readable name of this device.
+  readonly attribute AUTF8String name;
+
+  // TODO expose more info in order to fulfill UX spec
+  // The category of this device, could be "wifi", "bluetooth", "hdmi", etc.
+  readonly attribute AUTF8String type;
+
+  /*
+   * Establish a control channel to this device.
+   * @returns The control channel for this session.
+   * @throws  NS_ERROR_FAILURE if the establishment fails
+   */
+  nsIPresentationControlChannel establishControlChannel();
+
+  // Do something when presentation session is disconnected.
+  void disconnect();
+
+  /*
+   * Query if requested presentation URL is supported.
+   * @params requestedUrl the designated URL for a presentation request.
+   * @returns true if designated URL is supported.
+   */
+  boolean isRequestedUrlSupported(in AString requestedUrl);
+};
+
+
diff --git a/dom/presentation/interfaces/nsIPresentationDeviceManager.idl b/dom/presentation/interfaces/nsIPresentationDeviceManager.idl
new file mode 100644
index 0000000000..adff9fc09e
--- /dev/null
+++ b/dom/presentation/interfaces/nsIPresentationDeviceManager.idl
@@ -0,0 +1,51 @@
+/* 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 "nsISupports.idl"
+
+interface nsIArray;
+interface nsIPresentationDeviceProvider;
+
+%{C++
+#define PRESENTATION_DEVICE_MANAGER_CONTRACTID "@mozilla.org/presentation-device/manager;1"
+#define PRESENTATION_DEVICE_CHANGE_TOPIC "presentation-device-change"
+%}
+
+/*
+ * Manager for the device availability. User can observe "presentation-device-change"
+ * for any update of the available devices.
+ */
+[scriptable, uuid(beb61db5-3d5f-454f-a15a-dbfa0337c569)]
+interface nsIPresentationDeviceManager : nsISupports
+{
+  // true if there is any device available.
+  readonly attribute boolean deviceAvailable;
+
+  /*
+   * Register a device provider manually.
+   * @param provider The device provider to add.
+   */
+  void addDeviceProvider(in nsIPresentationDeviceProvider provider);
+
+  /*
+   * Unregister a device provider manually.
+   * @param provider The device provider to remove.
+   */
+  void removeDeviceProvider(in nsIPresentationDeviceProvider provider);
+
+  /*
+   * Force all registered device providers to update device information.
+   */
+  void forceDiscovery();
+
+  /*
+   * Retrieve all available devices or all available devices that supports
+   * designated presentation URLs, return a list of nsIPresentationDevice.
+   * The returned list is a cached device list and could be out-of-date.
+   * Observe device change events to get following updates.
+   * @param presentationUrls the target presentation URLs for device filtering
+   */
+  nsIArray getAvailableDevices([optional] in nsIArray presentationUrls);
+};
+
diff --git a/dom/presentation/interfaces/nsIPresentationDevicePrompt.idl b/dom/presentation/interfaces/nsIPresentationDevicePrompt.idl
new file mode 100644
index 0000000000..9128b1cc75
--- /dev/null
+++ b/dom/presentation/interfaces/nsIPresentationDevicePrompt.idl
@@ -0,0 +1,59 @@
+/* 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 "nsISupports.idl"
+
+interface nsIArray;
+interface nsIPresentationDevice;
+interface nsIPrincipal;
+
+webidl EventTarget;
+
+%{C++
+#define PRESENTATION_DEVICE_PROMPT_CONTRACTID "@mozilla.org/presentation-device/prompt;1"
+%}
+
+/*
+ * The information and callbacks for device selection
+ */
+[scriptable, uuid(b2aa7f6a-9448-446a-bba4-9c29638b0ed4)]
+interface nsIPresentationDeviceRequest : nsISupports
+{
+  // The origin which initiate the request.
+  readonly attribute AString origin;
+
+  // The array of candidate URLs.
+  readonly attribute nsIArray requestURLs;
+
+  // The XUL browser element that the request was originated in.
+  readonly attribute EventTarget chromeEventHandler;
+
+  // The principal of the request.
+  readonly attribute nsIPrincipal principal;
+
+  /*
+   * Callback after selecting a device
+   * @param device The selected device.
+   */
+  void select(in nsIPresentationDevice device);
+
+  /*
+   * Callback after selection failed or canceled by user.
+   * @param reason The error cause for canceling this request.
+   */
+  void cancel(in nsresult reason);
+};
+
+/*
+ * UI prompt for device selection.
+ */
+[scriptable, uuid(ac1a7e44-de86-454f-a9f1-276de2539831)]
+interface nsIPresentationDevicePrompt : nsISupports
+{
+  /*
+   * Request a device selection.
+   * @param request The information and callbacks of this selection request.
+   */
+  void promptDeviceSelection(in nsIPresentationDeviceRequest request);
+};
diff --git a/dom/presentation/interfaces/nsIPresentationDeviceProvider.idl b/dom/presentation/interfaces/nsIPresentationDeviceProvider.idl
new file mode 100644
index 0000000000..15d09241ef
--- /dev/null
+++ b/dom/presentation/interfaces/nsIPresentationDeviceProvider.idl
@@ -0,0 +1,75 @@
+/* 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 "nsISupports.idl"
+
+interface nsIPresentationDevice;
+interface nsIPresentationControlChannel;
+
+%{C++
+#define PRESENTATION_DEVICE_PROVIDER_CATEGORY "presentation-device-provider"
+%}
+
+/*
+ * The callbacks for any device updates and session request.
+ */
+[scriptable, uuid(46fd372b-2e40-4179-9b36-0478d141e440)]
+interface nsIPresentationDeviceListener: nsISupports
+{
+  void addDevice(in nsIPresentationDevice device);
+  void removeDevice(in nsIPresentationDevice device);
+  void updateDevice(in nsIPresentationDevice device);
+
+  /*
+   * Callback while the remote device is requesting to start a presentation session.
+   * @param device The remote device that sent session request.
+   * @param url The URL requested to open by remote device.
+   * @param presentationId The Id for representing this session.
+   * @param controlChannel The control channel for this session.
+   */
+  void onSessionRequest(in nsIPresentationDevice device,
+                        in AString url,
+                        in AString presentationId,
+                        in nsIPresentationControlChannel controlChannel);
+
+  /*
+   * Callback while the remote device is requesting to terminate a presentation session.
+   * @param device The remote device that sent session request.
+   * @param presentationId The Id for representing this session.
+   * @param controlChannel The control channel for this session.
+   * @param aIsFromReceiver true if termination is initiated by receiver.
+   */
+  void onTerminateRequest(in nsIPresentationDevice device,
+                          in AString presentationId,
+                          in nsIPresentationControlChannel controlChannel,
+                          in boolean aIsFromReceiver);
+
+  /*
+   * Callback while the remote device is requesting to reconnect a presentation session.
+   * @param device The remote device that sent session request.
+   * @param aUrl The URL requested to open by remote device.
+   * @param presentationId The Id for representing this session.
+   * @param controlChannel The control channel for this session.
+   */
+  void onReconnectRequest(in nsIPresentationDevice device,
+                          in AString url,
+                          in AString presentationId,
+                          in nsIPresentationControlChannel controlChannel);
+};
+
+/*
+ * Device provider for any device protocol, can be registered as default
+ * providers by adding its contractID to category "presentation-device-provider".
+ */
+[scriptable, uuid(3db2578a-0f50-44ad-b01b-28427b71b7bf)]
+interface nsIPresentationDeviceProvider: nsISupports
+{
+  // The listener for handling any device update.
+  attribute nsIPresentationDeviceListener listener;
+
+  /*
+   * Force to update device information.
+   */
+  void forceDiscovery();
+};
diff --git a/dom/presentation/interfaces/nsIPresentationListener.idl b/dom/presentation/interfaces/nsIPresentationListener.idl
new file mode 100644
index 0000000000..609ab27c78
--- /dev/null
+++ b/dom/presentation/interfaces/nsIPresentationListener.idl
@@ -0,0 +1,54 @@
+/* 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 "nsISupports.idl"
+
+%{C++
+#include "nsTArray.h"
+%}
+
+[ref] native URLArrayRef(const nsTArray<nsString>);
+
+[uuid(0105f837-4279-4715-9d5b-2dc3f8b65353)]
+interface nsIPresentationAvailabilityListener : nsISupports
+{
+  /*
+   * Called when device availability changes.
+   */
+  [noscript] void notifyAvailableChange(in URLArrayRef urls,
+                                        in bool available);
+};
+
+[scriptable, uuid(7dd48df8-8f8c-48c7-ac37-7b9fd1acf2f8)]
+interface nsIPresentationSessionListener : nsISupports
+{
+  const unsigned short STATE_CONNECTING = 0;
+  const unsigned short STATE_CONNECTED = 1;
+  const unsigned short STATE_CLOSED = 2;
+  const unsigned short STATE_TERMINATED = 3;
+
+  /*
+   * Called when session state changes.
+   */
+  void notifyStateChange(in AString sessionId,
+                         in unsigned short state,
+                         in nsresult reason);
+
+  /*
+   * Called when receive messages.
+   */
+  void notifyMessage(in AString sessionId,
+                     in ACString data,
+                     in boolean isBinary);
+};
+
+[scriptable, uuid(27f101d7-9ed1-429e-b4f8-43b00e8e111c)]
+interface nsIPresentationRespondingListener : nsISupports
+{
+  /*
+   * Called when an incoming session connects.
+   */
+  void notifySessionConnect(in unsigned long long windowId,
+                            in AString sessionId);
+};
diff --git a/dom/presentation/interfaces/nsIPresentationLocalDevice.idl b/dom/presentation/interfaces/nsIPresentationLocalDevice.idl
new file mode 100644
index 0000000000..80e3b4041f
--- /dev/null
+++ b/dom/presentation/interfaces/nsIPresentationLocalDevice.idl
@@ -0,0 +1,17 @@
+/* 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 "nsIPresentationDevice.idl"
+
+/*
+ * Local device.
+ * This device is used for 1-UA use case. The result for display is rendered by
+ * this host device.
+ */
+[scriptable, uuid(dd239720-cab6-4fb5-9025-cba23f1bbc2d)]
+interface nsIPresentationLocalDevice : nsIPresentationDevice
+{
+  // (1-UA only) The property is used to get the window ID of 1-UA device.
+  readonly attribute AUTF8String windowId;
+};
diff --git a/dom/presentation/interfaces/nsIPresentationNetworkHelper.idl b/dom/presentation/interfaces/nsIPresentationNetworkHelper.idl
new file mode 100644
index 0000000000..514075dfab
--- /dev/null
+++ b/dom/presentation/interfaces/nsIPresentationNetworkHelper.idl
@@ -0,0 +1,36 @@
+/* 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 "nsISupports.idl"
+
+%{C++
+#define PRESENTATION_NETWORK_HELPER_CONTRACTID \
+  "@mozilla.org/presentation-device/networkHelper;1"
+%}
+
+[scriptable, uuid(0a7e134f-ff80-4e73-91e6-12b3134fe568)]
+interface nsIPresentationNetworkHelperListener : nsISupports
+{
+  /**
+   * Called when error occurs.
+   * @param aReason error message.
+   */
+  void onError(in AUTF8String aReason);
+
+  /**
+   * Called when get Wi-Fi IP address.
+   * @param aIPAddress the IP address of Wi-Fi interface.
+   */
+  void onGetWifiIPAddress(in AUTF8String aIPAddress);
+};
+
+[scriptable, uuid(650dc16b-3d9c-49a6-9037-1d6f2d18c90c)]
+interface nsIPresentationNetworkHelper : nsISupports
+{
+  /**
+   * Get IP address of Wi-Fi interface.
+   * @param aListener the callback interface.
+   */
+  void getWifiIPAddress(in nsIPresentationNetworkHelperListener aListener);
+};
diff --git a/dom/presentation/interfaces/nsIPresentationRequestUIGlue.idl b/dom/presentation/interfaces/nsIPresentationRequestUIGlue.idl
new file mode 100644
index 0000000000..162ffb0ad8
--- /dev/null
+++ b/dom/presentation/interfaces/nsIPresentationRequestUIGlue.idl
@@ -0,0 +1,29 @@
+/* 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 "nsISupports.idl"
+
+interface nsIPresentationDevice;
+
+%{C++
+#define PRESENTATION_REQUEST_UI_GLUE_CONTRACTID \
+  "@mozilla.org/presentation/requestuiglue;1"
+%}
+
+[scriptable, uuid(faa45119-6fb5-496c-aa4c-f740177a38b5)]
+interface nsIPresentationRequestUIGlue : nsISupports
+{
+  /*
+   * This method is called to open the responding app/page when
+   * a presentation request comes in at receiver side.
+   *
+   * @param url       The url of the request.
+   * @param sessionId The session ID of the request.
+   *
+   * @return A promise that resolves to the opening frame.
+   */
+  Promise sendRequest(in AString url,
+                      in AString sessionId,
+                      in nsIPresentationDevice device);
+};
diff --git a/dom/presentation/interfaces/nsIPresentationService.idl b/dom/presentation/interfaces/nsIPresentationService.idl
new file mode 100644
index 0000000000..f1bf7ef9c2
--- /dev/null
+++ b/dom/presentation/interfaces/nsIPresentationService.idl
@@ -0,0 +1,276 @@
+/* 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 "nsISupports.idl"
+
+interface nsIInputStream;
+interface nsIPresentationAvailabilityListener;
+interface nsIPresentationRespondingListener;
+interface nsIPresentationSessionListener;
+interface nsIPresentationTransportBuilderConstructor;
+interface nsIPrincipal;
+
+webidl Blob;
+webidl EventTarget;
+
+%{C++
+#define PRESENTATION_SERVICE_CID \
+  { 0x1d9bb10c, 0xc0ab, 0x4fe8, \
+    { 0x9e, 0x4f, 0x40, 0x58, 0xb8, 0x51, 0x98, 0x32 } }
+#define PRESENTATION_SERVICE_CONTRACTID \
+  "@mozilla.org/presentation/presentationservice;1"
+
+#include "nsStringFwd.h"
+#include "nsTArray.h"
+
+%}
+
+[ref] native URLArrayRef(const nsTArray<nsString>);
+
+[scriptable, uuid(12073206-0065-4b10-9488-a6eb9b23e65b)]
+interface nsIPresentationServiceCallback : nsISupports
+{
+  /*
+   * Called when the operation succeeds.
+   *
+   * @param url: the selected request url used to start or reconnect a session.
+   */
+  void notifySuccess(in AString url);
+
+  /*
+   * Called when the operation fails.
+   *
+   * @param error: error message.
+   */
+  void notifyError(in nsresult error);
+};
+
+[scriptable, uuid(de42b741-5619-4650-b961-c2cebb572c95)]
+interface nsIPresentationService : nsISupports
+{
+  const unsigned short ROLE_CONTROLLER = 0x1;
+  const unsigned short ROLE_RECEIVER = 0x2;
+
+  const unsigned short CLOSED_REASON_ERROR = 0x1;
+  const unsigned short CLOSED_REASON_CLOSED = 0x2;
+  const unsigned short CLOSED_REASON_WENTAWAY = 0x3;
+
+  /*
+   * Start a new presentation session and display a prompt box which asks users
+   * to select a device.
+   *
+   * @param urls: The candidate Urls of presenting page. Only one url would be used.
+   * @param sessionId: An ID to identify presentation session.
+   * @param origin: The url of requesting page.
+   * @param deviceId: The specified device of handling this request, null string
+   *                  for prompt device selection dialog.
+   * @param windowId: The inner window ID associated with the presentation
+   *                  session. (0 implies no window ID since no actual window
+   *                  uses 0 as its ID. Generally it's the case the window is
+   *                  located in different process from this service)
+   * @param eventTarget: The chrome event handler, in particular XUL browser
+   *                     element in parent process, that the request was
+   *                     originated in.
+   * @param principal: The principal that initiated the session.
+   * @param callback: Invoke the callback when the operation is completed.
+   *                  NotifySuccess() is called with |id| if a session is
+   *                  established successfully with the selected device.
+   *                  Otherwise, NotifyError() is called with a error message.
+   * @param constructor: The constructor for creating a transport builder.
+   */
+  [noscript] void startSession(in URLArrayRef urls,
+                               in AString sessionId,
+                               in AString origin,
+                               in AString deviceId,
+                               in unsigned long long windowId,
+                               in EventTarget eventTarget,
+                               in nsIPrincipal principal,
+                               in nsIPresentationServiceCallback callback,
+                               in nsIPresentationTransportBuilderConstructor constructor);
+
+  /*
+   * Send the message to the session.
+   *
+   * @param sessionId: An ID to identify presentation session.
+   * @param role: Identify the function called by controller or receiver.
+   * @param data: the message being sent out.
+   */
+  void sendSessionMessage(in AString sessionId,
+                          in uint8_t role,
+                          in AString data);
+
+  /*
+   * Send the binary message to the session.
+   *
+   * @param sessionId: An ID to identify presentation session.
+   * @param role: Identify the function called by controller or receiver.
+   * @param data: the message being sent out.
+   */
+  void sendSessionBinaryMsg(in AString sessionId,
+                            in uint8_t role,
+                            in ACString data);
+
+  /*
+   * Send the blob to the session.
+   *
+   * @param sessionId: An ID to identify presentation session.
+   * @param role: Identify the function called by controller or receiver.
+   * @param blob: The input blob to be sent.
+   */
+  void sendSessionBlob(in AString sessionId,
+                       in uint8_t role,
+                       in Blob blob);
+
+  /*
+   * Close the session.
+   *
+   * @param sessionId: An ID to identify presentation session.
+   * @param role: Identify the function called by controller or receiver.
+   */
+  void closeSession(in AString sessionId,
+                    in uint8_t role,
+                    in uint8_t closedReason);
+
+  /*
+   * Terminate the session.
+   *
+   * @param sessionId: An ID to identify presentation session.
+   * @param role: Identify the function called by controller or receiver.
+   */
+  void terminateSession(in AString sessionId,
+                        in uint8_t role);
+
+  /*
+   * Reconnect the session.
+   *
+   * @param url: The request Urls.
+   * @param sessionId: An ID to identify presentation session.
+   * @param role: Identify the function called by controller or receiver.
+   * @param callback: NotifySuccess() is called when a control channel
+   *                  is opened successfully.
+   *                  Otherwise, NotifyError() is called with a error message.
+   */
+  [noscript] void reconnectSession(in URLArrayRef urls,
+                                   in AString sessionId,
+                                   in uint8_t role,
+                                   in nsIPresentationServiceCallback callback);
+
+  /*
+   * Register an availability listener. Must be called from the main thread.
+   *
+   * @param availabilityUrls: The Urls that this listener is interested in.
+   * @param listener: The listener to register.
+   */
+  [noscript] void registerAvailabilityListener(
+                              in URLArrayRef availabilityUrls,
+                              in nsIPresentationAvailabilityListener listener);
+
+  /*
+   * Unregister an availability listener. Must be called from the main thread.
+   *
+   * @param availabilityUrls: The Urls that are registered before.
+   * @param listener: The listener to unregister.
+   */
+  [noscript] void unregisterAvailabilityListener(
+                              in URLArrayRef availabilityUrls,
+                              in nsIPresentationAvailabilityListener listener);
+
+  /*
+   * Register a session listener. Must be called from the main thread.
+   *
+   * @param sessionId: An ID to identify presentation session.
+   * @param role: Identify the function called by controller or receiver.
+   * @param listener: The listener to register.
+   */
+  void registerSessionListener(in AString sessionId,
+                               in uint8_t role,
+                               in nsIPresentationSessionListener listener);
+
+  /*
+   * Unregister a session listener. Must be called from the main thread.
+   *
+   * @param sessionId: An ID to identify presentation session.
+   * @param role: Identify the function called by controller or receiver.
+   */
+  void unregisterSessionListener(in AString sessionId,
+                                 in uint8_t role);
+
+  /*
+   * Register a responding listener. Must be called from the main thread.
+   *
+   * @param windowId: The window ID associated with the listener.
+   * @param listener: The listener to register.
+   */
+  void registerRespondingListener(in unsigned long long windowId,
+                                  in nsIPresentationRespondingListener listener);
+
+  /*
+   * Unregister a responding listener. Must be called from the main thread.
+   * @param windowId: The window ID associated with the listener.
+   */
+  void unregisterRespondingListener(in unsigned long long windowId);
+
+  /*
+   * Notify the receiver page is ready for presentation use.
+   *
+   * @param sessionId An ID to identify presentation session.
+   * @param windowId  The inner window ID associated with the presentation
+   *                  session.
+   * @param isLoading true if receiver page is loading successfully.
+   * @param constructor: The constructor for creating a transport builder.
+   */
+  void notifyReceiverReady(in AString sessionId,
+                           in unsigned long long windowId,
+                           in boolean isLoading,
+                           in nsIPresentationTransportBuilderConstructor constructor);
+
+  /*
+   * Notify the transport is closed
+   *
+   * @param sessionId: An ID to identify presentation session.
+   * @param role: Identify the function called by controller or receiver.
+   * @param reason: the error message. NS_OK indicates it is closed normally.
+   */
+  void NotifyTransportClosed(in AString sessionId,
+                             in uint8_t role,
+                             in nsresult reason);
+
+  /*
+   * Untrack the relevant info about the presentation session if there's any.
+   *
+   * @param sessionId: An ID to identify presentation session.
+   * @param role: Identify the function called by controller or receiver.
+   */
+  void untrackSessionInfo(in AString sessionId, in uint8_t role);
+
+  /*
+   * The windowId for building RTCDataChannel session transport
+   *
+   * @param sessionId: An ID to identify presentation session.
+   * @param role: Identify the function called by controller or receiver.
+   */
+  unsigned long long getWindowIdBySessionId(in AString sessionId,
+                                            in uint8_t role);
+
+  /*
+   * Update the mapping of the session ID and window ID.
+   *
+   * @param sessionId: An ID to identify presentation session.
+   * @param role: Identify the function called by controller or receiver.
+   * @param windowId: The inner window ID associated with the presentation
+   *                  session.
+   */
+  void updateWindowIdBySessionId(in AString sessionId,
+                                 in uint8_t role,
+                                 in unsigned long long windowId);
+
+  /*
+   * To build the session transport.
+   * NOTE: This function should be only called at controller side.
+   *
+   * @param sessionId: An ID to identify presentation session.
+   * @param role: Identify the function called by controller or receiver.
+   */
+  void buildTransport(in AString sessionId, in uint8_t role);
+};
diff --git a/dom/presentation/interfaces/nsIPresentationSessionRequest.idl b/dom/presentation/interfaces/nsIPresentationSessionRequest.idl
new file mode 100644
index 0000000000..a145aaeed7
--- /dev/null
+++ b/dom/presentation/interfaces/nsIPresentationSessionRequest.idl
@@ -0,0 +1,35 @@
+/* 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 "nsISupports.idl"
+
+interface nsIPresentationDevice;
+interface nsIPresentationControlChannel;
+
+%{C++
+#define PRESENTATION_SESSION_REQUEST_TOPIC "presentation-session-request"
+#define PRESENTATION_RECONNECT_REQUEST_TOPIC "presentation-reconnect-request"
+%}
+
+/*
+ * The event of a device requesting for starting or reconnecting
+ * a presentation session. User can monitor the session request
+ * on every device by observing "presentation-sesion-request" for a
+ * new session and "presentation-reconnect-request" for reconnecting.
+ */
+[scriptable, uuid(d808a084-d0f8-455a-a8df-5879e05a755b)]
+interface nsIPresentationSessionRequest: nsISupports
+{
+  // The device which requesting the presentation session.
+  readonly attribute nsIPresentationDevice device;
+
+  // The URL requested to open by remote device.
+  readonly attribute AString url;
+
+  // The Id for representing this session.
+  readonly attribute AString presentationId;
+
+  // The control channel for this session.
+  readonly attribute nsIPresentationControlChannel controlChannel;
+};
diff --git a/dom/presentation/interfaces/nsIPresentationSessionTransport.idl b/dom/presentation/interfaces/nsIPresentationSessionTransport.idl
new file mode 100644
index 0000000000..f5b7187b21
--- /dev/null
+++ b/dom/presentation/interfaces/nsIPresentationSessionTransport.idl
@@ -0,0 +1,70 @@
+/* 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 "nsISupports.idl"
+
+interface nsIInputStream;
+interface nsINetAddr;
+
+webidl Blob;
+
+%{C++
+#define PRESENTATION_TCP_SESSION_TRANSPORT_CONTRACTID \
+  "@mozilla.org/presentation/presentationtcpsessiontransport;1"
+%}
+
+/*
+ * The callback for session transport events.
+ */
+[scriptable, uuid(9f158786-41a6-4a10-b29b-9497f25d4b67)]
+interface nsIPresentationSessionTransportCallback : nsISupports
+{
+  void notifyTransportReady();
+  void notifyTransportClosed(in nsresult reason);
+  void notifyData(in ACString data, in boolean isBinary);
+};
+
+/*
+ * App-to-App transport channel for the presentation session.
+ */
+[scriptable, uuid(670b7e1b-65be-42b6-a596-be571907fa18)]
+interface nsIPresentationSessionTransport : nsISupports
+{
+  // Should be set once the underlying session transport is built
+  attribute nsIPresentationSessionTransportCallback callback;
+
+  // valid for TCP session transport
+  readonly attribute nsINetAddr selfAddress;
+
+  /*
+   * Enable the notification for incoming data. |notifyData| of
+   * |nsIPresentationSessionTransportCallback| can start getting invoked.
+   * Should set callback before |enableDataNotification| is called.
+   */
+  void enableDataNotification();
+
+  /*
+   * Send message to the remote endpoint.
+   * @param data The message to send.
+   */
+  void send(in AString data);
+
+  /*
+   * Send the binary message to the remote endpoint.
+   * @param data: the message being sent out.
+   */
+  void sendBinaryMsg(in ACString data);
+
+  /*
+   * Send the blob to the remote endpoint.
+   * @param blob: The input blob to be sent.
+   */
+  void sendBlob(in Blob blob);
+
+  /*
+   * Close this session transport.
+   * @param reason The reason for closing this session transport.
+   */
+  void close(in nsresult reason);
+};
diff --git a/dom/presentation/interfaces/nsIPresentationSessionTransportBuilder.idl b/dom/presentation/interfaces/nsIPresentationSessionTransportBuilder.idl
new file mode 100644
index 0000000000..4b9d46db98
--- /dev/null
+++ b/dom/presentation/interfaces/nsIPresentationSessionTransportBuilder.idl
@@ -0,0 +1,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 "nsISupports.idl"
+
+interface nsIPresentationChannelDescription;
+interface nsISocketTransport;
+interface mozIDOMWindow;
+interface nsIPresentationControlChannel;
+interface nsIPresentationSessionTransport;
+
+[scriptable, uuid(673f6de1-e253-41b8-9be8-b7ff161fa8dc)]
+interface nsIPresentationSessionTransportBuilderListener : nsISupports
+{
+  // Should set |transport.callback| in |onSessionTransport|.
+  void onSessionTransport(in nsIPresentationSessionTransport transport);
+  void onError(in nsresult reason);
+
+  void sendOffer(in nsIPresentationChannelDescription offer);
+  void sendAnswer(in nsIPresentationChannelDescription answer);
+  void sendIceCandidate(in AString candidate);
+  void close(in nsresult reason);
+};
+
+[scriptable, uuid(2fdbe67d-80f9-48dc-8237-5bef8fa19801)]
+interface nsIPresentationSessionTransportBuilder : nsISupports
+{
+};
+
+/**
+ * The constructor for creating a transport builder.
+ */
+[scriptable, uuid(706482b2-1b51-4bed-a21d-785a9cfcfac7)]
+interface nsIPresentationTransportBuilderConstructor : nsISupports
+{
+  nsIPresentationSessionTransportBuilder createTransportBuilder(in uint8_t type);
+};
+
+/**
+ * Builder for TCP session transport
+ */
+[scriptable, uuid(cde36d6e-f471-4262-a70d-f932a26b21d9)]
+interface nsIPresentationTCPSessionTransportBuilder : nsIPresentationSessionTransportBuilder
+{
+  /**
+   * The following creation functions will trigger |listener.onSessionTransport|
+   * if the session transport is successfully built, |listener.onError| if some
+   * error occurs during building session transport.
+   */
+  void buildTCPSenderTransport(in nsISocketTransport aTransport,
+                               in nsIPresentationSessionTransportBuilderListener aListener);
+
+  void buildTCPReceiverTransport(in nsIPresentationChannelDescription aDescription,
+                                 in nsIPresentationSessionTransportBuilderListener aListener);
+};
+
+/**
+ * Builder for WebRTC data channel session transport
+ */
+[scriptable, uuid(8131c4e0-3a8c-4bc1-a92a-8431473d2fe8)]
+interface nsIPresentationDataChannelSessionTransportBuilder : nsIPresentationSessionTransportBuilder
+{
+  /**
+   * The following creation function will trigger |listener.onSessionTransport|
+   * if the session transport is successfully built, |listener.onError| if some
+   * error occurs during creating session transport. The |notifyConnected| of
+   * |aControlChannel| should be called before calling
+   * |buildDataChannelTransport|.
+   */
+  void buildDataChannelTransport(in uint8_t aRole,
+                                 in mozIDOMWindow aWindow,
+                                 in nsIPresentationSessionTransportBuilderListener aListener);
+
+  // Bug 1275150 - Merge TCP builder with the following APIs
+  void onOffer(in nsIPresentationChannelDescription offer);
+  void onAnswer(in nsIPresentationChannelDescription answer);
+  void onIceCandidate(in AString candidate);
+  void notifyDisconnected(in nsresult reason);
+};
diff --git a/dom/presentation/interfaces/nsIPresentationTerminateRequest.idl b/dom/presentation/interfaces/nsIPresentationTerminateRequest.idl
new file mode 100644
index 0000000000..cbfd486e9e
--- /dev/null
+++ b/dom/presentation/interfaces/nsIPresentationTerminateRequest.idl
@@ -0,0 +1,33 @@
+/* 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 "nsISupports.idl"
+
+interface nsIPresentationDevice;
+interface nsIPresentationControlChannel;
+
+%{C++
+#define PRESENTATION_TERMINATE_REQUEST_TOPIC "presentation-terminate-request"
+%}
+
+/*
+ * The event of a device requesting for terminating a presentation session. User can
+ * monitor the terminate request on every device by observing "presentation-terminate-request".
+ */
+[scriptable, uuid(3ddbf3a4-53ee-4b70-9bbc-58ac90dce6b5)]
+interface nsIPresentationTerminateRequest: nsISupports
+{
+  // The device which requesting to terminate presentation session.
+  readonly attribute nsIPresentationDevice device;
+
+  // The Id for representing this session.
+  readonly attribute AString presentationId;
+
+  // The control channel for this session.
+  // Should only use this channel to complete session termination.
+  readonly attribute nsIPresentationControlChannel controlChannel;
+
+  // True if termination is initiated by receiver.
+  readonly attribute boolean isFromReceiver;
+};
diff --git a/dom/presentation/ipc/PPresentation.ipdl b/dom/presentation/ipc/PPresentation.ipdl
new file mode 100644
index 0000000000..bfaca8fb57
--- /dev/null
+++ b/dom/presentation/ipc/PPresentation.ipdl
@@ -0,0 +1,114 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set sw=2 ts=8 et ft=cpp : */
+/* 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 PContent;
+include protocol PPresentationRequest;
+include protocol PPresentationBuilder;
+
+include InputStreamParams;
+
+include "mozilla/dom/PermissionMessageUtils.h";
+
+using refcounted class nsIPrincipal from "nsIPrincipal.h";
+using mozilla::dom::TabId from "mozilla/dom/ipc/IdType.h";
+
+namespace mozilla {
+namespace dom {
+
+struct StartSessionRequest
+{
+  nsString[] urls;
+  nsString sessionId;
+  nsString origin;
+  nsString deviceId;
+  uint64_t windowId;
+  TabId tabId;
+  nsIPrincipal principal;
+};
+
+struct SendSessionMessageRequest
+{
+  nsString sessionId;
+  uint8_t role;
+  nsString data;
+};
+
+struct CloseSessionRequest
+{
+  nsString sessionId;
+  uint8_t role;
+  uint8_t closedReason;
+};
+
+struct TerminateSessionRequest
+{
+  nsString sessionId;
+  uint8_t role;
+};
+
+struct ReconnectSessionRequest
+{
+  nsString[] urls;
+  nsString sessionId;
+  uint8_t role;
+};
+
+struct BuildTransportRequest
+{
+  nsString sessionId;
+  uint8_t role;
+};
+
+union PresentationIPCRequest
+{
+  StartSessionRequest;
+  SendSessionMessageRequest;
+  CloseSessionRequest;
+  TerminateSessionRequest;
+  ReconnectSessionRequest;
+  BuildTransportRequest;
+};
+
+sync protocol PPresentation
+{
+  manager PContent;
+  manages PPresentationBuilder;
+  manages PPresentationRequest;
+
+child:
+  async NotifyAvailableChange(nsString[] aAvailabilityUrls,
+                              bool aAvailable);
+  async NotifySessionStateChange(nsString aSessionId,
+                                 uint16_t aState,
+                                 nsresult aReason);
+  async NotifyMessage(nsString aSessionId, nsCString aData, bool aIsBinary);
+  async NotifySessionConnect(uint64_t aWindowId, nsString aSessionId);
+  async NotifyCloseSessionTransport(nsString aSessionId,
+                                    uint8_t aRole,
+                                    nsresult aReason);
+
+  async PPresentationBuilder(nsString aSessionId, uint8_t aRole);
+
+parent:
+  async __delete__();
+
+  async RegisterAvailabilityHandler(nsString[] aAvailabilityUrls);
+  async UnregisterAvailabilityHandler(nsString[] aAvailabilityUrls);
+
+  async RegisterSessionHandler(nsString aSessionId, uint8_t aRole);
+  async UnregisterSessionHandler(nsString aSessionId, uint8_t aRole);
+
+  async RegisterRespondingHandler(uint64_t aWindowId);
+  async UnregisterRespondingHandler(uint64_t aWindowId);
+
+  async PPresentationRequest(PresentationIPCRequest aRequest);
+
+  async NotifyReceiverReady(nsString aSessionId, uint64_t aWindowId, bool aIsLoading);
+  async NotifyTransportClosed(nsString aSessionId, uint8_t aRole, nsresult aReason);
+};
+
+} // namespace dom
+} // namespace mozilla
diff --git a/dom/presentation/ipc/PPresentationBuilder.ipdl b/dom/presentation/ipc/PPresentationBuilder.ipdl
new file mode 100644
index 0000000000..e32b02e8f3
--- /dev/null
+++ b/dom/presentation/ipc/PPresentationBuilder.ipdl
@@ -0,0 +1,34 @@
+/* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
+/* vim: set ts=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 protocol PPresentation;
+
+namespace mozilla {
+namespace dom {
+
+async protocol PPresentationBuilder
+{
+  manager PPresentation;
+
+parent:
+  async SendOffer(nsString aSDP);
+  async SendAnswer(nsString aSDP);
+  async SendIceCandidate(nsString aCandidate);
+  async Close(nsresult aReason);
+
+  async OnSessionTransport();
+  async OnSessionTransportError(nsresult aReason);
+
+child:
+  async OnOffer(nsString aSDP);
+  async OnAnswer(nsString aSDP);
+  async OnIceCandidate(nsString aCandidate);
+
+  async __delete__();
+};
+
+} // namespace dom
+} // namespace mozilla
diff --git a/dom/presentation/ipc/PPresentationRequest.ipdl b/dom/presentation/ipc/PPresentationRequest.ipdl
new file mode 100644
index 0000000000..fa99dfcabb
--- /dev/null
+++ b/dom/presentation/ipc/PPresentationRequest.ipdl
@@ -0,0 +1,22 @@
+/* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
+/* vim: set ts=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 protocol PPresentation;
+
+namespace mozilla {
+namespace dom {
+
+sync protocol PPresentationRequest
+{
+  manager PPresentation;
+
+child:
+  async __delete__(nsresult result);
+  async NotifyRequestUrlSelected(nsString aUrl);
+};
+
+} // namespace dom
+} // namespace mozilla
diff --git a/dom/presentation/ipc/PresentationBuilderChild.cpp b/dom/presentation/ipc/PresentationBuilderChild.cpp
new file mode 100644
index 0000000000..d4e1120392
--- /dev/null
+++ b/dom/presentation/ipc/PresentationBuilderChild.cpp
@@ -0,0 +1,172 @@
+/* -*- 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 "DCPresentationChannelDescription.h"
+#include "nsComponentManagerUtils.h"
+#include "nsGlobalWindow.h"
+#include "PresentationBuilderChild.h"
+#include "PresentationIPCService.h"
+#include "nsServiceManagerUtils.h"
+#include "mozilla/Unused.h"
+
+namespace mozilla {
+namespace dom {
+
+NS_IMPL_ISUPPORTS(PresentationBuilderChild,
+                  nsIPresentationSessionTransportBuilderListener)
+
+PresentationBuilderChild::PresentationBuilderChild(const nsString& aSessionId,
+                                                   uint8_t aRole)
+    : mSessionId(aSessionId), mRole(aRole) {}
+
+nsresult PresentationBuilderChild::Init() {
+  mBuilder = do_CreateInstance(
+      "@mozilla.org/presentation/datachanneltransportbuilder;1");
+  if (NS_WARN_IF(!mBuilder)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  uint64_t windowId = 0;
+
+  nsCOMPtr<nsIPresentationService> service =
+      do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+  if (NS_WARN_IF(!service)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  if (NS_WARN_IF(NS_FAILED(
+          service->GetWindowIdBySessionId(mSessionId, mRole, &windowId)))) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  nsPIDOMWindowInner* window =
+      nsGlobalWindowInner::GetInnerWindowWithId(windowId);
+  if (NS_WARN_IF(!window)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  return mBuilder->BuildDataChannelTransport(mRole, window, this);
+}
+
+void PresentationBuilderChild::ActorDestroy(ActorDestroyReason aWhy) {
+  mBuilder = nullptr;
+  mActorDestroyed = true;
+}
+
+mozilla::ipc::IPCResult PresentationBuilderChild::RecvOnOffer(
+    const nsString& aSDP) {
+  if (NS_WARN_IF(!mBuilder)) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  RefPtr<DCPresentationChannelDescription> description =
+      new DCPresentationChannelDescription(aSDP);
+
+  if (NS_WARN_IF(NS_FAILED(mBuilder->OnOffer(description)))) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult PresentationBuilderChild::RecvOnAnswer(
+    const nsString& aSDP) {
+  if (NS_WARN_IF(!mBuilder)) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  RefPtr<DCPresentationChannelDescription> description =
+      new DCPresentationChannelDescription(aSDP);
+
+  if (NS_WARN_IF(NS_FAILED(mBuilder->OnAnswer(description)))) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult PresentationBuilderChild::RecvOnIceCandidate(
+    const nsString& aCandidate) {
+  if (NS_WARN_IF(mBuilder && NS_FAILED(mBuilder->OnIceCandidate(aCandidate)))) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  return IPC_OK();
+}
+
+// nsPresentationSessionTransportBuilderListener
+NS_IMETHODIMP
+PresentationBuilderChild::OnSessionTransport(
+    nsIPresentationSessionTransport* aTransport) {
+  if (NS_WARN_IF(mActorDestroyed || !SendOnSessionTransport())) {
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIPresentationService> service =
+      do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+  NS_WARNING_ASSERTION(service, "no presentation service");
+  if (service) {
+    Unused << NS_WARN_IF(
+        NS_FAILED(static_cast<PresentationIPCService*>(service.get())
+                      ->NotifySessionTransport(mSessionId, mRole, aTransport)));
+  }
+  mBuilder = nullptr;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationBuilderChild::OnError(nsresult reason) {
+  mBuilder = nullptr;
+
+  if (NS_WARN_IF(mActorDestroyed || !SendOnSessionTransportError(reason))) {
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationBuilderChild::SendOffer(nsIPresentationChannelDescription* aOffer) {
+  nsAutoString SDP;
+  nsresult rv = aOffer->GetDataChannelSDP(SDP);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  if (NS_WARN_IF(mActorDestroyed || !SendSendOffer(SDP))) {
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationBuilderChild::SendAnswer(
+    nsIPresentationChannelDescription* aAnswer) {
+  nsAutoString SDP;
+  nsresult rv = aAnswer->GetDataChannelSDP(SDP);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  if (NS_WARN_IF(mActorDestroyed || !SendSendAnswer(SDP))) {
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationBuilderChild::SendIceCandidate(const nsAString& candidate) {
+  if (NS_WARN_IF(mActorDestroyed ||
+                 !SendSendIceCandidate(nsString(candidate)))) {
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationBuilderChild::Close(nsresult reason) {
+  if (NS_WARN_IF(mActorDestroyed || !SendClose(reason))) {
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/presentation/ipc/PresentationBuilderChild.h b/dom/presentation/ipc/PresentationBuilderChild.h
new file mode 100644
index 0000000000..8da43245da
--- /dev/null
+++ b/dom/presentation/ipc/PresentationBuilderChild.h
@@ -0,0 +1,47 @@
+/* -*- 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_PresentationBuilderChild_h
+#define mozilla_dom_PresentationBuilderChild_h
+
+#include "mozilla/dom/PPresentationBuilderChild.h"
+#include "nsIPresentationSessionTransportBuilder.h"
+
+namespace mozilla {
+namespace dom {
+
+class PresentationBuilderChild final
+    : public PPresentationBuilderChild,
+      public nsIPresentationSessionTransportBuilderListener {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPRESENTATIONSESSIONTRANSPORTBUILDERLISTENER
+
+  explicit PresentationBuilderChild(const nsString& aSessionId, uint8_t aRole);
+
+  nsresult Init();
+
+  virtual void ActorDestroy(ActorDestroyReason aWhy) override;
+
+  mozilla::ipc::IPCResult RecvOnOffer(const nsString& aSDP);
+
+  mozilla::ipc::IPCResult RecvOnAnswer(const nsString& aSDP);
+
+  mozilla::ipc::IPCResult RecvOnIceCandidate(const nsString& aCandidate);
+
+ private:
+  virtual ~PresentationBuilderChild() = default;
+
+  nsString mSessionId;
+  uint8_t mRole;
+  bool mActorDestroyed = false;
+  nsCOMPtr<nsIPresentationDataChannelSessionTransportBuilder> mBuilder;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_PresentationBuilderChild_h
diff --git a/dom/presentation/ipc/PresentationBuilderParent.cpp b/dom/presentation/ipc/PresentationBuilderParent.cpp
new file mode 100644
index 0000000000..cc451d7465
--- /dev/null
+++ b/dom/presentation/ipc/PresentationBuilderParent.cpp
@@ -0,0 +1,228 @@
+/* -*- 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 "DCPresentationChannelDescription.h"
+#include "PresentationBuilderParent.h"
+#include "PresentationSessionInfo.h"
+
+namespace mozilla {
+namespace dom {
+
+namespace {
+
+class PresentationSessionTransportIPC final
+    : public nsIPresentationSessionTransport {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPRESENTATIONSESSIONTRANSPORT
+
+  PresentationSessionTransportIPC(PresentationParent* aParent,
+                                  const nsAString& aSessionId, uint8_t aRole)
+      : mParent(aParent), mSessionId(aSessionId), mRole(aRole) {
+    MOZ_ASSERT(mParent);
+  }
+
+ private:
+  virtual ~PresentationSessionTransportIPC() = default;
+
+  RefPtr<PresentationParent> mParent;
+  nsString mSessionId;
+  uint8_t mRole;
+};
+
+NS_IMPL_ISUPPORTS(PresentationSessionTransportIPC,
+                  nsIPresentationSessionTransport)
+
+NS_IMETHODIMP
+PresentationSessionTransportIPC::GetCallback(
+    nsIPresentationSessionTransportCallback** aCallback) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationSessionTransportIPC::SetCallback(
+    nsIPresentationSessionTransportCallback* aCallback) {
+  if (aCallback) {
+    aCallback->NotifyTransportReady();
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationSessionTransportIPC::GetSelfAddress(nsINetAddr** aSelfAddress) {
+  MOZ_ASSERT(false, "Not expected.");
+  return NS_ERROR_FAILURE;
+}
+
+NS_IMETHODIMP
+PresentationSessionTransportIPC::EnableDataNotification() { return NS_OK; }
+
+NS_IMETHODIMP
+PresentationSessionTransportIPC::Send(const nsAString& aData) { return NS_OK; }
+
+NS_IMETHODIMP
+PresentationSessionTransportIPC::SendBinaryMsg(const nsACString& aData) {
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationSessionTransportIPC::SendBlob(Blob* aBlob) { return NS_OK; }
+
+NS_IMETHODIMP
+PresentationSessionTransportIPC::Close(nsresult aReason) {
+  if (NS_WARN_IF(!mParent->SendNotifyCloseSessionTransport(mSessionId, mRole,
+                                                           aReason))) {
+    return NS_ERROR_FAILURE;
+  }
+
+  return NS_OK;
+}
+
+}  // anonymous namespace
+
+NS_IMPL_ISUPPORTS(PresentationBuilderParent,
+                  nsIPresentationSessionTransportBuilder,
+                  nsIPresentationDataChannelSessionTransportBuilder)
+
+PresentationBuilderParent::PresentationBuilderParent(
+    PresentationParent* aParent)
+    : mParent(aParent) {}
+
+PresentationBuilderParent::~PresentationBuilderParent() {
+  if (mNeedDestroyActor) {
+    Unused << NS_WARN_IF(!Send__delete__(this));
+  }
+}
+
+NS_IMETHODIMP
+PresentationBuilderParent::BuildDataChannelTransport(
+    uint8_t aRole, mozIDOMWindow* aWindow, /* unused */
+    nsIPresentationSessionTransportBuilderListener* aListener) {
+  mBuilderListener = aListener;
+
+  RefPtr<PresentationSessionInfo> info =
+      static_cast<PresentationSessionInfo*>(aListener);
+  nsAutoString sessionId(info->GetSessionId());
+  if (NS_WARN_IF(!mParent->SendPPresentationBuilderConstructor(this, sessionId,
+                                                               aRole))) {
+    return NS_ERROR_FAILURE;
+  }
+  mIPCSessionTransport =
+      new PresentationSessionTransportIPC(mParent, sessionId, aRole);
+  mNeedDestroyActor = true;
+  mParent = nullptr;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationBuilderParent::OnIceCandidate(const nsAString& aCandidate) {
+  if (NS_WARN_IF(!SendOnIceCandidate(nsString(aCandidate)))) {
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationBuilderParent::OnOffer(
+    nsIPresentationChannelDescription* aDescription) {
+  nsAutoString SDP;
+  nsresult rv = aDescription->GetDataChannelSDP(SDP);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  if (NS_WARN_IF(!SendOnOffer(SDP))) {
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationBuilderParent::OnAnswer(
+    nsIPresentationChannelDescription* aDescription) {
+  nsAutoString SDP;
+  nsresult rv = aDescription->GetDataChannelSDP(SDP);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  if (NS_WARN_IF(!SendOnAnswer(SDP))) {
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationBuilderParent::NotifyDisconnected(nsresult aReason) {
+  return NS_OK;
+}
+
+void PresentationBuilderParent::ActorDestroy(ActorDestroyReason aWhy) {
+  mNeedDestroyActor = false;
+  mParent = nullptr;
+  mBuilderListener = nullptr;
+}
+
+mozilla::ipc::IPCResult PresentationBuilderParent::RecvSendOffer(
+    const nsString& aSDP) {
+  RefPtr<DCPresentationChannelDescription> description =
+      new DCPresentationChannelDescription(aSDP);
+  if (NS_WARN_IF(!mBuilderListener ||
+                 NS_FAILED(mBuilderListener->SendOffer(description)))) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult PresentationBuilderParent::RecvSendAnswer(
+    const nsString& aSDP) {
+  RefPtr<DCPresentationChannelDescription> description =
+      new DCPresentationChannelDescription(aSDP);
+  if (NS_WARN_IF(!mBuilderListener ||
+                 NS_FAILED(mBuilderListener->SendAnswer(description)))) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult PresentationBuilderParent::RecvSendIceCandidate(
+    const nsString& aCandidate) {
+  if (NS_WARN_IF(!mBuilderListener ||
+                 NS_FAILED(mBuilderListener->SendIceCandidate(aCandidate)))) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult PresentationBuilderParent::RecvClose(
+    const nsresult& aReason) {
+  if (NS_WARN_IF(!mBuilderListener ||
+                 NS_FAILED(mBuilderListener->Close(aReason)))) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  return IPC_OK();
+}
+
+// Delegate to nsIPresentationSessionTransportBuilderListener
+mozilla::ipc::IPCResult PresentationBuilderParent::RecvOnSessionTransport() {
+  RefPtr<PresentationBuilderParent> kungFuDeathGrip = this;
+  Unused << NS_WARN_IF(
+      !mBuilderListener ||
+      NS_FAILED(mBuilderListener->OnSessionTransport(mIPCSessionTransport)));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult PresentationBuilderParent::RecvOnSessionTransportError(
+    const nsresult& aReason) {
+  if (NS_WARN_IF(!mBuilderListener ||
+                 NS_FAILED(mBuilderListener->OnError(aReason)))) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  return IPC_OK();
+}
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/presentation/ipc/PresentationBuilderParent.h b/dom/presentation/ipc/PresentationBuilderParent.h
new file mode 100644
index 0000000000..6f8e097c16
--- /dev/null
+++ b/dom/presentation/ipc/PresentationBuilderParent.h
@@ -0,0 +1,52 @@
+/* -*- 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_PresentationBuilderParent_h__
+#define mozilla_dom_PresentationBuilderParent_h__
+
+#include "mozilla/dom/PPresentationBuilderParent.h"
+#include "PresentationParent.h"
+#include "nsIPresentationSessionTransportBuilder.h"
+
+namespace mozilla {
+namespace dom {
+
+class PresentationBuilderParent final
+    : public PPresentationBuilderParent,
+      public nsIPresentationDataChannelSessionTransportBuilder {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPRESENTATIONSESSIONTRANSPORTBUILDER
+  NS_DECL_NSIPRESENTATIONDATACHANNELSESSIONTRANSPORTBUILDER
+
+  explicit PresentationBuilderParent(PresentationParent* aParent);
+
+  mozilla::ipc::IPCResult RecvSendOffer(const nsString& aSDP);
+
+  mozilla::ipc::IPCResult RecvSendAnswer(const nsString& aSDP);
+
+  mozilla::ipc::IPCResult RecvSendIceCandidate(const nsString& aCandidate);
+
+  mozilla::ipc::IPCResult RecvClose(const nsresult& aReason);
+
+  virtual void ActorDestroy(ActorDestroyReason aWhy) override;
+
+  mozilla::ipc::IPCResult RecvOnSessionTransport();
+
+  mozilla::ipc::IPCResult RecvOnSessionTransportError(const nsresult& aReason);
+
+ private:
+  virtual ~PresentationBuilderParent();
+  bool mNeedDestroyActor = false;
+  RefPtr<PresentationParent> mParent;
+  nsCOMPtr<nsIPresentationSessionTransportBuilderListener> mBuilderListener;
+  nsCOMPtr<nsIPresentationSessionTransport> mIPCSessionTransport;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_PresentationBuilderParent_h__
diff --git a/dom/presentation/ipc/PresentationChild.cpp b/dom/presentation/ipc/PresentationChild.cpp
new file mode 100644
index 0000000000..77737e2e5e
--- /dev/null
+++ b/dom/presentation/ipc/PresentationChild.cpp
@@ -0,0 +1,173 @@
+/* -*- 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 "DCPresentationChannelDescription.h"
+#include "mozilla/StaticPtr.h"
+#include "PresentationBuilderChild.h"
+#include "PresentationChild.h"
+#include "PresentationIPCService.h"
+#include "nsThreadUtils.h"
+
+namespace mozilla {
+namespace dom {
+
+/*
+ * Implementation of PresentationChild
+ */
+
+PresentationChild::PresentationChild(PresentationIPCService* aService)
+    : mActorDestroyed(false), mService(aService) {
+  MOZ_ASSERT(mService);
+
+  MOZ_COUNT_CTOR(PresentationChild);
+}
+
+PresentationChild::~PresentationChild() {
+  MOZ_COUNT_DTOR(PresentationChild);
+
+  if (!mActorDestroyed) {
+    Send__delete__(this);
+  }
+  mService = nullptr;
+}
+
+void PresentationChild::ActorDestroy(ActorDestroyReason aWhy) {
+  mActorDestroyed = true;
+  mService->NotifyPresentationChildDestroyed();
+  mService = nullptr;
+}
+
+PPresentationRequestChild* PresentationChild::AllocPPresentationRequestChild(
+    const PresentationIPCRequest& aRequest) {
+  MOZ_ASSERT_UNREACHABLE(
+      "We should never be manually allocating "
+      "PPresentationRequestChild actors");
+  return nullptr;
+}
+
+bool PresentationChild::DeallocPPresentationRequestChild(
+    PPresentationRequestChild* aActor) {
+  delete aActor;
+  return true;
+}
+
+mozilla::ipc::IPCResult PresentationChild::RecvPPresentationBuilderConstructor(
+    PPresentationBuilderChild* aActor, const nsString& aSessionId,
+    const uint8_t& aRole) {
+  // Child will build the session transport
+  PresentationBuilderChild* actor =
+      static_cast<PresentationBuilderChild*>(aActor);
+  if (NS_WARN_IF(NS_FAILED(actor->Init()))) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  return IPC_OK();
+}
+
+PPresentationBuilderChild* PresentationChild::AllocPPresentationBuilderChild(
+    const nsString& aSessionId, const uint8_t& aRole) {
+  RefPtr<PresentationBuilderChild> actor =
+      new PresentationBuilderChild(aSessionId, aRole);
+
+  return actor.forget().take();
+}
+
+bool PresentationChild::DeallocPPresentationBuilderChild(
+    PPresentationBuilderChild* aActor) {
+  RefPtr<PresentationBuilderChild> actor =
+      dont_AddRef(static_cast<PresentationBuilderChild*>(aActor));
+  return true;
+}
+
+mozilla::ipc::IPCResult PresentationChild::RecvNotifyAvailableChange(
+    nsTArray<nsString>&& aAvailabilityUrls, const bool& aAvailable) {
+  if (mService) {
+    Unused << NS_WARN_IF(NS_FAILED(
+        mService->NotifyAvailableChange(aAvailabilityUrls, aAvailable)));
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult PresentationChild::RecvNotifySessionStateChange(
+    const nsString& aSessionId, const uint16_t& aState,
+    const nsresult& aReason) {
+  if (mService) {
+    Unused << NS_WARN_IF(NS_FAILED(
+        mService->NotifySessionStateChange(aSessionId, aState, aReason)));
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult PresentationChild::RecvNotifyMessage(
+    const nsString& aSessionId, const nsCString& aData, const bool& aIsBinary) {
+  if (mService) {
+    Unused << NS_WARN_IF(
+        NS_FAILED(mService->NotifyMessage(aSessionId, aData, aIsBinary)));
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult PresentationChild::RecvNotifySessionConnect(
+    const uint64_t& aWindowId, const nsString& aSessionId) {
+  if (mService) {
+    Unused << NS_WARN_IF(
+        NS_FAILED(mService->NotifySessionConnect(aWindowId, aSessionId)));
+  }
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult PresentationChild::RecvNotifyCloseSessionTransport(
+    const nsString& aSessionId, const uint8_t& aRole, const nsresult& aReason) {
+  if (mService) {
+    Unused << NS_WARN_IF(NS_FAILED(
+        mService->CloseContentSessionTransport(aSessionId, aRole, aReason)));
+  }
+  return IPC_OK();
+}
+
+/*
+ * Implementation of PresentationRequestChild
+ */
+
+PresentationRequestChild::PresentationRequestChild(
+    nsIPresentationServiceCallback* aCallback)
+    : mActorDestroyed(false), mCallback(aCallback) {
+  MOZ_COUNT_CTOR(PresentationRequestChild);
+}
+
+PresentationRequestChild::~PresentationRequestChild() {
+  MOZ_COUNT_DTOR(PresentationRequestChild);
+
+  mCallback = nullptr;
+}
+
+void PresentationRequestChild::ActorDestroy(ActorDestroyReason aWhy) {
+  mActorDestroyed = true;
+  mCallback = nullptr;
+}
+
+mozilla::ipc::IPCResult PresentationRequestChild::Recv__delete__(
+    const nsresult& aResult) {
+  if (mActorDestroyed) {
+    return IPC_OK();
+  }
+
+  if (mCallback) {
+    if (NS_FAILED(aResult)) {
+      Unused << NS_WARN_IF(NS_FAILED(mCallback->NotifyError(aResult)));
+    }
+  }
+
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult PresentationRequestChild::RecvNotifyRequestUrlSelected(
+    const nsString& aUrl) {
+  Unused << NS_WARN_IF(NS_FAILED(mCallback->NotifySuccess(aUrl)));
+  return IPC_OK();
+}
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/presentation/ipc/PresentationChild.h b/dom/presentation/ipc/PresentationChild.h
new file mode 100644
index 0000000000..3c02353350
--- /dev/null
+++ b/dom/presentation/ipc/PresentationChild.h
@@ -0,0 +1,88 @@
+/* -*- 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_PresentationChild_h
+#define mozilla_dom_PresentationChild_h
+
+#include "mozilla/dom/PPresentationBuilderChild.h"
+#include "mozilla/dom/PPresentationChild.h"
+#include "mozilla/dom/PPresentationRequestChild.h"
+
+class nsIPresentationServiceCallback;
+
+namespace mozilla {
+namespace dom {
+
+class PresentationIPCService;
+
+class PresentationChild final : public PPresentationChild {
+ public:
+  explicit PresentationChild(PresentationIPCService* aService);
+
+  virtual void ActorDestroy(ActorDestroyReason aWhy) override;
+
+  PPresentationRequestChild* AllocPPresentationRequestChild(
+      const PresentationIPCRequest& aRequest);
+
+  bool DeallocPPresentationRequestChild(PPresentationRequestChild* aActor);
+
+  mozilla::ipc::IPCResult RecvPPresentationBuilderConstructor(
+      PPresentationBuilderChild* aActor, const nsString& aSessionId,
+      const uint8_t& aRole) override;
+
+  PPresentationBuilderChild* AllocPPresentationBuilderChild(
+      const nsString& aSessionId, const uint8_t& aRole);
+
+  bool DeallocPPresentationBuilderChild(PPresentationBuilderChild* aActor);
+
+  mozilla::ipc::IPCResult RecvNotifyAvailableChange(
+      nsTArray<nsString>&& aAvailabilityUrls, const bool& aAvailable);
+
+  mozilla::ipc::IPCResult RecvNotifySessionStateChange(
+      const nsString& aSessionId, const uint16_t& aState,
+      const nsresult& aReason);
+
+  mozilla::ipc::IPCResult RecvNotifyMessage(const nsString& aSessionId,
+                                            const nsCString& aData,
+                                            const bool& aIsBinary);
+
+  mozilla::ipc::IPCResult RecvNotifySessionConnect(const uint64_t& aWindowId,
+                                                   const nsString& aSessionId);
+
+  mozilla::ipc::IPCResult RecvNotifyCloseSessionTransport(
+      const nsString& aSessionId, const uint8_t& aRole,
+      const nsresult& aReason);
+
+ private:
+  virtual ~PresentationChild();
+
+  bool mActorDestroyed = false;
+  RefPtr<PresentationIPCService> mService;
+};
+
+class PresentationRequestChild final : public PPresentationRequestChild {
+  friend class PresentationChild;
+
+ public:
+  explicit PresentationRequestChild(nsIPresentationServiceCallback* aCallback);
+
+  virtual void ActorDestroy(ActorDestroyReason aWhy) override;
+
+  mozilla::ipc::IPCResult Recv__delete__(const nsresult& aResult);
+
+  mozilla::ipc::IPCResult RecvNotifyRequestUrlSelected(const nsString& aUrl);
+
+ private:
+  virtual ~PresentationRequestChild();
+
+  bool mActorDestroyed = false;
+  nsCOMPtr<nsIPresentationServiceCallback> mCallback;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_PresentationChild_h
diff --git a/dom/presentation/ipc/PresentationContentSessionInfo.cpp b/dom/presentation/ipc/PresentationContentSessionInfo.cpp
new file mode 100644
index 0000000000..8190aedbf3
--- /dev/null
+++ b/dom/presentation/ipc/PresentationContentSessionInfo.cpp
@@ -0,0 +1,98 @@
+/* -*- 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 "nsServiceManagerUtils.h"
+#include "PresentationContentSessionInfo.h"
+#include "PresentationIPCService.h"
+
+namespace mozilla {
+namespace dom {
+
+NS_IMPL_ISUPPORTS(PresentationContentSessionInfo,
+                  nsIPresentationSessionTransportCallback);
+
+nsresult PresentationContentSessionInfo::Init() {
+  if (NS_WARN_IF(NS_FAILED(mTransport->SetCallback(this)))) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+  if (NS_WARN_IF(NS_FAILED(mTransport->EnableDataNotification()))) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+  return NS_OK;
+}
+
+nsresult PresentationContentSessionInfo::Send(const nsAString& aData) {
+  if (!mTransport) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  return mTransport->Send(aData);
+}
+
+nsresult PresentationContentSessionInfo::SendBinaryMsg(
+    const nsACString& aData) {
+  if (NS_WARN_IF(!mTransport)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  return mTransport->SendBinaryMsg(aData);
+}
+
+nsresult PresentationContentSessionInfo::SendBlob(Blob* aBlob) {
+  if (NS_WARN_IF(!mTransport)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  return mTransport->SendBlob(aBlob);
+}
+
+nsresult PresentationContentSessionInfo::Close(nsresult aReason) {
+  if (!mTransport) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  return mTransport->Close(aReason);
+}
+
+// nsIPresentationSessionTransportCallback
+NS_IMETHODIMP
+PresentationContentSessionInfo::NotifyTransportReady() {
+  // do nothing since |onSessionTransport| implies this
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationContentSessionInfo::NotifyTransportClosed(nsresult aReason) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  // Nullify |mTransport| here so it won't try to re-close |mTransport| in
+  // potential subsequent |Shutdown| calls.
+  mTransport = nullptr;
+  nsCOMPtr<nsIPresentationService> service =
+      do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+  if (NS_WARN_IF(!service)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+  return static_cast<PresentationIPCService*>(service.get())
+      ->NotifyTransportClosed(mSessionId, mRole, aReason);
+}
+
+NS_IMETHODIMP
+PresentationContentSessionInfo::NotifyData(const nsACString& aData,
+                                           bool aIsBinary) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  nsCOMPtr<nsIPresentationService> service =
+      do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+  if (NS_WARN_IF(!service)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+  return static_cast<PresentationIPCService*>(service.get())
+      ->NotifyMessage(mSessionId, aData, aIsBinary);
+}
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/presentation/ipc/PresentationContentSessionInfo.h b/dom/presentation/ipc/PresentationContentSessionInfo.h
new file mode 100644
index 0000000000..7f15da1859
--- /dev/null
+++ b/dom/presentation/ipc/PresentationContentSessionInfo.h
@@ -0,0 +1,62 @@
+/* -*- 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_PresentationContentSessionInfo_h
+#define mozilla_dom_PresentationContentSessionInfo_h
+
+#include "nsCOMPtr.h"
+#include "nsIPresentationSessionTransport.h"
+
+// XXX Avoid including this here by moving function bodies to the cpp file
+#include "nsIPresentationService.h"
+#include "nsXULAppAPI.h"
+
+namespace mozilla {
+namespace dom {
+
+/**
+ * PresentationContentSessionInfo manages nsIPresentationSessionTransport and
+ * delegates the callbacks to PresentationIPCService. Only lives in content
+ * process.
+ */
+class PresentationContentSessionInfo final
+    : public nsIPresentationSessionTransportCallback {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPRESENTATIONSESSIONTRANSPORTCALLBACK
+
+  PresentationContentSessionInfo(const nsAString& aSessionId, uint8_t aRole,
+                                 nsIPresentationSessionTransport* aTransport)
+      : mSessionId(aSessionId), mRole(aRole), mTransport(aTransport) {
+    MOZ_ASSERT(XRE_IsContentProcess());
+    MOZ_ASSERT(!aSessionId.IsEmpty());
+    MOZ_ASSERT(aRole == nsIPresentationService::ROLE_CONTROLLER ||
+               aRole == nsIPresentationService::ROLE_RECEIVER);
+    MOZ_ASSERT(aTransport);
+  }
+
+  nsresult Init();
+
+  nsresult Send(const nsAString& aData);
+
+  nsresult SendBinaryMsg(const nsACString& aData);
+
+  nsresult SendBlob(Blob* aBlob);
+
+  nsresult Close(nsresult aReason);
+
+ private:
+  virtual ~PresentationContentSessionInfo() = default;
+
+  nsString mSessionId;
+  uint8_t mRole;
+  nsCOMPtr<nsIPresentationSessionTransport> mTransport;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_PresentationContentSessionInfo_h
diff --git a/dom/presentation/ipc/PresentationIPCService.cpp b/dom/presentation/ipc/PresentationIPCService.cpp
new file mode 100644
index 0000000000..c99ce1c2ae
--- /dev/null
+++ b/dom/presentation/ipc/PresentationIPCService.cpp
@@ -0,0 +1,477 @@
+/* -*- 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 "mozilla/dom/ContentChild.h"
+#include "mozilla/dom/PermissionMessageUtils.h"
+#include "mozilla/dom/PPresentation.h"
+#include "mozilla/dom/BrowserParent.h"
+#include "mozilla/ipc/InputStreamUtils.h"
+#include "mozilla/ipc/URIUtils.h"
+#include "nsGlobalWindow.h"
+#include "nsIPresentationListener.h"
+#include "PresentationCallbacks.h"
+#include "PresentationChild.h"
+#include "PresentationContentSessionInfo.h"
+#include "PresentationIPCService.h"
+#include "PresentationLog.h"
+
+namespace mozilla {
+namespace dom {
+
+namespace {
+
+PresentationChild* sPresentationChild;
+
+}  // namespace
+
+NS_IMPL_ISUPPORTS(PresentationIPCService, nsIPresentationService,
+                  nsIPresentationAvailabilityListener)
+
+PresentationIPCService::PresentationIPCService() {
+  ContentChild* contentChild = ContentChild::GetSingleton();
+  if (NS_WARN_IF(!contentChild || contentChild->IsShuttingDown())) {
+    return;
+  }
+  sPresentationChild = new PresentationChild(this);
+  Unused << NS_WARN_IF(
+      !contentChild->SendPPresentationConstructor(sPresentationChild));
+}
+
+/* virtual */
+PresentationIPCService::~PresentationIPCService() {
+  Shutdown();
+
+  mSessionListeners.Clear();
+  mSessionInfoAtController.Clear();
+  mSessionInfoAtReceiver.Clear();
+  sPresentationChild = nullptr;
+}
+
+NS_IMETHODIMP
+PresentationIPCService::StartSession(
+    const nsTArray<nsString>& aUrls, const nsAString& aSessionId,
+    const nsAString& aOrigin, const nsAString& aDeviceId, uint64_t aWindowId,
+    EventTarget* aEventTarget, nsIPrincipal* aPrincipal,
+    nsIPresentationServiceCallback* aCallback,
+    nsIPresentationTransportBuilderConstructor* aBuilderConstructor) {
+  if (aWindowId != 0) {
+    AddRespondingSessionId(aWindowId, aSessionId,
+                           nsIPresentationService::ROLE_CONTROLLER);
+  }
+
+  nsPIDOMWindowInner* window =
+      nsGlobalWindowInner::GetInnerWindowWithId(aWindowId);
+  TabId tabId = BrowserParent::GetTabIdFrom(window->GetDocShell());
+
+  SendRequest(
+      aCallback,
+      StartSessionRequest(aUrls, nsString(aSessionId), nsString(aOrigin),
+                          nsString(aDeviceId), aWindowId, tabId, aPrincipal));
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationIPCService::SendSessionMessage(const nsAString& aSessionId,
+                                           uint8_t aRole,
+                                           const nsAString& aData) {
+  MOZ_ASSERT(!aSessionId.IsEmpty());
+  MOZ_ASSERT(!aData.IsEmpty());
+
+  RefPtr<PresentationContentSessionInfo> info =
+      GetSessionInfo(aSessionId, aRole);
+  // data channel session transport is maintained by content process
+  if (info) {
+    return info->Send(aData);
+  }
+
+  SendRequest(nullptr, SendSessionMessageRequest(nsString(aSessionId), aRole,
+                                                 nsString(aData)));
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationIPCService::SendSessionBinaryMsg(const nsAString& aSessionId,
+                                             uint8_t aRole,
+                                             const nsACString& aData) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(!aData.IsEmpty());
+  MOZ_ASSERT(!aSessionId.IsEmpty());
+  MOZ_ASSERT(aRole == nsIPresentationService::ROLE_CONTROLLER ||
+             aRole == nsIPresentationService::ROLE_RECEIVER);
+
+  RefPtr<PresentationContentSessionInfo> info =
+      GetSessionInfo(aSessionId, aRole);
+  // data channel session transport is maintained by content process
+  if (info) {
+    return info->SendBinaryMsg(aData);
+  }
+
+  return NS_ERROR_NOT_AVAILABLE;
+}
+
+NS_IMETHODIMP
+PresentationIPCService::SendSessionBlob(const nsAString& aSessionId,
+                                        uint8_t aRole, Blob* aBlob) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(!aSessionId.IsEmpty());
+  MOZ_ASSERT(aRole == nsIPresentationService::ROLE_CONTROLLER ||
+             aRole == nsIPresentationService::ROLE_RECEIVER);
+  MOZ_ASSERT(aBlob);
+
+  RefPtr<PresentationContentSessionInfo> info =
+      GetSessionInfo(aSessionId, aRole);
+  // data channel session transport is maintained by content process
+  if (info) {
+    return info->SendBlob(aBlob);
+  }
+
+  return NS_ERROR_NOT_AVAILABLE;
+}
+
+NS_IMETHODIMP
+PresentationIPCService::CloseSession(const nsAString& aSessionId, uint8_t aRole,
+                                     uint8_t aClosedReason) {
+  MOZ_ASSERT(!aSessionId.IsEmpty());
+
+  SendRequest(nullptr,
+              CloseSessionRequest(nsString(aSessionId), aRole, aClosedReason));
+
+  RefPtr<PresentationContentSessionInfo> info =
+      GetSessionInfo(aSessionId, aRole);
+  if (info) {
+    return info->Close(NS_OK);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationIPCService::TerminateSession(const nsAString& aSessionId,
+                                         uint8_t aRole) {
+  MOZ_ASSERT(!aSessionId.IsEmpty());
+
+  SendRequest(nullptr, TerminateSessionRequest(nsString(aSessionId), aRole));
+
+  RefPtr<PresentationContentSessionInfo> info =
+      GetSessionInfo(aSessionId, aRole);
+  if (info) {
+    return info->Close(NS_OK);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationIPCService::ReconnectSession(
+    const nsTArray<nsString>& aUrls, const nsAString& aSessionId, uint8_t aRole,
+    nsIPresentationServiceCallback* aCallback) {
+  MOZ_ASSERT(!aSessionId.IsEmpty());
+
+  if (aRole != nsIPresentationService::ROLE_CONTROLLER) {
+    MOZ_ASSERT(false, "Only controller can call ReconnectSession.");
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  SendRequest(aCallback,
+              ReconnectSessionRequest(aUrls, nsString(aSessionId), aRole));
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationIPCService::BuildTransport(const nsAString& aSessionId,
+                                       uint8_t aRole) {
+  MOZ_ASSERT(!aSessionId.IsEmpty());
+
+  if (aRole != nsIPresentationService::ROLE_CONTROLLER) {
+    MOZ_ASSERT(false, "Only controller can call ReconnectSession.");
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  SendRequest(nullptr, BuildTransportRequest(nsString(aSessionId), aRole));
+  return NS_OK;
+}
+
+void PresentationIPCService::SendRequest(
+    nsIPresentationServiceCallback* aCallback,
+    const PresentationIPCRequest& aRequest) {
+  if (sPresentationChild) {
+    PresentationRequestChild* actor = new PresentationRequestChild(aCallback);
+    Unused << NS_WARN_IF(
+        !sPresentationChild->SendPPresentationRequestConstructor(actor,
+                                                                 aRequest));
+  }
+}
+
+NS_IMETHODIMP
+PresentationIPCService::RegisterAvailabilityListener(
+    const nsTArray<nsString>& aAvailabilityUrls,
+    nsIPresentationAvailabilityListener* aListener) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(!aAvailabilityUrls.IsEmpty());
+  MOZ_ASSERT(aListener);
+
+  nsTArray<nsString> addedUrls;
+  mAvailabilityManager.AddAvailabilityListener(aAvailabilityUrls, aListener,
+                                               addedUrls);
+
+  if (sPresentationChild && !addedUrls.IsEmpty()) {
+    Unused << NS_WARN_IF(
+        !sPresentationChild->SendRegisterAvailabilityHandler(addedUrls));
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationIPCService::UnregisterAvailabilityListener(
+    const nsTArray<nsString>& aAvailabilityUrls,
+    nsIPresentationAvailabilityListener* aListener) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  nsTArray<nsString> removedUrls;
+  mAvailabilityManager.RemoveAvailabilityListener(aAvailabilityUrls, aListener,
+                                                  removedUrls);
+
+  if (sPresentationChild && !removedUrls.IsEmpty()) {
+    Unused << NS_WARN_IF(
+        !sPresentationChild->SendUnregisterAvailabilityHandler(removedUrls));
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationIPCService::RegisterSessionListener(
+    const nsAString& aSessionId, uint8_t aRole,
+    nsIPresentationSessionListener* aListener) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(aListener);
+
+  nsCOMPtr<nsIPresentationSessionListener> listener;
+  if (mSessionListeners.Get(aSessionId, getter_AddRefs(listener))) {
+    mSessionListeners.Put(aSessionId, RefPtr{aListener});
+    return NS_OK;
+  }
+
+  mSessionListeners.Put(aSessionId, RefPtr{aListener});
+  if (sPresentationChild) {
+    Unused << NS_WARN_IF(!sPresentationChild->SendRegisterSessionHandler(
+        nsString(aSessionId), aRole));
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationIPCService::UnregisterSessionListener(const nsAString& aSessionId,
+                                                  uint8_t aRole) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  UntrackSessionInfo(aSessionId, aRole);
+
+  mSessionListeners.Remove(aSessionId);
+  if (sPresentationChild) {
+    Unused << NS_WARN_IF(!sPresentationChild->SendUnregisterSessionHandler(
+        nsString(aSessionId), aRole));
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationIPCService::RegisterRespondingListener(
+    uint64_t aWindowId, nsIPresentationRespondingListener* aListener) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  mRespondingListeners.Put(aWindowId, RefPtr{aListener});
+  if (sPresentationChild) {
+    Unused << NS_WARN_IF(
+        !sPresentationChild->SendRegisterRespondingHandler(aWindowId));
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationIPCService::UnregisterRespondingListener(uint64_t aWindowId) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  mRespondingListeners.Remove(aWindowId);
+  if (sPresentationChild) {
+    Unused << NS_WARN_IF(
+        !sPresentationChild->SendUnregisterRespondingHandler(aWindowId));
+  }
+  return NS_OK;
+}
+
+nsresult PresentationIPCService::NotifySessionTransport(
+    const nsString& aSessionId, const uint8_t& aRole,
+    nsIPresentationSessionTransport* aTransport) {
+  RefPtr<PresentationContentSessionInfo> info =
+      new PresentationContentSessionInfo(aSessionId, aRole, aTransport);
+
+  if (NS_WARN_IF(NS_FAILED(info->Init()))) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  if (aRole == nsIPresentationService::ROLE_CONTROLLER) {
+    mSessionInfoAtController.Put(aSessionId, std::move(info));
+  } else {
+    mSessionInfoAtReceiver.Put(aSessionId, std::move(info));
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationIPCService::GetWindowIdBySessionId(const nsAString& aSessionId,
+                                               uint8_t aRole,
+                                               uint64_t* aWindowId) {
+  return GetWindowIdBySessionIdInternal(aSessionId, aRole, aWindowId);
+}
+
+NS_IMETHODIMP
+PresentationIPCService::UpdateWindowIdBySessionId(const nsAString& aSessionId,
+                                                  uint8_t aRole,
+                                                  const uint64_t aWindowId) {
+  UpdateWindowIdBySessionIdInternal(aSessionId, aRole, aWindowId);
+  return NS_OK;
+}
+
+nsresult PresentationIPCService::NotifySessionStateChange(
+    const nsAString& aSessionId, uint16_t aState, nsresult aReason) {
+  nsCOMPtr<nsIPresentationSessionListener> listener;
+  if (NS_WARN_IF(
+          !mSessionListeners.Get(aSessionId, getter_AddRefs(listener)))) {
+    return NS_OK;
+  }
+
+  return listener->NotifyStateChange(aSessionId, aState, aReason);
+}
+
+// Only used for OOP RTCDataChannel session transport case.
+nsresult PresentationIPCService::NotifyMessage(const nsAString& aSessionId,
+                                               const nsACString& aData,
+                                               const bool& aIsBinary) {
+  nsCOMPtr<nsIPresentationSessionListener> listener;
+  if (NS_WARN_IF(
+          !mSessionListeners.Get(aSessionId, getter_AddRefs(listener)))) {
+    return NS_OK;
+  }
+
+  return listener->NotifyMessage(aSessionId, aData, aIsBinary);
+}
+
+// Only used for OOP RTCDataChannel session transport case.
+nsresult PresentationIPCService::NotifyTransportClosed(
+    const nsAString& aSessionId, uint8_t aRole, nsresult aReason) {
+  RefPtr<PresentationContentSessionInfo> info =
+      GetSessionInfo(aSessionId, aRole);
+  if (NS_WARN_IF(!info)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+  Unused << NS_WARN_IF(!sPresentationChild->SendNotifyTransportClosed(
+      nsString(aSessionId), aRole, aReason));
+  return NS_OK;
+}
+
+nsresult PresentationIPCService::NotifySessionConnect(
+    uint64_t aWindowId, const nsAString& aSessionId) {
+  nsCOMPtr<nsIPresentationRespondingListener> listener;
+  if (NS_WARN_IF(
+          !mRespondingListeners.Get(aWindowId, getter_AddRefs(listener)))) {
+    return NS_OK;
+  }
+
+  return listener->NotifySessionConnect(aWindowId, aSessionId);
+}
+
+NS_IMETHODIMP
+PresentationIPCService::NotifyAvailableChange(
+    const nsTArray<nsString>& aAvailabilityUrls, bool aAvailable) {
+  mAvailabilityManager.DoNotifyAvailableChange(aAvailabilityUrls, aAvailable);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationIPCService::NotifyReceiverReady(
+    const nsAString& aSessionId, uint64_t aWindowId, bool aIsLoading,
+    nsIPresentationTransportBuilderConstructor* aBuilderConstructor) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  // No actual window uses 0 as its ID.
+  if (NS_WARN_IF(aWindowId == 0)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  // Track the responding info for an OOP receiver page.
+  AddRespondingSessionId(aWindowId, aSessionId,
+                         nsIPresentationService::ROLE_RECEIVER);
+
+  Unused << NS_WARN_IF(!sPresentationChild->SendNotifyReceiverReady(
+      nsString(aSessionId), aWindowId, aIsLoading));
+
+  // Release mCallback after using aSessionId
+  // because aSessionId is held by mCallback.
+  mCallback = nullptr;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationIPCService::UntrackSessionInfo(const nsAString& aSessionId,
+                                           uint8_t aRole) {
+  PRES_DEBUG("content %s:id[%s], role[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(aSessionId).get(), aRole);
+
+  if (nsIPresentationService::ROLE_RECEIVER == aRole) {
+    // Terminate receiver page.
+    uint64_t windowId;
+    if (NS_SUCCEEDED(
+            GetWindowIdBySessionIdInternal(aSessionId, aRole, &windowId))) {
+      NS_DispatchToMainThread(NS_NewRunnableFunction(
+          "dom::PresentationIPCService::UntrackSessionInfo",
+          [windowId]() -> void {
+            PRES_DEBUG("Attempt to close window[%" PRIu64 "]\n", windowId);
+
+            if (auto* window =
+                    nsGlobalWindowInner::GetInnerWindowWithId(windowId)) {
+              window->Close();
+            }
+          }));
+    }
+  }
+
+  // Remove the OOP responding info (if it has never been used).
+  RemoveRespondingSessionId(aSessionId, aRole);
+
+  if (nsIPresentationService::ROLE_CONTROLLER == aRole) {
+    mSessionInfoAtController.Remove(aSessionId);
+  } else {
+    mSessionInfoAtReceiver.Remove(aSessionId);
+  }
+
+  return NS_OK;
+}
+
+void PresentationIPCService::NotifyPresentationChildDestroyed() {
+  sPresentationChild = nullptr;
+}
+
+nsresult PresentationIPCService::MonitorResponderLoading(
+    const nsAString& aSessionId, nsIDocShell* aDocShell) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  mCallback = new PresentationResponderLoadingCallback(aSessionId);
+  return mCallback->Init(aDocShell);
+}
+
+nsresult PresentationIPCService::CloseContentSessionTransport(
+    const nsString& aSessionId, uint8_t aRole, nsresult aReason) {
+  RefPtr<PresentationContentSessionInfo> info =
+      GetSessionInfo(aSessionId, aRole);
+  if (NS_WARN_IF(!info)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  return info->Close(aReason);
+}
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/presentation/ipc/PresentationIPCService.h b/dom/presentation/ipc/PresentationIPCService.h
new file mode 100644
index 0000000000..9b80209a52
--- /dev/null
+++ b/dom/presentation/ipc/PresentationIPCService.h
@@ -0,0 +1,71 @@
+/* -*- 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_PresentationIPCService_h
+#define mozilla_dom_PresentationIPCService_h
+
+#include "mozilla/dom/PresentationServiceBase.h"
+#include "nsIPresentationListener.h"
+#include "nsIPresentationSessionTransport.h"
+#include "nsIPresentationService.h"
+
+class nsIDocShell;
+
+namespace mozilla {
+namespace dom {
+
+class PresentationIPCRequest;
+class PresentationContentSessionInfo;
+class PresentationResponderLoadingCallback;
+
+class PresentationIPCService final
+    : public nsIPresentationAvailabilityListener,
+      public nsIPresentationService,
+      public PresentationServiceBase<PresentationContentSessionInfo> {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPRESENTATIONAVAILABILITYLISTENER
+  NS_DECL_NSIPRESENTATIONSERVICE
+
+  PresentationIPCService();
+
+  nsresult NotifySessionStateChange(const nsAString& aSessionId,
+                                    uint16_t aState, nsresult aReason);
+
+  nsresult NotifyMessage(const nsAString& aSessionId, const nsACString& aData,
+                         const bool& aIsBinary);
+
+  nsresult NotifySessionConnect(uint64_t aWindowId,
+                                const nsAString& aSessionId);
+
+  void NotifyPresentationChildDestroyed();
+
+  nsresult MonitorResponderLoading(const nsAString& aSessionId,
+                                   nsIDocShell* aDocShell);
+
+  nsresult NotifySessionTransport(const nsString& aSessionId,
+                                  const uint8_t& aRole,
+                                  nsIPresentationSessionTransport* transport);
+
+  nsresult CloseContentSessionTransport(const nsString& aSessionId,
+                                        uint8_t aRole, nsresult aReason);
+
+ private:
+  virtual ~PresentationIPCService();
+  void SendRequest(nsIPresentationServiceCallback* aCallback,
+                   const PresentationIPCRequest& aRequest);
+
+  nsRefPtrHashtable<nsStringHashKey, nsIPresentationSessionListener>
+      mSessionListeners;
+  nsRefPtrHashtable<nsUint64HashKey, nsIPresentationRespondingListener>
+      mRespondingListeners;
+  RefPtr<PresentationResponderLoadingCallback> mCallback;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_PresentationIPCService_h
diff --git a/dom/presentation/ipc/PresentationParent.cpp b/dom/presentation/ipc/PresentationParent.cpp
new file mode 100644
index 0000000000..8d643bd8b3
--- /dev/null
+++ b/dom/presentation/ipc/PresentationParent.cpp
@@ -0,0 +1,497 @@
+/* -*- 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 "DCPresentationChannelDescription.h"
+#include "mozilla/dom/BrowserParent.h"
+#include "mozilla/dom/ContentProcessManager.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/ipc/InputStreamUtils.h"
+#include "mozilla/Unused.h"
+#include "nsComponentManagerUtils.h"
+#include "nsIPresentationSessionTransport.h"
+#include "nsIPresentationSessionTransportBuilder.h"
+#include "nsServiceManagerUtils.h"
+#include "PresentationBuilderParent.h"
+#include "PresentationParent.h"
+#include "PresentationService.h"
+#include "PresentationSessionInfo.h"
+
+namespace mozilla {
+namespace dom {
+
+namespace {
+
+class PresentationTransportBuilderConstructorIPC final
+    : public nsIPresentationTransportBuilderConstructor {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPRESENTATIONTRANSPORTBUILDERCONSTRUCTOR
+
+  explicit PresentationTransportBuilderConstructorIPC(
+      PresentationParent* aParent)
+      : mParent(aParent) {}
+
+ private:
+  virtual ~PresentationTransportBuilderConstructorIPC() = default;
+
+  RefPtr<PresentationParent> mParent;
+};
+
+NS_IMPL_ISUPPORTS(PresentationTransportBuilderConstructorIPC,
+                  nsIPresentationTransportBuilderConstructor)
+
+NS_IMETHODIMP
+PresentationTransportBuilderConstructorIPC::CreateTransportBuilder(
+    uint8_t aType, nsIPresentationSessionTransportBuilder** aRetval) {
+  if (NS_WARN_IF(!aRetval)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  *aRetval = nullptr;
+
+  if (NS_WARN_IF(aType != nsIPresentationChannelDescription::TYPE_TCP &&
+                 aType !=
+                     nsIPresentationChannelDescription::TYPE_DATACHANNEL)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  if (XRE_IsContentProcess()) {
+    MOZ_ASSERT(false,
+               "CreateTransportBuilder can only be invoked in parent process.");
+    return NS_ERROR_FAILURE;
+  }
+
+  nsCOMPtr<nsIPresentationSessionTransportBuilder> builder;
+  if (aType == nsIPresentationChannelDescription::TYPE_TCP) {
+    builder = do_CreateInstance(PRESENTATION_TCP_SESSION_TRANSPORT_CONTRACTID);
+  } else {
+    builder = new PresentationBuilderParent(mParent);
+  }
+
+  if (NS_WARN_IF(!builder)) {
+    return NS_ERROR_DOM_OPERATION_ERR;
+  }
+
+  builder.forget(aRetval);
+  return NS_OK;
+}
+
+}  // anonymous namespace
+
+/*
+ * Implementation of PresentationParent
+ */
+
+NS_IMPL_ISUPPORTS(PresentationParent, nsIPresentationAvailabilityListener,
+                  nsIPresentationSessionListener,
+                  nsIPresentationRespondingListener)
+
+PresentationParent::PresentationParent() = default;
+
+/* virtual */ PresentationParent::~PresentationParent() = default;
+
+bool PresentationParent::Init(ContentParentId aContentParentId) {
+  MOZ_ASSERT(!mService);
+  mService = do_GetService(PRESENTATION_SERVICE_CONTRACTID);
+  mChildId = aContentParentId;
+  return !NS_WARN_IF(!mService);
+}
+
+void PresentationParent::ActorDestroy(ActorDestroyReason aWhy) {
+  mActorDestroyed = true;
+
+  for (uint32_t i = 0; i < mSessionIdsAtController.Length(); i++) {
+    Unused << NS_WARN_IF(NS_FAILED(mService->UnregisterSessionListener(
+        mSessionIdsAtController[i], nsIPresentationService::ROLE_CONTROLLER)));
+  }
+  mSessionIdsAtController.Clear();
+
+  for (uint32_t i = 0; i < mSessionIdsAtReceiver.Length(); i++) {
+    Unused << NS_WARN_IF(NS_FAILED(mService->UnregisterSessionListener(
+        mSessionIdsAtReceiver[i], nsIPresentationService::ROLE_RECEIVER)));
+  }
+  mSessionIdsAtReceiver.Clear();
+
+  for (uint32_t i = 0; i < mWindowIds.Length(); i++) {
+    Unused << NS_WARN_IF(
+        NS_FAILED(mService->UnregisterRespondingListener(mWindowIds[i])));
+  }
+  mWindowIds.Clear();
+
+  if (!mContentAvailabilityUrls.IsEmpty()) {
+    mService->UnregisterAvailabilityListener(mContentAvailabilityUrls, this);
+  }
+  mService = nullptr;
+}
+
+mozilla::ipc::IPCResult PresentationParent::RecvPPresentationRequestConstructor(
+    PPresentationRequestParent* aActor,
+    const PresentationIPCRequest& aRequest) {
+  PresentationRequestParent* actor =
+      static_cast<PresentationRequestParent*>(aActor);
+
+  nsresult rv = NS_ERROR_FAILURE;
+  switch (aRequest.type()) {
+    case PresentationIPCRequest::TStartSessionRequest:
+      rv = actor->DoRequest(aRequest.get_StartSessionRequest());
+      break;
+    case PresentationIPCRequest::TSendSessionMessageRequest:
+      rv = actor->DoRequest(aRequest.get_SendSessionMessageRequest());
+      break;
+    case PresentationIPCRequest::TCloseSessionRequest:
+      rv = actor->DoRequest(aRequest.get_CloseSessionRequest());
+      break;
+    case PresentationIPCRequest::TTerminateSessionRequest:
+      rv = actor->DoRequest(aRequest.get_TerminateSessionRequest());
+      break;
+    case PresentationIPCRequest::TReconnectSessionRequest:
+      rv = actor->DoRequest(aRequest.get_ReconnectSessionRequest());
+      break;
+    case PresentationIPCRequest::TBuildTransportRequest:
+      rv = actor->DoRequest(aRequest.get_BuildTransportRequest());
+      break;
+    default:
+      MOZ_CRASH("Unknown PresentationIPCRequest type");
+  }
+
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return IPC_FAIL_NO_REASON(this);
+  }
+  return IPC_OK();
+}
+
+PPresentationRequestParent* PresentationParent::AllocPPresentationRequestParent(
+    const PresentationIPCRequest& aRequest) {
+  MOZ_ASSERT(mService);
+  RefPtr<PresentationRequestParent> actor =
+      new PresentationRequestParent(mService, mChildId);
+  return actor.forget().take();
+}
+
+bool PresentationParent::DeallocPPresentationRequestParent(
+    PPresentationRequestParent* aActor) {
+  RefPtr<PresentationRequestParent> actor =
+      dont_AddRef(static_cast<PresentationRequestParent*>(aActor));
+  return true;
+}
+
+PPresentationBuilderParent* PresentationParent::AllocPPresentationBuilderParent(
+    const nsString& aSessionId, const uint8_t& aRole) {
+  MOZ_ASSERT_UNREACHABLE(
+      "We should never be manually allocating "
+      "AllocPPresentationBuilderParent actors");
+  return nullptr;
+}
+
+bool PresentationParent::DeallocPPresentationBuilderParent(
+    PPresentationBuilderParent* aActor) {
+  return true;
+}
+
+mozilla::ipc::IPCResult PresentationParent::Recv__delete__() {
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult PresentationParent::RecvRegisterAvailabilityHandler(
+    nsTArray<nsString>&& aAvailabilityUrls) {
+  MOZ_ASSERT(mService);
+
+  Unused << NS_WARN_IF(NS_FAILED(
+      mService->RegisterAvailabilityListener(aAvailabilityUrls, this)));
+  mContentAvailabilityUrls.AppendElements(aAvailabilityUrls);
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult PresentationParent::RecvUnregisterAvailabilityHandler(
+    nsTArray<nsString>&& aAvailabilityUrls) {
+  MOZ_ASSERT(mService);
+
+  Unused << NS_WARN_IF(NS_FAILED(
+      mService->UnregisterAvailabilityListener(aAvailabilityUrls, this)));
+  for (const auto& url : aAvailabilityUrls) {
+    mContentAvailabilityUrls.RemoveElement(url);
+  }
+  return IPC_OK();
+}
+
+/* virtual */ mozilla::ipc::IPCResult
+PresentationParent::RecvRegisterSessionHandler(const nsString& aSessionId,
+                                               const uint8_t& aRole) {
+  MOZ_ASSERT(mService);
+
+  // Validate the accessibility (primarily for receiver side) so that a
+  // compromised child process can't fake the ID.
+  if (NS_WARN_IF(!static_cast<PresentationService*>(mService.get())
+                      ->IsSessionAccessible(aSessionId, aRole, OtherPid()))) {
+    return IPC_OK();
+  }
+
+  if (nsIPresentationService::ROLE_CONTROLLER == aRole) {
+    mSessionIdsAtController.AppendElement(aSessionId);
+  } else {
+    mSessionIdsAtReceiver.AppendElement(aSessionId);
+  }
+  Unused << NS_WARN_IF(
+      NS_FAILED(mService->RegisterSessionListener(aSessionId, aRole, this)));
+  return IPC_OK();
+}
+
+/* virtual */ mozilla::ipc::IPCResult
+PresentationParent::RecvUnregisterSessionHandler(const nsString& aSessionId,
+                                                 const uint8_t& aRole) {
+  MOZ_ASSERT(mService);
+  if (nsIPresentationService::ROLE_CONTROLLER == aRole) {
+    mSessionIdsAtController.RemoveElement(aSessionId);
+  } else {
+    mSessionIdsAtReceiver.RemoveElement(aSessionId);
+  }
+  Unused << NS_WARN_IF(
+      NS_FAILED(mService->UnregisterSessionListener(aSessionId, aRole)));
+  return IPC_OK();
+}
+
+/* virtual */ mozilla::ipc::IPCResult
+PresentationParent::RecvRegisterRespondingHandler(const uint64_t& aWindowId) {
+  MOZ_ASSERT(mService);
+
+  mWindowIds.AppendElement(aWindowId);
+  Unused << NS_WARN_IF(
+      NS_FAILED(mService->RegisterRespondingListener(aWindowId, this)));
+  return IPC_OK();
+}
+
+/* virtual */ mozilla::ipc::IPCResult
+PresentationParent::RecvUnregisterRespondingHandler(const uint64_t& aWindowId) {
+  MOZ_ASSERT(mService);
+  mWindowIds.RemoveElement(aWindowId);
+  Unused << NS_WARN_IF(
+      NS_FAILED(mService->UnregisterRespondingListener(aWindowId)));
+  return IPC_OK();
+}
+
+NS_IMETHODIMP
+PresentationParent::NotifyAvailableChange(
+    const nsTArray<nsString>& aAvailabilityUrls, bool aAvailable) {
+  if (NS_WARN_IF(mActorDestroyed ||
+                 !SendNotifyAvailableChange(aAvailabilityUrls, aAvailable))) {
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationParent::NotifyStateChange(const nsAString& aSessionId,
+                                      uint16_t aState, nsresult aReason) {
+  if (NS_WARN_IF(mActorDestroyed ||
+                 !SendNotifySessionStateChange(nsString(aSessionId), aState,
+                                               aReason))) {
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationParent::NotifyMessage(const nsAString& aSessionId,
+                                  const nsACString& aData, bool aIsBinary) {
+  if (NS_WARN_IF(mActorDestroyed ||
+                 !SendNotifyMessage(nsString(aSessionId), nsCString(aData),
+                                    aIsBinary))) {
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+PresentationParent::NotifySessionConnect(uint64_t aWindowId,
+                                         const nsAString& aSessionId) {
+  if (NS_WARN_IF(mActorDestroyed ||
+                 !SendNotifySessionConnect(aWindowId, nsString(aSessionId)))) {
+    return NS_ERROR_FAILURE;
+  }
+  return NS_OK;
+}
+
+mozilla::ipc::IPCResult PresentationParent::RecvNotifyReceiverReady(
+    const nsString& aSessionId, const uint64_t& aWindowId,
+    const bool& aIsLoading) {
+  MOZ_ASSERT(mService);
+
+  nsCOMPtr<nsIPresentationTransportBuilderConstructor> constructor =
+      new PresentationTransportBuilderConstructorIPC(this);
+  Unused << NS_WARN_IF(NS_FAILED(mService->NotifyReceiverReady(
+      aSessionId, aWindowId, aIsLoading, constructor)));
+  return IPC_OK();
+}
+
+mozilla::ipc::IPCResult PresentationParent::RecvNotifyTransportClosed(
+    const nsString& aSessionId, const uint8_t& aRole, const nsresult& aReason) {
+  MOZ_ASSERT(mService);
+
+  Unused << NS_WARN_IF(
+      NS_FAILED(mService->NotifyTransportClosed(aSessionId, aRole, aReason)));
+  return IPC_OK();
+}
+
+/*
+ * Implementation of PresentationRequestParent
+ */
+
+NS_IMPL_ISUPPORTS(PresentationRequestParent, nsIPresentationServiceCallback)
+
+PresentationRequestParent::PresentationRequestParent(
+    nsIPresentationService* aService, ContentParentId aContentParentId)
+    : mService(aService), mChildId(aContentParentId) {}
+
+PresentationRequestParent::~PresentationRequestParent() = default;
+
+void PresentationRequestParent::ActorDestroy(ActorDestroyReason aWhy) {
+  mActorDestroyed = true;
+  mService = nullptr;
+}
+
+nsresult PresentationRequestParent::DoRequest(
+    const StartSessionRequest& aRequest) {
+  MOZ_ASSERT(mService);
+
+  mSessionId = aRequest.sessionId();
+
+  RefPtr<EventTarget> eventTarget;
+  ContentProcessManager* cpm = ContentProcessManager::GetSingleton();
+  RefPtr<BrowserParent> tp = cpm->GetTopLevelBrowserParentByProcessAndTabId(
+      mChildId, aRequest.tabId());
+  if (tp) {
+    eventTarget = tp->GetOwnerElement();
+  }
+
+  RefPtr<PresentationParent> parent =
+      static_cast<PresentationParent*>(Manager());
+  nsCOMPtr<nsIPresentationTransportBuilderConstructor> constructor =
+      new PresentationTransportBuilderConstructorIPC(parent);
+  return mService->StartSession(aRequest.urls(), aRequest.sessionId(),
+                                aRequest.origin(), aRequest.deviceId(),
+                                aRequest.windowId(), eventTarget,
+                                aRequest.principal(), this, constructor);
+}
+
+nsresult PresentationRequestParent::DoRequest(
+    const SendSessionMessageRequest& aRequest) {
+  MOZ_ASSERT(mService);
+
+  // Validate the accessibility (primarily for receiver side) so that a
+  // compromised child process can't fake the ID.
+  if (NS_WARN_IF(!static_cast<PresentationService*>(mService.get())
+                      ->IsSessionAccessible(aRequest.sessionId(),
+                                            aRequest.role(), OtherPid()))) {
+    return SendResponse(NS_ERROR_DOM_SECURITY_ERR);
+  }
+
+  nsresult rv = mService->SendSessionMessage(aRequest.sessionId(),
+                                             aRequest.role(), aRequest.data());
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return SendResponse(rv);
+  }
+  return SendResponse(NS_OK);
+}
+
+nsresult PresentationRequestParent::DoRequest(
+    const CloseSessionRequest& aRequest) {
+  MOZ_ASSERT(mService);
+
+  // Validate the accessibility (primarily for receiver side) so that a
+  // compromised child process can't fake the ID.
+  if (NS_WARN_IF(!static_cast<PresentationService*>(mService.get())
+                      ->IsSessionAccessible(aRequest.sessionId(),
+                                            aRequest.role(), OtherPid()))) {
+    return SendResponse(NS_ERROR_DOM_SECURITY_ERR);
+  }
+
+  nsresult rv = mService->CloseSession(aRequest.sessionId(), aRequest.role(),
+                                       aRequest.closedReason());
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return SendResponse(rv);
+  }
+  return SendResponse(NS_OK);
+}
+
+nsresult PresentationRequestParent::DoRequest(
+    const TerminateSessionRequest& aRequest) {
+  MOZ_ASSERT(mService);
+
+  // Validate the accessibility (primarily for receiver side) so that a
+  // compromised child process can't fake the ID.
+  if (NS_WARN_IF(!static_cast<PresentationService*>(mService.get())
+                      ->IsSessionAccessible(aRequest.sessionId(),
+                                            aRequest.role(), OtherPid()))) {
+    return SendResponse(NS_ERROR_DOM_SECURITY_ERR);
+  }
+
+  nsresult rv =
+      mService->TerminateSession(aRequest.sessionId(), aRequest.role());
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return SendResponse(rv);
+  }
+  return SendResponse(NS_OK);
+}
+
+nsresult PresentationRequestParent::DoRequest(
+    const ReconnectSessionRequest& aRequest) {
+  MOZ_ASSERT(mService);
+
+  // Validate the accessibility (primarily for receiver side) so that a
+  // compromised child process can't fake the ID.
+  if (NS_WARN_IF(!static_cast<PresentationService*>(mService.get())
+                      ->IsSessionAccessible(aRequest.sessionId(),
+                                            aRequest.role(), OtherPid()))) {
+    // NOTE: Return NS_ERROR_DOM_NOT_FOUND_ERR here to match the spec.
+    // https://w3c.github.io/presentation-api/#reconnecting-to-a-presentation
+    return SendResponse(NS_ERROR_DOM_NOT_FOUND_ERR);
+  }
+
+  mSessionId = aRequest.sessionId();
+  return mService->ReconnectSession(aRequest.urls(), aRequest.sessionId(),
+                                    aRequest.role(), this);
+}
+
+nsresult PresentationRequestParent::DoRequest(
+    const BuildTransportRequest& aRequest) {
+  MOZ_ASSERT(mService);
+
+  // Validate the accessibility (primarily for receiver side) so that a
+  // compromised child process can't fake the ID.
+  if (NS_WARN_IF(!static_cast<PresentationService*>(mService.get())
+                      ->IsSessionAccessible(aRequest.sessionId(),
+                                            aRequest.role(), OtherPid()))) {
+    return SendResponse(NS_ERROR_DOM_SECURITY_ERR);
+  }
+
+  nsresult rv = mService->BuildTransport(aRequest.sessionId(), aRequest.role());
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return SendResponse(rv);
+  }
+  return SendResponse(NS_OK);
+}
+
+NS_IMETHODIMP
+PresentationRequestParent::NotifySuccess(const nsAString& aUrl) {
+  Unused << SendNotifyRequestUrlSelected(nsString(aUrl));
+  return SendResponse(NS_OK);
+}
+
+NS_IMETHODIMP
+PresentationRequestParent::NotifyError(nsresult aError) {
+  return SendResponse(aError);
+}
+
+nsresult PresentationRequestParent::SendResponse(nsresult aResult) {
+  if (NS_WARN_IF(mActorDestroyed || !Send__delete__(this, aResult))) {
+    return NS_ERROR_FAILURE;
+  }
+
+  return NS_OK;
+}
+
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/presentation/ipc/PresentationParent.h b/dom/presentation/ipc/PresentationParent.h
new file mode 100644
index 0000000000..c50d374923
--- /dev/null
+++ b/dom/presentation/ipc/PresentationParent.h
@@ -0,0 +1,133 @@
+/* -*- 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_PresentationParent_h__
+#define mozilla_dom_PresentationParent_h__
+
+#include "mozilla/dom/ipc/IdType.h"
+#include "mozilla/dom/PPresentationBuilderParent.h"
+#include "mozilla/dom/PPresentationParent.h"
+#include "mozilla/dom/PPresentationRequestParent.h"
+#include "nsIPresentationListener.h"
+#include "nsIPresentationService.h"
+
+namespace mozilla {
+namespace dom {
+
+class PresentationParent final : public PPresentationParent,
+                                 public nsIPresentationAvailabilityListener,
+                                 public nsIPresentationSessionListener,
+                                 public nsIPresentationRespondingListener {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPRESENTATIONAVAILABILITYLISTENER
+  NS_DECL_NSIPRESENTATIONSESSIONLISTENER
+  NS_DECL_NSIPRESENTATIONRESPONDINGLISTENER
+
+  PresentationParent();
+
+  bool Init(ContentParentId aContentParentId);
+
+  bool RegisterTransportBuilder(const nsString& aSessionId,
+                                const uint8_t& aRole);
+
+  virtual void ActorDestroy(ActorDestroyReason aWhy) override;
+
+  virtual mozilla::ipc::IPCResult RecvPPresentationRequestConstructor(
+      PPresentationRequestParent* aActor,
+      const PresentationIPCRequest& aRequest) override;
+
+  PPresentationRequestParent* AllocPPresentationRequestParent(
+      const PresentationIPCRequest& aRequest);
+
+  bool DeallocPPresentationRequestParent(PPresentationRequestParent* aActor);
+
+  PPresentationBuilderParent* AllocPPresentationBuilderParent(
+      const nsString& aSessionId, const uint8_t& aRole);
+
+  bool DeallocPPresentationBuilderParent(PPresentationBuilderParent* aActor);
+
+  virtual mozilla::ipc::IPCResult Recv__delete__() override;
+
+  mozilla::ipc::IPCResult RecvRegisterAvailabilityHandler(
+      nsTArray<nsString>&& aAvailabilityUrls);
+
+  mozilla::ipc::IPCResult RecvUnregisterAvailabilityHandler(
+      nsTArray<nsString>&& aAvailabilityUrls);
+
+  mozilla::ipc::IPCResult RecvRegisterSessionHandler(const nsString& aSessionId,
+                                                     const uint8_t& aRole);
+
+  mozilla::ipc::IPCResult RecvUnregisterSessionHandler(
+      const nsString& aSessionId, const uint8_t& aRole);
+
+  mozilla::ipc::IPCResult RecvRegisterRespondingHandler(
+      const uint64_t& aWindowId);
+
+  mozilla::ipc::IPCResult RecvUnregisterRespondingHandler(
+      const uint64_t& aWindowId);
+
+  mozilla::ipc::IPCResult RecvNotifyReceiverReady(const nsString& aSessionId,
+                                                  const uint64_t& aWindowId,
+                                                  const bool& aIsLoading);
+
+  mozilla::ipc::IPCResult RecvNotifyTransportClosed(const nsString& aSessionId,
+                                                    const uint8_t& aRole,
+                                                    const nsresult& aReason);
+
+ private:
+  virtual ~PresentationParent();
+
+  bool mActorDestroyed = false;
+  nsCOMPtr<nsIPresentationService> mService;
+  nsTArray<nsString> mSessionIdsAtController;
+  nsTArray<nsString> mSessionIdsAtReceiver;
+  nsTArray<uint64_t> mWindowIds;
+  ContentParentId mChildId;
+  nsTArray<nsString> mContentAvailabilityUrls;
+};
+
+class PresentationRequestParent final : public PPresentationRequestParent,
+                                        public nsIPresentationServiceCallback {
+  friend class PresentationParent;
+
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPRESENTATIONSERVICECALLBACK
+
+  explicit PresentationRequestParent(nsIPresentationService* aService,
+                                     ContentParentId aContentParentId);
+
+  virtual void ActorDestroy(ActorDestroyReason aWhy) override;
+
+ private:
+  virtual ~PresentationRequestParent();
+
+  nsresult SendResponse(nsresult aResult);
+
+  nsresult DoRequest(const StartSessionRequest& aRequest);
+
+  nsresult DoRequest(const SendSessionMessageRequest& aRequest);
+
+  nsresult DoRequest(const CloseSessionRequest& aRequest);
+
+  nsresult DoRequest(const TerminateSessionRequest& aRequest);
+
+  nsresult DoRequest(const ReconnectSessionRequest& aRequest);
+
+  nsresult DoRequest(const BuildTransportRequest& aRequest);
+
+  bool mActorDestroyed = false;
+  bool mNeedRegisterBuilder = false;
+  nsString mSessionId;
+  nsCOMPtr<nsIPresentationService> mService;
+  ContentParentId mChildId;
+};
+
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_PresentationParent_h__
diff --git a/dom/presentation/moz.build b/dom/presentation/moz.build
new file mode 100644
index 0000000000..2b8ad19fd1
--- /dev/null
+++ b/dom/presentation/moz.build
@@ -0,0 +1,88 @@
+# -*- 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: Core & HTML")
+
+DIRS += ["interfaces", "provider"]
+
+XPCSHELL_TESTS_MANIFESTS += ["tests/xpcshell/xpcshell.ini"]
+MOCHITEST_MANIFESTS += ["tests/mochitest/mochitest.ini"]
+MOCHITEST_CHROME_MANIFESTS += ["tests/mochitest/chrome.ini"]
+
+EXPORTS.mozilla.dom += [
+    "DCPresentationChannelDescription.h",
+    "ipc/PresentationBuilderChild.h",
+    "ipc/PresentationBuilderParent.h",
+    "ipc/PresentationChild.h",
+    "ipc/PresentationIPCService.h",
+    "ipc/PresentationParent.h",
+    "MockedSocketTransport.h",
+    "Presentation.h",
+    "PresentationAvailability.h",
+    "PresentationCallbacks.h",
+    "PresentationConnection.h",
+    "PresentationConnectionList.h",
+    "PresentationDeviceManager.h",
+    "PresentationReceiver.h",
+    "PresentationRequest.h",
+    "PresentationService.h",
+    "PresentationServiceBase.h",
+    "PresentationSessionInfo.h",
+    "PresentationTCPSessionTransport.h",
+]
+
+UNIFIED_SOURCES += [
+    "AvailabilityCollection.cpp",
+    "ControllerConnectionCollection.cpp",
+    "DCPresentationChannelDescription.cpp",
+    "ipc/PresentationBuilderChild.cpp",
+    "ipc/PresentationBuilderParent.cpp",
+    "ipc/PresentationChild.cpp",
+    "ipc/PresentationContentSessionInfo.cpp",
+    "ipc/PresentationIPCService.cpp",
+    "ipc/PresentationParent.cpp",
+    "MockedSocketTransport.cpp",
+    "Presentation.cpp",
+    "PresentationAvailability.cpp",
+    "PresentationCallbacks.cpp",
+    "PresentationConnection.cpp",
+    "PresentationConnectionList.cpp",
+    "PresentationDeviceManager.cpp",
+    "PresentationReceiver.cpp",
+    "PresentationRequest.cpp",
+    "PresentationService.cpp",
+    "PresentationSessionInfo.cpp",
+    "PresentationSessionRequest.cpp",
+    "PresentationTCPSessionTransport.cpp",
+    "PresentationTerminateRequest.cpp",
+    "PresentationTransportBuilderConstructor.cpp",
+]
+
+EXTRA_JS_MODULES += [
+    "PresentationDataChannelSessionTransport.jsm",
+]
+
+XPCOM_MANIFESTS += [
+    "components.conf",
+]
+
+if CONFIG["MOZ_WIDGET_TOOLKIT"] == "android":
+    EXTRA_JS_MODULES += [
+        "PresentationNetworkHelper.jsm",
+    ]
+
+IPDL_SOURCES += [
+    "ipc/PPresentation.ipdl",
+    "ipc/PPresentationBuilder.ipdl",
+    "ipc/PPresentationRequest.ipdl",
+]
+
+LOCAL_INCLUDES += ["../base"]
+
+include("/ipc/chromium/chromium-config.mozbuild")
+
+FINAL_LIBRARY = "xul"
diff --git a/dom/presentation/provider/ControllerStateMachine.jsm b/dom/presentation/provider/ControllerStateMachine.jsm
new file mode 100644
index 0000000000..03f6b35bd5
--- /dev/null
+++ b/dom/presentation/provider/ControllerStateMachine.jsm
@@ -0,0 +1,236 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 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/. */
+
+"use strict";
+
+var EXPORTED_SYMBOLS = ["ControllerStateMachine"];
+
+const { CommandType, State } = ChromeUtils.import(
+  "resource://gre/modules/presentation/StateMachineHelper.jsm"
+);
+
+const DEBUG = false;
+function debug(str) {
+  dump("-*- ControllerStateMachine: " + str + "\n");
+}
+
+var handlers = [
+  function _initHandler(stateMachine, command) {
+    // shouldn't receive any command at init state.
+    DEBUG && debug("unexpected command: " + JSON.stringify(command));
+  },
+  function _connectingHandler(stateMachine, command) {
+    switch (command.type) {
+      case CommandType.CONNECT_ACK:
+        stateMachine.state = State.CONNECTED;
+        stateMachine._notifyDeviceConnected();
+        break;
+      case CommandType.DISCONNECT:
+        stateMachine.state = State.CLOSED;
+        stateMachine._notifyDisconnected(command.reason);
+        break;
+      default:
+        debug("unexpected command: " + JSON.stringify(command));
+        // ignore unexpected command.
+        break;
+    }
+  },
+  function _connectedHandler(stateMachine, command) {
+    switch (command.type) {
+      case CommandType.DISCONNECT:
+        stateMachine.state = State.CLOSED;
+        stateMachine._notifyDisconnected(command.reason);
+        break;
+      case CommandType.LAUNCH_ACK:
+        stateMachine._notifyLaunch(command.presentationId);
+        break;
+      case CommandType.TERMINATE:
+        stateMachine._notifyTerminate(command.presentationId);
+        break;
+      case CommandType.TERMINATE_ACK:
+        stateMachine._notifyTerminate(command.presentationId);
+        break;
+      case CommandType.ANSWER:
+      case CommandType.ICE_CANDIDATE:
+        stateMachine._notifyChannelDescriptor(command);
+        break;
+      case CommandType.RECONNECT_ACK:
+        stateMachine._notifyReconnect(command.presentationId);
+        break;
+      default:
+        debug("unexpected command: " + JSON.stringify(command));
+        // ignore unexpected command.
+        break;
+    }
+  },
+  function _closingHandler(stateMachine, command) {
+    switch (command.type) {
+      case CommandType.DISCONNECT:
+        stateMachine.state = State.CLOSED;
+        stateMachine._notifyDisconnected(command.reason);
+        break;
+      default:
+        debug("unexpected command: " + JSON.stringify(command));
+        // ignore unexpected command.
+        break;
+    }
+  },
+  function _closedHandler(stateMachine, command) {
+    // ignore every command in closed state.
+    DEBUG && debug("unexpected command: " + JSON.stringify(command));
+  },
+];
+
+function ControllerStateMachine(channel, deviceId) {
+  this.state = State.INIT;
+  this._channel = channel;
+  this._deviceId = deviceId;
+}
+
+ControllerStateMachine.prototype = {
+  launch: function _launch(presentationId, url) {
+    if (this.state === State.CONNECTED) {
+      this._sendCommand({
+        type: CommandType.LAUNCH,
+        presentationId,
+        url,
+      });
+    }
+  },
+
+  terminate: function _terminate(presentationId) {
+    if (this.state === State.CONNECTED) {
+      this._sendCommand({
+        type: CommandType.TERMINATE,
+        presentationId,
+      });
+    }
+  },
+
+  terminateAck: function _terminateAck(presentationId) {
+    if (this.state === State.CONNECTED) {
+      this._sendCommand({
+        type: CommandType.TERMINATE_ACK,
+        presentationId,
+      });
+    }
+  },
+
+  reconnect: function _reconnect(presentationId, url) {
+    if (this.state === State.CONNECTED) {
+      this._sendCommand({
+        type: CommandType.RECONNECT,
+        presentationId,
+        url,
+      });
+    }
+  },
+
+  sendOffer: function _sendOffer(offer) {
+    if (this.state === State.CONNECTED) {
+      this._sendCommand({
+        type: CommandType.OFFER,
+        offer,
+      });
+    }
+  },
+
+  sendAnswer: function _sendAnswer() {
+    // answer can only be sent by presenting UA.
+    debug("controller shouldn't generate answer");
+  },
+
+  updateIceCandidate: function _updateIceCandidate(candidate) {
+    if (this.state === State.CONNECTED) {
+      this._sendCommand({
+        type: CommandType.ICE_CANDIDATE,
+        candidate,
+      });
+    }
+  },
+
+  onCommand: function _onCommand(command) {
+    handlers[this.state](this, command);
+  },
+
+  onChannelReady: function _onChannelReady() {
+    if (this.state === State.INIT) {
+      this._sendCommand({
+        type: CommandType.CONNECT,
+        deviceId: this._deviceId,
+      });
+      this.state = State.CONNECTING;
+    }
+  },
+
+  onChannelClosed: function _onChannelClose(reason, isByRemote) {
+    switch (this.state) {
+      case State.CONNECTED:
+        if (isByRemote) {
+          this.state = State.CLOSED;
+          this._notifyDisconnected(reason);
+        } else {
+          this._sendCommand({
+            type: CommandType.DISCONNECT,
+            reason,
+          });
+          this.state = State.CLOSING;
+          this._closeReason = reason;
+        }
+        break;
+      case State.CLOSING:
+        if (isByRemote) {
+          this.state = State.CLOSED;
+          if (this._closeReason) {
+            reason = this._closeReason;
+            delete this._closeReason;
+          }
+          this._notifyDisconnected(reason);
+        }
+        break;
+      default:
+        DEBUG &&
+          debug("unexpected channel close: " + reason + ", " + isByRemote);
+        break;
+    }
+  },
+
+  _sendCommand: function _sendCommand(command) {
+    this._channel.sendCommand(command);
+  },
+
+  _notifyDeviceConnected: function _notifyDeviceConnected() {
+    // XXX trigger following command
+    this._channel.notifyDeviceConnected();
+  },
+
+  _notifyDisconnected: function _notifyDisconnected(reason) {
+    this._channel.notifyDisconnected(reason);
+  },
+
+  _notifyLaunch: function _notifyLaunch(presentationId) {
+    this._channel.notifyLaunch(presentationId);
+  },
+
+  _notifyTerminate: function _notifyTerminate(presentationId) {
+    this._channel.notifyTerminate(presentationId);
+  },
+
+  _notifyReconnect: function _notifyReconnect(presentationId) {
+    this._channel.notifyReconnect(presentationId);
+  },
+
+  _notifyChannelDescriptor: function _notifyChannelDescriptor(command) {
+    switch (command.type) {
+      case CommandType.ANSWER:
+        this._channel.notifyAnswer(command.answer);
+        break;
+      case CommandType.ICE_CANDIDATE:
+        this._channel.notifyIceCandidate(command.candidate);
+        break;
+    }
+  },
+};
diff --git a/dom/presentation/provider/DeviceProviderHelpers.cpp b/dom/presentation/provider/DeviceProviderHelpers.cpp
new file mode 100644
index 0000000000..011afc7040
--- /dev/null
+++ b/dom/presentation/provider/DeviceProviderHelpers.cpp
@@ -0,0 +1,53 @@
+/* -*- 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 "DeviceProviderHelpers.h"
+
+#include "nsCOMPtr.h"
+#include "nsIURI.h"
+#include "nsNetUtil.h"
+
+namespace mozilla {
+namespace dom {
+namespace presentation {
+
+static const char* const kFxTVPresentationAppUrls[] = {
+    "app://fling-player.gaiamobile.org/index.html",
+    "app://notification-receiver.gaiamobile.org/index.html", nullptr};
+
+/* static */
+bool DeviceProviderHelpers::IsCommonlySupportedScheme(const nsAString& aUrl) {
+  nsCOMPtr<nsIURI> uri;
+  nsresult rv = NS_NewURI(getter_AddRefs(uri), aUrl);
+  if (NS_FAILED(rv) || !uri) {
+    return false;
+  }
+
+  nsAutoCString scheme;
+  uri->GetScheme(scheme);
+  if (scheme.LowerCaseEqualsLiteral("http") ||
+      scheme.LowerCaseEqualsLiteral("https")) {
+    return true;
+  }
+
+  return false;
+}
+
+/* static */
+bool DeviceProviderHelpers::IsFxTVSupportedAppUrl(const nsAString& aUrl) {
+  // Check if matched with any presentation Apps on TV.
+  for (uint32_t i = 0; kFxTVPresentationAppUrls[i]; i++) {
+    if (aUrl.EqualsASCII(kFxTVPresentationAppUrls[i])) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+}  // namespace presentation
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/presentation/provider/DeviceProviderHelpers.h b/dom/presentation/provider/DeviceProviderHelpers.h
new file mode 100644
index 0000000000..4bf6f9ae5b
--- /dev/null
+++ b/dom/presentation/provider/DeviceProviderHelpers.h
@@ -0,0 +1,29 @@
+/* -*- 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_presentation_DeviceProviderHelpers_h
+#define mozilla_dom_presentation_DeviceProviderHelpers_h
+
+#include "nsString.h"
+
+namespace mozilla {
+namespace dom {
+namespace presentation {
+
+class DeviceProviderHelpers final {
+ public:
+  static bool IsCommonlySupportedScheme(const nsAString& aUrl);
+  static bool IsFxTVSupportedAppUrl(const nsAString& aUrl);
+
+ private:
+  DeviceProviderHelpers() = delete;
+};
+
+}  // namespace presentation
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_presentation_DeviceProviderHelpers_h
diff --git a/dom/presentation/provider/MulticastDNSDeviceProvider.cpp b/dom/presentation/provider/MulticastDNSDeviceProvider.cpp
new file mode 100644
index 0000000000..d5f443dfd2
--- /dev/null
+++ b/dom/presentation/provider/MulticastDNSDeviceProvider.cpp
@@ -0,0 +1,1153 @@
+/* -*- 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 "MulticastDNSDeviceProvider.h"
+
+#include "DeviceProviderHelpers.h"
+#include "MainThreadUtils.h"
+#include "mozilla/IntegerPrintfMacros.h"
+#include "mozilla/Logging.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/Unused.h"
+#include "nsComponentManagerUtils.h"
+#include "nsIWritablePropertyBag2.h"
+#include "nsServiceManagerUtils.h"
+#include "nsTCPDeviceInfo.h"
+#include "nsThreadUtils.h"
+
+#ifdef MOZ_WIDGET_ANDROID
+#  include "nsIPropertyBag2.h"
+#endif  // MOZ_WIDGET_ANDROID
+
+#define PREF_PRESENTATION_DISCOVERY "dom.presentation.discovery.enabled"
+#define PREF_PRESENTATION_DISCOVERY_TIMEOUT_MS \
+  "dom.presentation.discovery.timeout_ms"
+#define PREF_PRESENTATION_DISCOVERABLE "dom.presentation.discoverable"
+#define PREF_PRESENTATION_DISCOVERABLE_ENCRYPTED \
+  "dom.presentation.discoverable.encrypted"
+#define PREF_PRESENTATION_DISCOVERABLE_RETRY_MS \
+  "dom.presentation.discoverable.retry_ms"
+#define PREF_PRESENTATION_DEVICE_NAME "dom.presentation.device.name"
+
+#define SERVICE_TYPE "_presentation-ctrl._tcp"
+#define PROTOCOL_VERSION_TAG u"version"
+#define CERT_FINGERPRINT_TAG u"certFingerprint"
+
+static mozilla::LazyLogModule sMulticastDNSProviderLogModule(
+    "MulticastDNSDeviceProvider");
+
+#undef LOG_I
+#define LOG_I(...)                                                  \
+  MOZ_LOG(sMulticastDNSProviderLogModule, mozilla::LogLevel::Debug, \
+          (__VA_ARGS__))
+#undef LOG_E
+#define LOG_E(...)                                                  \
+  MOZ_LOG(sMulticastDNSProviderLogModule, mozilla::LogLevel::Error, \
+          (__VA_ARGS__))
+
+namespace mozilla {
+namespace dom {
+namespace presentation {
+
+static const char* kObservedPrefs[] = {
+    PREF_PRESENTATION_DISCOVERY, PREF_PRESENTATION_DISCOVERY_TIMEOUT_MS,
+    PREF_PRESENTATION_DISCOVERABLE, PREF_PRESENTATION_DEVICE_NAME, nullptr};
+
+namespace {
+
+#ifdef MOZ_WIDGET_ANDROID
+static void GetAndroidDeviceName(nsACString& aRetVal) {
+  nsCOMPtr<nsIPropertyBag2> infoService =
+      do_GetService("@mozilla.org/system-info;1");
+  MOZ_ASSERT(infoService, "Could not find a system info service");
+
+  Unused << NS_WARN_IF(
+      NS_FAILED(infoService->GetPropertyAsACString(u"device"_ns, aRetVal)));
+}
+#endif  // MOZ_WIDGET_ANDROID
+
+}  // anonymous namespace
+
+/**
+ * This wrapper is used to break circular-reference problem.
+ */
+class DNSServiceWrappedListener final
+    : public nsIDNSServiceDiscoveryListener,
+      public nsIDNSRegistrationListener,
+      public nsIDNSServiceResolveListener,
+      public nsIPresentationControlServerListener {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_FORWARD_SAFE_NSIDNSSERVICEDISCOVERYLISTENER(mListener)
+  NS_FORWARD_SAFE_NSIDNSREGISTRATIONLISTENER(mListener)
+  NS_FORWARD_SAFE_NSIDNSSERVICERESOLVELISTENER(mListener)
+  NS_FORWARD_SAFE_NSIPRESENTATIONCONTROLSERVERLISTENER(mListener)
+
+  explicit DNSServiceWrappedListener() = default;
+
+  nsresult SetListener(MulticastDNSDeviceProvider* aListener) {
+    mListener = aListener;
+    return NS_OK;
+  }
+
+ private:
+  virtual ~DNSServiceWrappedListener() = default;
+
+  MulticastDNSDeviceProvider* mListener = nullptr;
+};
+
+NS_IMPL_ISUPPORTS(DNSServiceWrappedListener, nsIDNSServiceDiscoveryListener,
+                  nsIDNSRegistrationListener, nsIDNSServiceResolveListener,
+                  nsIPresentationControlServerListener)
+
+NS_IMPL_ISUPPORTS(MulticastDNSDeviceProvider, nsIPresentationDeviceProvider,
+                  nsIDNSServiceDiscoveryListener, nsIDNSRegistrationListener,
+                  nsIDNSServiceResolveListener,
+                  nsIPresentationControlServerListener, nsIObserver)
+
+MulticastDNSDeviceProvider::MulticastDNSDeviceProvider() = default;
+MulticastDNSDeviceProvider::~MulticastDNSDeviceProvider() { Uninit(); }
+
+nsresult MulticastDNSDeviceProvider::Init() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (mInitialized) {
+    return NS_OK;
+  }
+
+  nsresult rv;
+
+  mMulticastDNS = do_GetService(DNSSERVICEDISCOVERY_CONTRACT_ID, &rv);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  mWrappedListener = new DNSServiceWrappedListener();
+  if (NS_WARN_IF(NS_FAILED(rv = mWrappedListener->SetListener(this)))) {
+    return rv;
+  }
+
+  mPresentationService =
+      do_CreateInstance(PRESENTATION_CONTROL_SERVICE_CONTACT_ID, &rv);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  mDiscoveryTimer = NS_NewTimer();
+  if (NS_WARN_IF(!mDiscoveryTimer)) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+
+  mServerRetryTimer = NS_NewTimer();
+  if (NS_WARN_IF(!mServerRetryTimer)) {
+    return NS_ERROR_OUT_OF_MEMORY;
+  }
+  Preferences::AddStrongObservers(this, kObservedPrefs);
+
+  mDiscoveryEnabled = Preferences::GetBool(PREF_PRESENTATION_DISCOVERY);
+  mDiscoveryTimeoutMs =
+      Preferences::GetUint(PREF_PRESENTATION_DISCOVERY_TIMEOUT_MS);
+  mDiscoverable = Preferences::GetBool(PREF_PRESENTATION_DISCOVERABLE);
+  mDiscoverableEncrypted =
+      Preferences::GetBool(PREF_PRESENTATION_DISCOVERABLE_ENCRYPTED);
+  mServerRetryMs =
+      Preferences::GetUint(PREF_PRESENTATION_DISCOVERABLE_RETRY_MS);
+  mServiceName.Truncate();
+  Preferences::GetCString(PREF_PRESENTATION_DEVICE_NAME, mServiceName);
+
+#ifdef MOZ_WIDGET_ANDROID
+  // FIXME: Bug 1185806 - Provide a common device name setting.
+  if (mServiceName.IsEmpty()) {
+    GetAndroidDeviceName(mServiceName);
+    Unused << Preferences::SetCString(PREF_PRESENTATION_DEVICE_NAME,
+                                      mServiceName);
+  }
+#endif  // MOZ_WIDGET_ANDROID
+
+  Unused << mPresentationService->SetId(mServiceName);
+
+  if (mDiscoveryEnabled && NS_WARN_IF(NS_FAILED(rv = ForceDiscovery()))) {
+    return rv;
+  }
+
+  if (mDiscoverable && NS_WARN_IF(NS_FAILED(rv = StartServer()))) {
+    return rv;
+  }
+
+  mInitialized = true;
+  return NS_OK;
+}
+
+void MulticastDNSDeviceProvider::Uninit() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!mInitialized) {
+    return;
+  }
+
+  ClearDevices();
+
+  Preferences::RemoveObservers(this, kObservedPrefs);
+
+  StopDiscovery(NS_OK);
+  StopServer();
+
+  mMulticastDNS = nullptr;
+
+  if (mWrappedListener) {
+    mWrappedListener->SetListener(nullptr);
+    mWrappedListener = nullptr;
+  }
+
+  mInitialized = false;
+}
+
+nsresult MulticastDNSDeviceProvider::StartServer() {
+  LOG_I("StartServer: %s (%d)", mServiceName.get(), mDiscoverable);
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!mDiscoverable) {
+    return NS_OK;
+  }
+
+  nsresult rv;
+
+  uint16_t servicePort;
+  if (NS_WARN_IF(NS_FAILED(rv = mPresentationService->GetPort(&servicePort)))) {
+    return rv;
+  }
+
+  /**
+   * If |servicePort| is non-zero, it means PresentationControlService is
+   * running. Otherwise, we should make it start serving.
+   */
+  if (servicePort) {
+    return RegisterMDNSService();
+  }
+
+  if (NS_WARN_IF(NS_FAILED(
+          rv = mPresentationService->SetListener(mWrappedListener)))) {
+    return rv;
+  }
+
+  AbortServerRetry();
+
+  if (NS_WARN_IF(NS_FAILED(
+          rv = mPresentationService->StartServer(mDiscoverableEncrypted, 0)))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+void MulticastDNSDeviceProvider::StopServer() {
+  LOG_I("StopServer: %s", mServiceName.get());
+  MOZ_ASSERT(NS_IsMainThread());
+
+  UnregisterMDNSService(NS_OK);
+
+  AbortServerRetry();
+
+  if (mPresentationService) {
+    mPresentationService->SetListener(nullptr);
+    mPresentationService->Close();
+  }
+}
+
+void MulticastDNSDeviceProvider::AbortServerRetry() {
+  if (mIsServerRetrying) {
+    mIsServerRetrying = false;
+    mServerRetryTimer->Cancel();
+  }
+}
+
+nsresult MulticastDNSDeviceProvider::RegisterMDNSService() {
+  LOG_I("RegisterMDNSService: %s", mServiceName.get());
+
+  if (!mDiscoverable) {
+    return NS_OK;
+  }
+
+  // Cancel on going service registration.
+  UnregisterMDNSService(NS_OK);
+
+  nsresult rv;
+
+  uint16_t servicePort;
+  if (NS_FAILED(rv = mPresentationService->GetPort(&servicePort)) ||
+      !servicePort) {
+    // Abort service registration if server port is not available.
+    return rv;
+  }
+
+  /**
+   * Register the presentation control channel server as an mDNS service.
+   */
+  nsCOMPtr<nsIDNSServiceInfo> serviceInfo =
+      do_CreateInstance(DNSSERVICEINFO_CONTRACT_ID, &rv);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+  if (NS_WARN_IF(NS_FAILED(
+          rv = serviceInfo->SetServiceType(nsLiteralCString(SERVICE_TYPE))))) {
+    return rv;
+  }
+  if (NS_WARN_IF(NS_FAILED(rv = serviceInfo->SetServiceName(mServiceName)))) {
+    return rv;
+  }
+  if (NS_WARN_IF(NS_FAILED(rv = serviceInfo->SetPort(servicePort)))) {
+    return rv;
+  }
+
+  nsCOMPtr<nsIWritablePropertyBag2> propBag =
+      do_CreateInstance("@mozilla.org/hash-property-bag;1");
+  MOZ_ASSERT(propBag);
+
+  uint32_t version;
+  rv = mPresentationService->GetVersion(&version);
+  MOZ_ASSERT(NS_SUCCEEDED(rv));
+
+  rv = propBag->SetPropertyAsUint32(nsLiteralString(PROTOCOL_VERSION_TAG),
+                                    version);
+  MOZ_ASSERT(NS_SUCCEEDED(rv));
+
+  if (mDiscoverableEncrypted) {
+    nsAutoCString certFingerprint;
+    rv = mPresentationService->GetCertFingerprint(certFingerprint);
+    MOZ_ASSERT(NS_SUCCEEDED(rv));
+
+    rv = propBag->SetPropertyAsACString(nsLiteralString(CERT_FINGERPRINT_TAG),
+                                        certFingerprint);
+    MOZ_ASSERT(NS_SUCCEEDED(rv));
+  }
+
+  if (NS_WARN_IF(NS_FAILED(rv = serviceInfo->SetAttributes(propBag)))) {
+    return rv;
+  }
+
+  return mMulticastDNS->RegisterService(serviceInfo, mWrappedListener,
+                                        getter_AddRefs(mRegisterRequest));
+}
+
+void MulticastDNSDeviceProvider::UnregisterMDNSService(nsresult aReason) {
+  LOG_I("UnregisterMDNSService: %s (0x%08" PRIx32 ")", mServiceName.get(),
+        static_cast<uint32_t>(aReason));
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (mRegisterRequest) {
+    mRegisterRequest->Cancel(aReason);
+    mRegisterRequest = nullptr;
+  }
+}
+
+nsresult MulticastDNSDeviceProvider::StopDiscovery(nsresult aReason) {
+  LOG_I("StopDiscovery (0x%08" PRIx32 ")", static_cast<uint32_t>(aReason));
+
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(mDiscoveryTimer);
+
+  Unused << mDiscoveryTimer->Cancel();
+
+  if (mDiscoveryRequest) {
+    mDiscoveryRequest->Cancel(aReason);
+    mDiscoveryRequest = nullptr;
+  }
+
+  return NS_OK;
+}
+
+nsresult MulticastDNSDeviceProvider::Connect(
+    Device* aDevice, nsIPresentationControlChannel** aRetVal) {
+  MOZ_ASSERT(aDevice);
+  MOZ_ASSERT(mPresentationService);
+
+  RefPtr<TCPDeviceInfo> deviceInfo =
+      new TCPDeviceInfo(aDevice->Id(), aDevice->Address(), aDevice->Port(),
+                        aDevice->CertFingerprint());
+
+  return mPresentationService->Connect(deviceInfo, aRetVal);
+}
+
+bool MulticastDNSDeviceProvider::IsCompatibleServer(
+    nsIDNSServiceInfo* aServiceInfo) {
+  MOZ_ASSERT(aServiceInfo);
+
+  nsCOMPtr<nsIPropertyBag2> propBag;
+  if (NS_WARN_IF(
+          NS_FAILED(aServiceInfo->GetAttributes(getter_AddRefs(propBag)))) ||
+      !propBag) {
+    return false;
+  }
+
+  uint32_t remoteVersion;
+  if (NS_WARN_IF(NS_FAILED(propBag->GetPropertyAsUint32(
+          nsLiteralString(PROTOCOL_VERSION_TAG), &remoteVersion)))) {
+    return false;
+  }
+
+  bool isCompatible = false;
+  Unused << NS_WARN_IF(NS_FAILED(
+      mPresentationService->IsCompatibleServer(remoteVersion, &isCompatible)));
+
+  return isCompatible;
+}
+
+nsresult MulticastDNSDeviceProvider::AddDevice(
+    const nsACString& aId, const nsACString& aServiceName,
+    const nsACString& aServiceType, const nsACString& aAddress,
+    const uint16_t aPort, const nsACString& aCertFingerprint) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(mPresentationService);
+
+  RefPtr<Device> device =
+      new Device(aId, /* ID */
+                 aServiceName, aServiceType, aAddress, aPort, aCertFingerprint,
+                 DeviceState::eActive, this);
+
+  nsCOMPtr<nsIPresentationDeviceListener> listener;
+  if (NS_SUCCEEDED(GetListener(getter_AddRefs(listener))) && listener) {
+    Unused << listener->AddDevice(device);
+  }
+
+  mDevices.AppendElement(device);
+
+  return NS_OK;
+}
+
+nsresult MulticastDNSDeviceProvider::UpdateDevice(
+    const uint32_t aIndex, const nsACString& aServiceName,
+    const nsACString& aServiceType, const nsACString& aAddress,
+    const uint16_t aPort, const nsACString& aCertFingerprint) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(mPresentationService);
+
+  if (NS_WARN_IF(aIndex >= mDevices.Length())) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  RefPtr<Device> device = mDevices[aIndex];
+  device->Update(aServiceName, aServiceType, aAddress, aPort, aCertFingerprint);
+  device->ChangeState(DeviceState::eActive);
+
+  nsCOMPtr<nsIPresentationDeviceListener> listener;
+  if (NS_SUCCEEDED(GetListener(getter_AddRefs(listener))) && listener) {
+    Unused << listener->UpdateDevice(device);
+  }
+
+  return NS_OK;
+}
+
+nsresult MulticastDNSDeviceProvider::RemoveDevice(const uint32_t aIndex) {
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(mPresentationService);
+
+  if (NS_WARN_IF(aIndex >= mDevices.Length())) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  RefPtr<Device> device = mDevices[aIndex];
+
+  LOG_I("RemoveDevice: %s", device->Id().get());
+  mDevices.RemoveElementAt(aIndex);
+
+  nsCOMPtr<nsIPresentationDeviceListener> listener;
+  if (NS_SUCCEEDED(GetListener(getter_AddRefs(listener))) && listener) {
+    Unused << listener->RemoveDevice(device);
+  }
+
+  return NS_OK;
+}
+
+bool MulticastDNSDeviceProvider::FindDeviceById(const nsACString& aId,
+                                                uint32_t& aIndex) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  RefPtr<Device> device = new Device(aId,
+                                     /* aName = */ ""_ns,
+                                     /* aType = */ ""_ns,
+                                     /* aHost = */ ""_ns,
+                                     /* aPort = */ 0,
+                                     /* aCertFingerprint */ ""_ns,
+                                     /* aState = */ DeviceState::eUnknown,
+                                     /* aProvider = */ nullptr);
+  size_t index = mDevices.IndexOf(device, 0, DeviceIdComparator());
+
+  if (index == mDevices.NoIndex) {
+    return false;
+  }
+
+  aIndex = index;
+  return true;
+}
+
+bool MulticastDNSDeviceProvider::FindDeviceByAddress(const nsACString& aAddress,
+                                                     uint32_t& aIndex) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  RefPtr<Device> device = new Device(/* aId = */ ""_ns,
+                                     /* aName = */ ""_ns,
+                                     /* aType = */ ""_ns, aAddress,
+                                     /* aPort = */ 0,
+                                     /* aCertFingerprint */ ""_ns,
+                                     /* aState = */ DeviceState::eUnknown,
+                                     /* aProvider = */ nullptr);
+  size_t index = mDevices.IndexOf(device, 0, DeviceAddressComparator());
+
+  if (index == mDevices.NoIndex) {
+    return false;
+  }
+
+  aIndex = index;
+  return true;
+}
+
+void MulticastDNSDeviceProvider::MarkAllDevicesUnknown() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  for (auto& device : mDevices) {
+    device->ChangeState(DeviceState::eUnknown);
+  }
+}
+
+void MulticastDNSDeviceProvider::ClearUnknownDevices() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  size_t i = mDevices.Length();
+  while (i > 0) {
+    --i;
+    if (mDevices[i]->State() == DeviceState::eUnknown) {
+      Unused << NS_WARN_IF(NS_FAILED(RemoveDevice(i)));
+    }
+  }
+}
+
+void MulticastDNSDeviceProvider::ClearDevices() {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  size_t i = mDevices.Length();
+  while (i > 0) {
+    --i;
+    Unused << NS_WARN_IF(NS_FAILED(RemoveDevice(i)));
+  }
+}
+
+// nsIPresentationDeviceProvider
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::GetListener(
+    nsIPresentationDeviceListener** aListener) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (NS_WARN_IF(!aListener)) {
+    return NS_ERROR_INVALID_POINTER;
+  }
+
+  nsresult rv;
+  nsCOMPtr<nsIPresentationDeviceListener> listener =
+      do_QueryReferent(mDeviceListener, &rv);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  listener.forget(aListener);
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::SetListener(
+    nsIPresentationDeviceListener* aListener) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  mDeviceListener = do_GetWeakReference(aListener);
+
+  nsresult rv;
+  if (mDeviceListener) {
+    if (NS_WARN_IF(NS_FAILED(rv = Init()))) {
+      return rv;
+    }
+  } else {
+    Uninit();
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::ForceDiscovery() {
+  LOG_I("ForceDiscovery (%d)", mDiscoveryEnabled);
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!mDiscoveryEnabled) {
+    return NS_OK;
+  }
+
+  MOZ_ASSERT(mDiscoveryTimer);
+  MOZ_ASSERT(mMulticastDNS);
+
+  // if it's already discovering, extend existing discovery timeout.
+  nsresult rv;
+  if (mIsDiscovering) {
+    Unused << mDiscoveryTimer->Cancel();
+
+    if (NS_WARN_IF(
+            NS_FAILED(rv = mDiscoveryTimer->Init(this, mDiscoveryTimeoutMs,
+                                                 nsITimer::TYPE_ONE_SHOT)))) {
+      return rv;
+    }
+    return NS_OK;
+  }
+
+  StopDiscovery(NS_OK);
+
+  if (NS_WARN_IF(NS_FAILED(rv = mMulticastDNS->StartDiscovery(
+                               nsLiteralCString(SERVICE_TYPE), mWrappedListener,
+                               getter_AddRefs(mDiscoveryRequest))))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+// nsIDNSServiceDiscoveryListener
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::OnDiscoveryStarted(const nsACString& aServiceType) {
+  LOG_I("OnDiscoveryStarted");
+  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(mDiscoveryTimer);
+
+  MarkAllDevicesUnknown();
+
+  nsresult rv;
+  if (NS_WARN_IF(
+          NS_FAILED(rv = mDiscoveryTimer->Init(this, mDiscoveryTimeoutMs,
+                                               nsITimer::TYPE_ONE_SHOT)))) {
+    return rv;
+  }
+
+  mIsDiscovering = true;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::OnDiscoveryStopped(const nsACString& aServiceType) {
+  LOG_I("OnDiscoveryStopped");
+  MOZ_ASSERT(NS_IsMainThread());
+
+  ClearUnknownDevices();
+
+  mIsDiscovering = false;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::OnServiceFound(nsIDNSServiceInfo* aServiceInfo) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (NS_WARN_IF(!aServiceInfo)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  nsresult rv;
+
+  nsAutoCString serviceName;
+  if (NS_WARN_IF(NS_FAILED(rv = aServiceInfo->GetServiceName(serviceName)))) {
+    return rv;
+  }
+
+  LOG_I("OnServiceFound: %s", serviceName.get());
+
+  if (mMulticastDNS) {
+    if (NS_WARN_IF(NS_FAILED(rv = mMulticastDNS->ResolveService(
+                                 aServiceInfo, mWrappedListener)))) {
+      return rv;
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::OnServiceLost(nsIDNSServiceInfo* aServiceInfo) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (NS_WARN_IF(!aServiceInfo)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  nsresult rv;
+
+  nsAutoCString serviceName;
+  if (NS_WARN_IF(NS_FAILED(rv = aServiceInfo->GetServiceName(serviceName)))) {
+    return rv;
+  }
+
+  LOG_I("OnServiceLost: %s", serviceName.get());
+
+  nsAutoCString host;
+  if (NS_WARN_IF(NS_FAILED(rv = aServiceInfo->GetHost(host)))) {
+    return rv;
+  }
+
+  uint32_t index;
+  if (!FindDeviceById(host, index)) {
+    // given device was not found
+    return NS_OK;
+  }
+
+  if (NS_WARN_IF(NS_FAILED(rv = RemoveDevice(index)))) {
+    return rv;
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::OnStartDiscoveryFailed(
+    const nsACString& aServiceType, int32_t aErrorCode) {
+  LOG_E("OnStartDiscoveryFailed: %d", aErrorCode);
+  MOZ_ASSERT(NS_IsMainThread());
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::OnStopDiscoveryFailed(
+    const nsACString& aServiceType, int32_t aErrorCode) {
+  LOG_E("OnStopDiscoveryFailed: %d", aErrorCode);
+  MOZ_ASSERT(NS_IsMainThread());
+
+  return NS_OK;
+}
+
+// nsIDNSRegistrationListener
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::OnServiceRegistered(
+    nsIDNSServiceInfo* aServiceInfo) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (NS_WARN_IF(!aServiceInfo)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+  nsresult rv;
+
+  nsAutoCString name;
+  if (NS_WARN_IF(NS_FAILED(rv = aServiceInfo->GetServiceName(name)))) {
+    return rv;
+  }
+
+  LOG_I("OnServiceRegistered (%s)", name.get());
+  mRegisteredName = name;
+
+  if (mMulticastDNS) {
+    if (NS_WARN_IF(NS_FAILED(rv = mMulticastDNS->ResolveService(
+                                 aServiceInfo, mWrappedListener)))) {
+      return rv;
+    }
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::OnServiceUnregistered(
+    nsIDNSServiceInfo* aServiceInfo) {
+  LOG_I("OnServiceUnregistered");
+  MOZ_ASSERT(NS_IsMainThread());
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::OnRegistrationFailed(
+    nsIDNSServiceInfo* aServiceInfo, int32_t aErrorCode) {
+  LOG_E("OnRegistrationFailed: %d", aErrorCode);
+  MOZ_ASSERT(NS_IsMainThread());
+
+  mRegisterRequest = nullptr;
+
+  if (aErrorCode == nsIDNSRegistrationListener::ERROR_SERVICE_NOT_RUNNING) {
+    return NS_DispatchToMainThread(NewRunnableMethod(
+        "dom::presentation::MulticastDNSDeviceProvider::RegisterMDNSService",
+        this, &MulticastDNSDeviceProvider::RegisterMDNSService));
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::OnUnregistrationFailed(
+    nsIDNSServiceInfo* aServiceInfo, int32_t aErrorCode) {
+  LOG_E("OnUnregistrationFailed: %d", aErrorCode);
+  MOZ_ASSERT(NS_IsMainThread());
+
+  return NS_OK;
+}
+
+// nsIDNSServiceResolveListener
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::OnServiceResolved(nsIDNSServiceInfo* aServiceInfo) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (NS_WARN_IF(!aServiceInfo)) {
+    return NS_ERROR_INVALID_ARG;
+  }
+
+  nsresult rv;
+
+  nsAutoCString serviceName;
+  if (NS_WARN_IF(NS_FAILED(rv = aServiceInfo->GetServiceName(serviceName)))) {
+    return rv;
+  }
+
+  LOG_I("OnServiceResolved: %s", serviceName.get());
+
+  nsAutoCString host;
+  if (NS_WARN_IF(NS_FAILED(rv = aServiceInfo->GetHost(host)))) {
+    return rv;
+  }
+
+  if (mRegisteredName == serviceName) {
+    LOG_I("ignore self");
+
+    if (NS_WARN_IF(NS_FAILED(rv = mPresentationService->SetId(host)))) {
+      return rv;
+    }
+
+    return NS_OK;
+  }
+
+  if (!IsCompatibleServer(aServiceInfo)) {
+    LOG_I("ignore incompatible service: %s", serviceName.get());
+    return NS_OK;
+  }
+
+  nsAutoCString address;
+  if (NS_WARN_IF(NS_FAILED(rv = aServiceInfo->GetAddress(address)))) {
+    return rv;
+  }
+
+  uint16_t port;
+  if (NS_WARN_IF(NS_FAILED(rv = aServiceInfo->GetPort(&port)))) {
+    return rv;
+  }
+
+  nsAutoCString serviceType;
+  if (NS_WARN_IF(NS_FAILED(rv = aServiceInfo->GetServiceType(serviceType)))) {
+    return rv;
+  }
+
+  nsCOMPtr<nsIPropertyBag2> propBag;
+  if (NS_WARN_IF(
+          NS_FAILED(aServiceInfo->GetAttributes(getter_AddRefs(propBag)))) ||
+      !propBag) {
+    return rv;
+  }
+
+  nsAutoCString certFingerprint;
+  Unused << propBag->GetPropertyAsACString(
+      nsLiteralString(CERT_FINGERPRINT_TAG), certFingerprint);
+
+  uint32_t index;
+  if (FindDeviceById(host, index)) {
+    return UpdateDevice(index, serviceName, serviceType, address, port,
+                        certFingerprint);
+  }
+  return AddDevice(host, serviceName, serviceType, address, port,
+                   certFingerprint);
+}
+
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::OnResolveFailed(nsIDNSServiceInfo* aServiceInfo,
+                                            int32_t aErrorCode) {
+  LOG_E("OnResolveFailed: %d", aErrorCode);
+  MOZ_ASSERT(NS_IsMainThread());
+
+  return NS_OK;
+}
+
+// nsIPresentationControlServerListener
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::OnServerReady(uint16_t aPort,
+                                          const nsACString& aCertFingerprint) {
+  LOG_I("OnServerReady: %d, %s", aPort,
+        PromiseFlatCString(aCertFingerprint).get());
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (mDiscoverable) {
+    RegisterMDNSService();
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::OnServerStopped(nsresult aResult) {
+  LOG_I("OnServerStopped: (0x%08" PRIx32 ")", static_cast<uint32_t>(aResult));
+
+  UnregisterMDNSService(aResult);
+
+  // Try restart server if it is stopped abnormally.
+  if (NS_FAILED(aResult) && mDiscoverable) {
+    mIsServerRetrying = true;
+    mServerRetryTimer->Init(this, mServerRetryMs, nsITimer::TYPE_ONE_SHOT);
+  }
+
+  return NS_OK;
+}
+
+// Create a new device if we were unable to find one with the address.
+already_AddRefed<MulticastDNSDeviceProvider::Device>
+MulticastDNSDeviceProvider::GetOrCreateDevice(nsITCPDeviceInfo* aDeviceInfo) {
+  nsAutoCString address;
+  Unused << aDeviceInfo->GetAddress(address);
+
+  RefPtr<Device> device;
+  uint32_t index;
+  if (FindDeviceByAddress(address, index)) {
+    device = mDevices[index];
+  } else {
+    // Create a one-time device object for non-discoverable controller.
+    // This device will not be in the list of available devices and cannot
+    // be used for requesting session.
+    nsAutoCString id;
+    Unused << aDeviceInfo->GetId(id);
+    uint16_t port;
+    Unused << aDeviceInfo->GetPort(&port);
+
+    device = new Device(id,
+                        /* aName = */ id,
+                        /* aType = */ ""_ns, address, port,
+                        /* aCertFingerprint */ ""_ns, DeviceState::eActive,
+                        /* aProvider = */ nullptr);
+  }
+
+  return device.forget();
+}
+
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::OnSessionRequest(
+    nsITCPDeviceInfo* aDeviceInfo, const nsAString& aUrl,
+    const nsAString& aPresentationId,
+    nsIPresentationControlChannel* aControlChannel) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  nsAutoCString address;
+  Unused << aDeviceInfo->GetAddress(address);
+
+  LOG_I("OnSessionRequest: %s", address.get());
+
+  RefPtr<Device> device = GetOrCreateDevice(aDeviceInfo);
+  nsCOMPtr<nsIPresentationDeviceListener> listener;
+  if (NS_SUCCEEDED(GetListener(getter_AddRefs(listener))) && listener) {
+    Unused << listener->OnSessionRequest(device, aUrl, aPresentationId,
+                                         aControlChannel);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::OnTerminateRequest(
+    nsITCPDeviceInfo* aDeviceInfo, const nsAString& aPresentationId,
+    nsIPresentationControlChannel* aControlChannel, bool aIsFromReceiver) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  nsAutoCString address;
+  Unused << aDeviceInfo->GetAddress(address);
+
+  LOG_I("OnTerminateRequest: %s", address.get());
+
+  RefPtr<Device> device = GetOrCreateDevice(aDeviceInfo);
+  nsCOMPtr<nsIPresentationDeviceListener> listener;
+  if (NS_SUCCEEDED(GetListener(getter_AddRefs(listener))) && listener) {
+    Unused << listener->OnTerminateRequest(device, aPresentationId,
+                                           aControlChannel, aIsFromReceiver);
+  }
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::OnReconnectRequest(
+    nsITCPDeviceInfo* aDeviceInfo, const nsAString& aUrl,
+    const nsAString& aPresentationId,
+    nsIPresentationControlChannel* aControlChannel) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  nsAutoCString address;
+  Unused << aDeviceInfo->GetAddress(address);
+
+  LOG_I("OnReconnectRequest: %s", address.get());
+
+  RefPtr<Device> device = GetOrCreateDevice(aDeviceInfo);
+  nsCOMPtr<nsIPresentationDeviceListener> listener;
+  if (NS_SUCCEEDED(GetListener(getter_AddRefs(listener))) && listener) {
+    Unused << listener->OnReconnectRequest(device, aUrl, aPresentationId,
+                                           aControlChannel);
+  }
+
+  return NS_OK;
+}
+
+// nsIObserver
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::Observe(nsISupports* aSubject, const char* aTopic,
+                                    const char16_t* aData) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  NS_ConvertUTF16toUTF8 data(aData);
+  LOG_I("Observe: topic = %s, data = %s", aTopic, data.get());
+
+  if (!strcmp(aTopic, NS_PREFBRANCH_PREFCHANGE_TOPIC_ID)) {
+    if (data.EqualsLiteral(PREF_PRESENTATION_DISCOVERY)) {
+      OnDiscoveryChanged(Preferences::GetBool(PREF_PRESENTATION_DISCOVERY));
+    } else if (data.EqualsLiteral(PREF_PRESENTATION_DISCOVERY_TIMEOUT_MS)) {
+      OnDiscoveryTimeoutChanged(
+          Preferences::GetUint(PREF_PRESENTATION_DISCOVERY_TIMEOUT_MS));
+    } else if (data.EqualsLiteral(PREF_PRESENTATION_DISCOVERABLE)) {
+      OnDiscoverableChanged(
+          Preferences::GetBool(PREF_PRESENTATION_DISCOVERABLE));
+    } else if (data.EqualsLiteral(PREF_PRESENTATION_DEVICE_NAME)) {
+      nsAutoCString newServiceName;
+      Preferences::GetCString(PREF_PRESENTATION_DEVICE_NAME, newServiceName);
+      if (!mServiceName.Equals(newServiceName)) {
+        OnServiceNameChanged(newServiceName);
+      }
+    }
+  } else if (!strcmp(aTopic, NS_TIMER_CALLBACK_TOPIC)) {
+    nsCOMPtr<nsITimer> timer = do_QueryInterface(aSubject);
+    if (!timer) {
+      return NS_ERROR_UNEXPECTED;
+    }
+
+    if (timer == mDiscoveryTimer) {
+      StopDiscovery(NS_OK);
+    } else if (timer == mServerRetryTimer) {
+      mIsServerRetrying = false;
+      StartServer();
+    }
+  }
+
+  return NS_OK;
+}
+
+nsresult MulticastDNSDeviceProvider::OnDiscoveryChanged(bool aEnabled) {
+  LOG_I("DiscoveryEnabled = %d\n", aEnabled);
+  MOZ_ASSERT(NS_IsMainThread());
+
+  mDiscoveryEnabled = aEnabled;
+
+  if (mDiscoveryEnabled) {
+    return ForceDiscovery();
+  }
+
+  return StopDiscovery(NS_OK);
+}
+
+nsresult MulticastDNSDeviceProvider::OnDiscoveryTimeoutChanged(
+    uint32_t aTimeoutMs) {
+  LOG_I("OnDiscoveryTimeoutChanged = %d\n", aTimeoutMs);
+  MOZ_ASSERT(NS_IsMainThread());
+
+  mDiscoveryTimeoutMs = aTimeoutMs;
+
+  return NS_OK;
+}
+
+nsresult MulticastDNSDeviceProvider::OnDiscoverableChanged(bool aEnabled) {
+  LOG_I("Discoverable = %d\n", aEnabled);
+  MOZ_ASSERT(NS_IsMainThread());
+
+  mDiscoverable = aEnabled;
+
+  if (mDiscoverable) {
+    return StartServer();
+  }
+
+  StopServer();
+  return NS_OK;
+}
+
+nsresult MulticastDNSDeviceProvider::OnServiceNameChanged(
+    const nsACString& aServiceName) {
+  LOG_I("serviceName = %s\n", PromiseFlatCString(aServiceName).get());
+  MOZ_ASSERT(NS_IsMainThread());
+
+  mServiceName = aServiceName;
+
+  UnregisterMDNSService(NS_OK);
+
+  if (mDiscoverable) {
+    return RegisterMDNSService();
+  }
+
+  return NS_OK;
+}
+
+// MulticastDNSDeviceProvider::Device
+NS_IMPL_ISUPPORTS(MulticastDNSDeviceProvider::Device, nsIPresentationDevice)
+
+// nsIPresentationDevice
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::Device::GetId(nsACString& aId) {
+  aId = mId;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::Device::GetName(nsACString& aName) {
+  aName = mName;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::Device::GetType(nsACString& aType) {
+  aType = mType;
+
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::Device::EstablishControlChannel(
+    nsIPresentationControlChannel** aRetVal) {
+  if (!mProvider) {
+    return NS_ERROR_FAILURE;
+  }
+
+  return mProvider->Connect(this, aRetVal);
+}
+
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::Device::Disconnect() {
+  // No need to do anything when disconnect.
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+MulticastDNSDeviceProvider::Device::IsRequestedUrlSupported(
+    const nsAString& aRequestedUrl, bool* aRetVal) {
+  MOZ_ASSERT(NS_IsMainThread());
+
+  if (!aRetVal) {
+    return NS_ERROR_INVALID_POINTER;
+  }
+
+  // TV 2.6 also supports presentation Apps and HTTP/HTTPS hosted receiver page.
+  if (DeviceProviderHelpers::IsFxTVSupportedAppUrl(aRequestedUrl) ||
+      DeviceProviderHelpers::IsCommonlySupportedScheme(aRequestedUrl)) {
+    *aRetVal = true;
+  }
+
+  return NS_OK;
+}
+
+}  // namespace presentation
+}  // namespace dom
+}  // namespace mozilla
diff --git a/dom/presentation/provider/MulticastDNSDeviceProvider.h b/dom/presentation/provider/MulticastDNSDeviceProvider.h
new file mode 100644
index 0000000000..ff2866d799
--- /dev/null
+++ b/dom/presentation/provider/MulticastDNSDeviceProvider.h
@@ -0,0 +1,185 @@
+/* -*- 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_presentation_provider_MulticastDNSDeviceProvider_h
+#define mozilla_dom_presentation_provider_MulticastDNSDeviceProvider_h
+
+#include "mozilla/RefPtr.h"
+#include "nsCOMPtr.h"
+#include "nsICancelable.h"
+#include "nsIDNSServiceDiscovery.h"
+#include "nsIObserver.h"
+#include "nsIPresentationDevice.h"
+#include "nsIPresentationDeviceProvider.h"
+#include "nsIPresentationControlService.h"
+#include "nsITimer.h"
+#include "nsIWeakReferenceUtils.h"
+#include "nsString.h"
+#include "nsTArray.h"
+
+class nsITCPDeviceInfo;
+
+namespace mozilla {
+namespace dom {
+namespace presentation {
+
+class DNSServiceWrappedListener;
+class MulticastDNSService;
+
+class MulticastDNSDeviceProvider final
+    : public nsIPresentationDeviceProvider,
+      public nsIDNSServiceDiscoveryListener,
+      public nsIDNSRegistrationListener,
+      public nsIDNSServiceResolveListener,
+      public nsIPresentationControlServerListener,
+      public nsIObserver {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSIPRESENTATIONDEVICEPROVIDER
+  NS_DECL_NSIDNSSERVICEDISCOVERYLISTENER
+  NS_DECL_NSIDNSREGISTRATIONLISTENER
+  NS_DECL_NSIDNSSERVICERESOLVELISTENER
+  NS_DECL_NSIPRESENTATIONCONTROLSERVERLISTENER
+  NS_DECL_NSIOBSERVER
+
+  explicit MulticastDNSDeviceProvider();
+  nsresult Init();
+  void Uninit();
+
+ private:
+  enum class DeviceState : uint32_t { eUnknown, eActive };
+
+  class Device final : public nsIPresentationDevice {
+   public:
+    NS_DECL_ISUPPORTS
+    NS_DECL_NSIPRESENTATIONDEVICE
+
+    explicit Device(const nsACString& aId, const nsACString& aName,
+                    const nsACString& aType, const nsACString& aAddress,
+                    const uint16_t aPort, const nsACString& aCertFingerprint,
+                    DeviceState aState, MulticastDNSDeviceProvider* aProvider)
+        : mId(aId),
+          mName(aName),
+          mType(aType),
+          mAddress(aAddress),
+          mPort(aPort),
+          mCertFingerprint(aCertFingerprint),
+          mState(aState),
+          mProvider(aProvider) {}
+
+    const nsCString& Id() const { return mId; }
+
+    const nsCString& Address() const { return mAddress; }
+
+    uint16_t Port() const { return mPort; }
+
+    const nsCString& CertFingerprint() const { return mCertFingerprint; }
+
+    DeviceState State() const { return mState; }
+
+    void ChangeState(DeviceState aState) { mState = aState; }
+
+    void Update(const nsACString& aName, const nsACString& aType,
+                const nsACString& aAddress, const uint16_t aPort,
+                const nsACString& aCertFingerprint) {
+      mName = aName;
+      mType = aType;
+      mAddress = aAddress;
+      mPort = aPort;
+      mCertFingerprint = aCertFingerprint;
+    }
+
+   private:
+    virtual ~Device() = default;
+
+    nsCString mId;
+    nsCString mName;
+    nsCString mType;
+    nsCString mAddress;
+    uint16_t mPort;
+    nsCString mCertFingerprint;
+    DeviceState mState;
+    MulticastDNSDeviceProvider* mProvider;
+  };
+
+  struct DeviceIdComparator {
+    bool Equals(const RefPtr<Device>& aA, const RefPtr<Device>& aB) const {
+      return aA->Id() == aB->Id();
+    }
+  };
+
+  struct DeviceAddressComparator {
+    bool Equals(const RefPtr<Device>& aA, const RefPtr<Device>& aB) const {
+      return aA->Address() == aB->Address();
+    }
+  };
+
+  virtual ~MulticastDNSDeviceProvider();
+  nsresult StartServer();
+  void StopServer();
+  void AbortServerRetry();
+  nsresult RegisterMDNSService();
+  void UnregisterMDNSService(nsresult aReason);
+  nsresult StopDiscovery(nsresult aReason);
+  nsresult Connect(Device* aDevice, nsIPresentationControlChannel** aRetVal);
+  bool IsCompatibleServer(nsIDNSServiceInfo* aServiceInfo);
+
+  // device manipulation
+  nsresult AddDevice(const nsACString& aId, const nsACString& aServiceName,
+                     const nsACString& aServiceType, const nsACString& aAddress,
+                     const uint16_t aPort, const nsACString& aCertFingerprint);
+  nsresult UpdateDevice(const uint32_t aIndex, const nsACString& aServiceName,
+                        const nsACString& aServiceType,
+                        const nsACString& aAddress, const uint16_t aPort,
+                        const nsACString& aCertFingerprint);
+  nsresult RemoveDevice(const uint32_t aIndex);
+  bool FindDeviceById(const nsACString& aId, uint32_t& aIndex);
+
+  bool FindDeviceByAddress(const nsACString& aAddress, uint32_t& aIndex);
+
+  already_AddRefed<Device> GetOrCreateDevice(nsITCPDeviceInfo* aDeviceInfo);
+
+  void MarkAllDevicesUnknown();
+  void ClearUnknownDevices();
+  void ClearDevices();
+
+  // preferences
+  nsresult OnDiscoveryChanged(bool aEnabled);
+  nsresult OnDiscoveryTimeoutChanged(uint32_t aTimeoutMs);
+  nsresult OnDiscoverableChanged(bool aEnabled);
+  nsresult OnServiceNameChanged(const nsACString& aServiceName);
+
+  bool mInitialized = false;
+  nsWeakPtr mDeviceListener;
+  nsCOMPtr<nsIPresentationControlService> mPresentationService;
+  nsCOMPtr<nsIDNSServiceDiscovery> mMulticastDNS;
+  RefPtr<DNSServiceWrappedListener> mWrappedListener;
+
+  nsCOMPtr<nsICancelable> mDiscoveryRequest;
+  nsCOMPtr<nsICancelable> mRegisterRequest;
+
+  nsTArray<RefPtr<Device>> mDevices;
+
+  bool mDiscoveryEnabled = false;
+  bool mIsDiscovering = false;
+  uint32_t mDiscoveryTimeoutMs;
+  nsCOMPtr<nsITimer> mDiscoveryTimer;
+
+  bool mDiscoverable = false;
+  bool mDiscoverableEncrypted = false;
+  bool mIsServerRetrying = false;
+  uint32_t mServerRetryMs;
+  nsCOMPtr<nsITimer> mServerRetryTimer;
+
+  nsCString mServiceName;
+  nsCString mRegisteredName;
+};
+
+}  // namespace presentation
+}  // namespace dom
+}  // namespace mozilla
+
+#endif  // mozilla_dom_presentation_provider_MulticastDNSDeviceProvider_h
diff --git a/dom/presentation/provider/PresentationControlService.jsm b/dom/presentation/provider/PresentationControlService.jsm
new file mode 100644
index 0000000000..07e46d1f1c
--- /dev/null
+++ b/dom/presentation/provider/PresentationControlService.jsm
@@ -0,0 +1,1054 @@
+/* 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/. */
+"use strict";
+
+const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+const { NetUtil } = ChromeUtils.import("resource://gre/modules/NetUtil.jsm");
+const { clearTimeout, setTimeout } = ChromeUtils.import(
+  "resource://gre/modules/Timer.jsm"
+);
+
+ChromeUtils.defineModuleGetter(
+  this,
+  "ControllerStateMachine",
+  "resource://gre/modules/presentation/ControllerStateMachine.jsm"
+);
+ChromeUtils.defineModuleGetter(
+  this,
+  "ReceiverStateMachine",
+  "resource://gre/modules/presentation/ReceiverStateMachine.jsm"
+);
+
+const kProtocolVersion = 1; // need to review isCompatibleServer while fiddling the version number.
+const kLocalCertName = "presentation";
+
+const DEBUG = Services.prefs.getBoolPref("dom.presentation.tcp_server.debug");
+function log(aMsg) {
+  dump("-*- PresentationControlService.js: " + aMsg + "\n");
+}
+
+function TCPDeviceInfo(aAddress, aPort, aId, aCertFingerprint) {
+  this.address = aAddress;
+  this.port = aPort;
+  this.id = aId;
+  this.certFingerprint = aCertFingerprint || "";
+}
+
+function PresentationControlService() {
+  this._id = null;
+  this._port = 0;
+  this._serverSocket = null;
+}
+
+PresentationControlService.prototype = {
+  /**
+   * If a user agent connects to this server, we create a control channel but
+   * hand it to |TCPDevice.listener| when the initial information exchange
+   * finishes. Therefore, we hold the control channels in this period.
+   */
+  _controlChannels: [],
+
+  startServer(aEncrypted, aPort) {
+    if (this._isServiceInit()) {
+      DEBUG &&
+        log("PresentationControlService - server socket has been initialized");
+      throw Components.Exception("", Cr.NS_ERROR_FAILURE);
+    }
+
+    /**
+     * 0 or undefined indicates opt-out parameter, and a port will be selected
+     * automatically.
+     */
+    let serverSocketPort =
+      typeof aPort !== "undefined" && aPort !== 0 ? aPort : -1;
+
+    if (aEncrypted) {
+      let self = this;
+      let localCertService = Cc[
+        "@mozilla.org/security/local-cert-service;1"
+      ].getService(Ci.nsILocalCertService);
+      localCertService.getOrCreateCert(kLocalCertName, {
+        handleCert(aCert, aRv) {
+          DEBUG && log("PresentationControlService - handleCert");
+          if (aRv) {
+            self._notifyServerStopped(aRv);
+          } else {
+            self._serverSocket = Cc[
+              "@mozilla.org/network/tls-server-socket;1"
+            ].createInstance(Ci.nsITLSServerSocket);
+
+            self._serverSocketInit(serverSocketPort, aCert);
+          }
+        },
+      });
+    } else {
+      this._serverSocket = Cc[
+        "@mozilla.org/network/server-socket;1"
+      ].createInstance(Ci.nsIServerSocket);
+
+      this._serverSocketInit(serverSocketPort, null);
+    }
+  },
+
+  _serverSocketInit(aPort, aCert) {
+    if (!this._serverSocket) {
+      DEBUG && log("PresentationControlService - create server socket fail.");
+      throw Components.Exception("", Cr.NS_ERROR_FAILURE);
+    }
+
+    try {
+      this._serverSocket.init(aPort, false, -1);
+
+      if (aCert) {
+        this._serverSocket.serverCert = aCert;
+        this._serverSocket.setSessionTickets(false);
+        let requestCert = Ci.nsITLSServerSocket.REQUEST_NEVER;
+        this._serverSocket.setRequestClientCertificate(requestCert);
+      }
+
+      this._serverSocket.asyncListen(this);
+    } catch (e) {
+      // NS_ERROR_SOCKET_ADDRESS_IN_USE
+      DEBUG &&
+        log("PresentationControlService - init server socket fail: " + e);
+      throw Components.Exception("", Cr.NS_ERROR_FAILURE);
+    }
+
+    this._port = this._serverSocket.port;
+
+    DEBUG &&
+      log("PresentationControlService - service start on port: " + this._port);
+
+    // Monitor network interface change to restart server socket.
+    Services.obs.addObserver(this, "network:offline-status-changed");
+
+    this._notifyServerReady();
+  },
+
+  _notifyServerReady() {
+    Services.tm.dispatchToMainThread(() => {
+      if (this._listener) {
+        this._listener.onServerReady(this._port, this.certFingerprint);
+      }
+    });
+  },
+
+  _notifyServerStopped(aRv) {
+    Services.tm.dispatchToMainThread(() => {
+      if (this._listener) {
+        this._listener.onServerStopped(aRv);
+      }
+    });
+  },
+
+  isCompatibleServer(aVersion) {
+    // No compatibility issue for the first version of control protocol
+    return this.version === aVersion;
+  },
+
+  get id() {
+    return this._id;
+  },
+
+  set id(aId) {
+    this._id = aId;
+  },
+
+  get port() {
+    return this._port;
+  },
+
+  get version() {
+    return kProtocolVersion;
+  },
+
+  get certFingerprint() {
+    if (!this._serverSocket.serverCert) {
+      return null;
+    }
+
+    return this._serverSocket.serverCert.sha256Fingerprint;
+  },
+
+  set listener(aListener) {
+    this._listener = aListener;
+  },
+
+  get listener() {
+    return this._listener;
+  },
+
+  _isServiceInit() {
+    return this._serverSocket !== null;
+  },
+
+  connect(aDeviceInfo) {
+    if (!this.id) {
+      DEBUG &&
+        log(
+          "PresentationControlService - Id has not initialized; connect fails"
+        );
+      return null;
+    }
+    DEBUG && log("PresentationControlService - connect to " + aDeviceInfo.id);
+
+    let socketTransport = this._attemptConnect(aDeviceInfo);
+    return new TCPControlChannel(this, socketTransport, aDeviceInfo, "sender");
+  },
+
+  _attemptConnect(aDeviceInfo) {
+    let sts = Cc["@mozilla.org/network/socket-transport-service;1"].getService(
+      Ci.nsISocketTransportService
+    );
+
+    let socketTransport;
+    try {
+      if (aDeviceInfo.certFingerprint) {
+        let overrideService = Cc[
+          "@mozilla.org/security/certoverride;1"
+        ].getService(Ci.nsICertOverrideService);
+        overrideService.rememberTemporaryValidityOverrideUsingFingerprint(
+          aDeviceInfo.address,
+          aDeviceInfo.port,
+          aDeviceInfo.certFingerprint,
+          Ci.nsICertOverrideService.ERROR_UNTRUSTED |
+            Ci.nsICertOverrideService.ERROR_MISMATCH
+        );
+
+        socketTransport = sts.createTransport(
+          ["ssl"],
+          aDeviceInfo.address,
+          aDeviceInfo.port,
+          null
+        );
+      } else {
+        socketTransport = sts.createTransport(
+          [],
+          aDeviceInfo.address,
+          aDeviceInfo.port,
+          null
+        );
+      }
+      // Shorten the connection failure procedure.
+      socketTransport.setTimeout(Ci.nsISocketTransport.TIMEOUT_CONNECT, 2);
+    } catch (e) {
+      DEBUG && log("PresentationControlService - createTransport throws: " + e);
+      // Pop the exception to |TCPDevice.establishControlChannel|
+      throw Components.Exception("", Cr.NS_ERROR_FAILURE);
+    }
+    return socketTransport;
+  },
+
+  responseSession(aDeviceInfo, aSocketTransport) {
+    if (!this._isServiceInit()) {
+      DEBUG &&
+        log(
+          "PresentationControlService - should never receive remote " +
+            "session request before server socket initialization"
+        );
+      return null;
+    }
+    DEBUG &&
+      log(
+        "PresentationControlService - responseSession to " +
+          JSON.stringify(aDeviceInfo)
+      );
+    return new TCPControlChannel(
+      this,
+      aSocketTransport,
+      aDeviceInfo,
+      "receiver"
+    );
+  },
+
+  // Triggered by TCPControlChannel
+  onSessionRequest(aDeviceInfo, aUrl, aPresentationId, aControlChannel) {
+    DEBUG &&
+      log(
+        "PresentationControlService - onSessionRequest: " +
+          aDeviceInfo.address +
+          ":" +
+          aDeviceInfo.port
+      );
+    if (!this.listener) {
+      this.releaseControlChannel(aControlChannel);
+      return;
+    }
+
+    this.listener.onSessionRequest(
+      aDeviceInfo,
+      aUrl,
+      aPresentationId,
+      aControlChannel
+    );
+    this.releaseControlChannel(aControlChannel);
+  },
+
+  onSessionTerminate(
+    aDeviceInfo,
+    aPresentationId,
+    aControlChannel,
+    aIsFromReceiver
+  ) {
+    DEBUG &&
+      log(
+        "TCPPresentationServer - onSessionTerminate: " +
+          aDeviceInfo.address +
+          ":" +
+          aDeviceInfo.port
+      );
+    if (!this.listener) {
+      this.releaseControlChannel(aControlChannel);
+      return;
+    }
+
+    this.listener.onTerminateRequest(
+      aDeviceInfo,
+      aPresentationId,
+      aControlChannel,
+      aIsFromReceiver
+    );
+    this.releaseControlChannel(aControlChannel);
+  },
+
+  onSessionReconnect(aDeviceInfo, aUrl, aPresentationId, aControlChannel) {
+    DEBUG &&
+      log(
+        "TCPPresentationServer - onSessionReconnect: " +
+          aDeviceInfo.address +
+          ":" +
+          aDeviceInfo.port
+      );
+    if (!this.listener) {
+      this.releaseControlChannel(aControlChannel);
+      return;
+    }
+
+    this.listener.onReconnectRequest(
+      aDeviceInfo,
+      aUrl,
+      aPresentationId,
+      aControlChannel
+    );
+    this.releaseControlChannel(aControlChannel);
+  },
+
+  // nsIServerSocketListener (Triggered by nsIServerSocket.init)
+  onSocketAccepted(aServerSocket, aClientSocket) {
+    DEBUG &&
+      log(
+        "PresentationControlService - onSocketAccepted: " +
+          aClientSocket.host +
+          ":" +
+          aClientSocket.port
+      );
+    let deviceInfo = new TCPDeviceInfo(aClientSocket.host, aClientSocket.port);
+    this.holdControlChannel(this.responseSession(deviceInfo, aClientSocket));
+  },
+
+  holdControlChannel(aControlChannel) {
+    this._controlChannels.push(aControlChannel);
+  },
+
+  releaseControlChannel(aControlChannel) {
+    let index = this._controlChannels.indexOf(aControlChannel);
+    if (index !== -1) {
+      delete this._controlChannels[index];
+    }
+  },
+
+  // nsIServerSocketListener (Triggered by nsIServerSocket.init)
+  onStopListening(aServerSocket, aStatus) {
+    DEBUG && log("PresentationControlService - onStopListening: " + aStatus);
+  },
+
+  close() {
+    DEBUG && log("PresentationControlService - close");
+    if (this._isServiceInit()) {
+      DEBUG && log("PresentationControlService - close server socket");
+      this._serverSocket.close();
+      this._serverSocket = null;
+
+      Services.obs.removeObserver(this, "network:offline-status-changed");
+
+      this._notifyServerStopped(Cr.NS_OK);
+    }
+    this._port = 0;
+  },
+
+  // nsIObserver
+  observe(aSubject, aTopic, aData) {
+    DEBUG && log("PresentationControlService - observe: " + aTopic);
+    switch (aTopic) {
+      case "network:offline-status-changed": {
+        if (aData == "offline") {
+          DEBUG && log("network offline");
+          return;
+        }
+        this._restartServer();
+        break;
+      }
+    }
+  },
+
+  _restartServer() {
+    DEBUG && log("PresentationControlService - restart service");
+
+    // restart server socket
+    if (this._isServiceInit()) {
+      this.close();
+
+      try {
+        this.startServer();
+      } catch (e) {
+        DEBUG && log("PresentationControlService - restart service fail: " + e);
+      }
+    }
+  },
+
+  classID: Components.ID("{f4079b8b-ede5-4b90-a112-5b415a931deb}"),
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIServerSocketListener",
+    "nsIPresentationControlService",
+    "nsIObserver",
+  ]),
+};
+
+function ChannelDescription(aInit) {
+  this._type = aInit.type;
+  switch (this._type) {
+    case Ci.nsIPresentationChannelDescription.TYPE_TCP:
+      this._tcpAddresses = Cc["@mozilla.org/array;1"].createInstance(
+        Ci.nsIMutableArray
+      );
+      for (let address of aInit.tcpAddress) {
+        let wrapper = Cc["@mozilla.org/supports-cstring;1"].createInstance(
+          Ci.nsISupportsCString
+        );
+        wrapper.data = address;
+        this._tcpAddresses.appendElement(wrapper);
+      }
+
+      this._tcpPort = aInit.tcpPort;
+      break;
+    case Ci.nsIPresentationChannelDescription.TYPE_DATACHANNEL:
+      this._dataChannelSDP = aInit.dataChannelSDP;
+      break;
+  }
+}
+
+ChannelDescription.prototype = {
+  _type: 0,
+  _tcpAddresses: null,
+  _tcpPort: 0,
+  _dataChannelSDP: "",
+
+  get type() {
+    return this._type;
+  },
+
+  get tcpAddress() {
+    return this._tcpAddresses;
+  },
+
+  get tcpPort() {
+    return this._tcpPort;
+  },
+
+  get dataChannelSDP() {
+    return this._dataChannelSDP;
+  },
+
+  classID: Components.ID("{82507aea-78a2-487e-904a-858a6c5bf4e1}"),
+  QueryInterface: ChromeUtils.generateQI(["nsIPresentationChannelDescription"]),
+};
+
+// Helper function: transfer nsIPresentationChannelDescription to json
+function discriptionAsJson(aDescription) {
+  let json = {};
+  json.type = aDescription.type;
+  switch (aDescription.type) {
+    case Ci.nsIPresentationChannelDescription.TYPE_TCP:
+      let addresses = aDescription.tcpAddress.QueryInterface(Ci.nsIArray);
+      json.tcpAddress = [];
+      for (let idx = 0; idx < addresses.length; idx++) {
+        let address = addresses.queryElementAt(idx, Ci.nsISupportsCString);
+        json.tcpAddress.push(address.data);
+      }
+      json.tcpPort = aDescription.tcpPort;
+      break;
+    case Ci.nsIPresentationChannelDescription.TYPE_DATACHANNEL:
+      json.dataChannelSDP = aDescription.dataChannelSDP;
+      break;
+  }
+  return json;
+}
+
+const kDisconnectTimeout = 5000;
+const kTerminateTimeout = 5000;
+
+function TCPControlChannel(
+  presentationService,
+  transport,
+  deviceInfo,
+  direction
+) {
+  DEBUG && log("create TCPControlChannel for : " + direction);
+  this._deviceInfo = deviceInfo;
+  this._direction = direction;
+  this._transport = transport;
+
+  this._presentationService = presentationService;
+
+  if (direction === "receiver") {
+    // Need to set security observer before I/O stream operation.
+    this._setSecurityObserver(this);
+  }
+
+  let currentThread = Services.tm.currentThread;
+  transport.setEventSink(this, currentThread);
+
+  this._input = this._transport
+    .openInputStream(0, 0, 0)
+    .QueryInterface(Ci.nsIAsyncInputStream);
+  this._input.asyncWait(
+    this.QueryInterface(Ci.nsIStreamListener),
+    Ci.nsIAsyncInputStream.WAIT_CLOSURE_ONLY,
+    0,
+    currentThread
+  );
+
+  this._output = this._transport
+    .openOutputStream(Ci.nsITransport.OPEN_UNBUFFERED, 0, 0)
+    .QueryInterface(Ci.nsIAsyncOutputStream);
+
+  this._outgoingMsgs = [];
+
+  this._stateMachine =
+    direction === "sender"
+      ? new ControllerStateMachine(this, presentationService.id)
+      : new ReceiverStateMachine(this);
+
+  if (direction === "receiver" && !transport.securityInfo) {
+    // Since the transport created by server socket is already CONNECTED_TO.
+    this._outgoingEnabled = true;
+    this._createInputStreamPump();
+  }
+}
+
+TCPControlChannel.prototype = {
+  _outgoingEnabled: false,
+  _incomingEnabled: false,
+  _pendingOpen: false,
+  _pendingOffer: null,
+  _pendingAnswer: null,
+  _pendingClose: null,
+  _pendingCloseReason: null,
+  _pendingReconnect: false,
+
+  sendOffer(aOffer) {
+    this._stateMachine.sendOffer(discriptionAsJson(aOffer));
+  },
+
+  sendAnswer(aAnswer) {
+    this._stateMachine.sendAnswer(discriptionAsJson(aAnswer));
+  },
+
+  sendIceCandidate(aCandidate) {
+    this._stateMachine.updateIceCandidate(aCandidate);
+  },
+
+  launch(aPresentationId, aUrl) {
+    this._stateMachine.launch(aPresentationId, aUrl);
+  },
+
+  terminate(aPresentationId) {
+    if (!this._terminatingId) {
+      this._terminatingId = aPresentationId;
+      this._stateMachine.terminate(aPresentationId);
+
+      // Start a guard timer to ensure terminateAck is processed.
+      this._terminateTimer = setTimeout(() => {
+        DEBUG &&
+          log("TCPControlChannel - terminate timeout: " + aPresentationId);
+        delete this._terminateTimer;
+        if (this._pendingDisconnect) {
+          this._pendingDisconnect();
+        } else {
+          this.disconnect(Cr.NS_OK);
+        }
+      }, kTerminateTimeout);
+    } else {
+      this._stateMachine.terminateAck(aPresentationId);
+      delete this._terminatingId;
+    }
+  },
+
+  _flushOutgoing() {
+    if (!this._outgoingEnabled || this._outgoingMsgs.length === 0) {
+      return;
+    }
+
+    this._output.asyncWait(this, 0, 0, Services.tm.currentThread);
+  },
+
+  // may throw an exception
+  _send(aMsg) {
+    DEBUG && log("TCPControlChannel - Send: " + JSON.stringify(aMsg, null, 2));
+
+    /**
+     * XXX In TCP streaming, it is possible that more than one message in one
+     * TCP packet. We use line delimited JSON to identify where one JSON encoded
+     * object ends and the next begins. Therefore, we do not allow newline
+     * characters whithin the whole message, and add a newline at the end.
+     * Please see the parser code in |onDataAvailable|.
+     */
+    let message = JSON.stringify(aMsg).replace(["\n"], "") + "\n";
+    try {
+      this._output.write(message, message.length);
+    } catch (e) {
+      DEBUG && log("TCPControlChannel - Failed to send message: " + e.name);
+      throw e;
+    }
+  },
+
+  _setSecurityObserver(observer) {
+    if (this._transport && this._transport.securityInfo) {
+      DEBUG && log("TCPControlChannel - setSecurityObserver: " + observer);
+      let connectionInfo = this._transport.securityInfo.QueryInterface(
+        Ci.nsITLSServerConnectionInfo
+      );
+      connectionInfo.setSecurityObserver(observer);
+    }
+  },
+
+  // nsITLSServerSecurityObserver
+  onHandshakeDone(socket, clientStatus) {
+    log(
+      "TCPControlChannel - onHandshakeDone: TLS version: " +
+        clientStatus.tlsVersionUsed.toString(16)
+    );
+    this._setSecurityObserver(null);
+
+    // Process input/output after TLS handshake is complete.
+    this._outgoingEnabled = true;
+    this._createInputStreamPump();
+  },
+
+  // nsIAsyncOutputStream
+  onOutputStreamReady() {
+    DEBUG && log("TCPControlChannel - onOutputStreamReady");
+    if (this._outgoingMsgs.length === 0) {
+      return;
+    }
+
+    try {
+      this._send(this._outgoingMsgs[0]);
+    } catch (e) {
+      if (e.result === Cr.NS_BASE_STREAM_WOULD_BLOCK) {
+        this._output.asyncWait(this, 0, 0, Services.tm.currentThread);
+        return;
+      }
+
+      this._closeTransport();
+      return;
+    }
+    this._outgoingMsgs.shift();
+    this._flushOutgoing();
+  },
+
+  // nsIAsyncInputStream (Triggered by nsIInputStream.asyncWait)
+  // Only used for detecting connection refused
+  onInputStreamReady(aStream) {
+    DEBUG && log("TCPControlChannel - onInputStreamReady");
+    try {
+      aStream.available();
+    } catch (e) {
+      DEBUG && log("TCPControlChannel - onInputStreamReady error: " + e.name);
+      // NS_ERROR_CONNECTION_REFUSED
+      this._notifyDisconnected(e.result);
+    }
+  },
+
+  // nsITransportEventSink (Triggered by nsISocketTransport.setEventSink)
+  onTransportStatus(aTransport, aStatus) {
+    DEBUG &&
+      log(
+        "TCPControlChannel - onTransportStatus: " +
+          aStatus.toString(16) +
+          " with role: " +
+          this._direction
+      );
+    if (aStatus === Ci.nsISocketTransport.STATUS_CONNECTED_TO) {
+      this._outgoingEnabled = true;
+      this._createInputStreamPump();
+    }
+  },
+
+  // nsIRequestObserver (Triggered by nsIInputStreamPump.asyncRead)
+  onStartRequest() {
+    DEBUG &&
+      log("TCPControlChannel - onStartRequest with role: " + this._direction);
+    this._incomingEnabled = true;
+  },
+
+  // nsIRequestObserver (Triggered by nsIInputStreamPump.asyncRead)
+  onStopRequest(aRequest, aContext, aStatus) {
+    DEBUG &&
+      log(
+        "TCPControlChannel - onStopRequest: " +
+          aStatus +
+          " with role: " +
+          this._direction
+      );
+    this._stateMachine.onChannelClosed(aStatus, true);
+  },
+
+  // nsIStreamListener (Triggered by nsIInputStreamPump.asyncRead)
+  onDataAvailable(aRequest, aInputStream) {
+    let data = NetUtil.readInputStreamToString(
+      aInputStream,
+      aInputStream.available()
+    );
+    DEBUG && log("TCPControlChannel - onDataAvailable: " + data);
+
+    // Parser of line delimited JSON. Please see |_send| for more informaiton.
+    let jsonArray = data.split("\n");
+    jsonArray.pop();
+    for (let json of jsonArray) {
+      let msg;
+      try {
+        msg = JSON.parse(json);
+      } catch (e) {
+        DEBUG && log("TCPSignalingChannel - error in parsing json: " + e);
+      }
+
+      this._handleMessage(msg);
+    }
+  },
+
+  _createInputStreamPump() {
+    if (this._pump) {
+      return;
+    }
+
+    DEBUG &&
+      log("TCPControlChannel - create pump with role: " + this._direction);
+    this._pump = Cc["@mozilla.org/network/input-stream-pump;1"].createInstance(
+      Ci.nsIInputStreamPump
+    );
+    this._pump.init(this._input, 0, 0, false);
+    this._pump.asyncRead(this, null);
+    this._stateMachine.onChannelReady();
+  },
+
+  // Handle command from remote side
+  _handleMessage(aMsg) {
+    DEBUG &&
+      log(
+        "TCPControlChannel - handleMessage from " +
+          JSON.stringify(this._deviceInfo) +
+          ": " +
+          JSON.stringify(aMsg)
+      );
+    this._stateMachine.onCommand(aMsg);
+  },
+
+  get listener() {
+    return this._listener;
+  },
+
+  set listener(aListener) {
+    DEBUG && log("TCPControlChannel - set listener: " + aListener);
+    if (!aListener) {
+      this._listener = null;
+      return;
+    }
+
+    this._listener = aListener;
+    if (this._pendingOpen) {
+      this._pendingOpen = false;
+      DEBUG && log("TCPControlChannel - notify pending opened");
+      this._listener.notifyConnected();
+    }
+
+    if (this._pendingOffer) {
+      let offer = this._pendingOffer;
+      DEBUG &&
+        log(
+          "TCPControlChannel - notify pending offer: " + JSON.stringify(offer)
+        );
+      this._listener.onOffer(new ChannelDescription(offer));
+      this._pendingOffer = null;
+    }
+
+    if (this._pendingAnswer) {
+      let answer = this._pendingAnswer;
+      DEBUG &&
+        log(
+          "TCPControlChannel - notify pending answer: " + JSON.stringify(answer)
+        );
+      this._listener.onAnswer(new ChannelDescription(answer));
+      this._pendingAnswer = null;
+    }
+
+    if (this._pendingClose) {
+      DEBUG && log("TCPControlChannel - notify pending closed");
+      this._notifyDisconnected(this._pendingCloseReason);
+      this._pendingClose = null;
+    }
+
+    if (this._pendingReconnect) {
+      DEBUG && log("TCPControlChannel - notify pending reconnected");
+      this._notifyReconnected();
+      this._pendingReconnect = false;
+    }
+  },
+
+  /**
+   * These functions are designed to handle the interaction with listener
+   * appropriately. |_FUNC| is to handle |this._listener.FUNC|.
+   */
+  _onOffer(aOffer) {
+    if (!this._incomingEnabled) {
+      return;
+    }
+    if (!this._listener) {
+      this._pendingOffer = aOffer;
+      return;
+    }
+    DEBUG && log("TCPControlChannel - notify offer: " + JSON.stringify(aOffer));
+    this._listener.onOffer(new ChannelDescription(aOffer));
+  },
+
+  _onAnswer(aAnswer) {
+    if (!this._incomingEnabled) {
+      return;
+    }
+    if (!this._listener) {
+      this._pendingAnswer = aAnswer;
+      return;
+    }
+    DEBUG &&
+      log("TCPControlChannel - notify answer: " + JSON.stringify(aAnswer));
+    this._listener.onAnswer(new ChannelDescription(aAnswer));
+  },
+
+  _notifyConnected() {
+    this._pendingClose = false;
+    this._pendingCloseReason = Cr.NS_OK;
+
+    if (!this._listener) {
+      this._pendingOpen = true;
+      return;
+    }
+
+    DEBUG &&
+      log("TCPControlChannel - notify opened with role: " + this._direction);
+    this._listener.notifyConnected();
+  },
+
+  _notifyDisconnected(aReason) {
+    this._pendingOpen = false;
+    this._pendingOffer = null;
+    this._pendingAnswer = null;
+
+    // Remote endpoint closes the control channel with abnormal reason.
+    if (aReason == Cr.NS_OK && this._pendingCloseReason != Cr.NS_OK) {
+      aReason = this._pendingCloseReason;
+    }
+
+    if (!this._listener) {
+      this._pendingClose = true;
+      this._pendingCloseReason = aReason;
+      return;
+    }
+
+    DEBUG &&
+      log("TCPControlChannel - notify closed with role: " + this._direction);
+    this._listener.notifyDisconnected(aReason);
+  },
+
+  _notifyReconnected() {
+    if (!this._listener) {
+      this._pendingReconnect = true;
+      return;
+    }
+
+    DEBUG &&
+      log(
+        "TCPControlChannel - notify reconnected with role: " + this._direction
+      );
+    this._listener.notifyReconnected();
+  },
+
+  _closeOutgoing() {
+    if (this._outgoingEnabled) {
+      this._output.close();
+      this._outgoingEnabled = false;
+    }
+  },
+  _closeIncoming() {
+    if (this._incomingEnabled) {
+      this._pump = null;
+      this._input.close();
+      this._incomingEnabled = false;
+    }
+  },
+  _closeTransport() {
+    if (this._disconnectTimer) {
+      clearTimeout(this._disconnectTimer);
+      delete this._disconnectTimer;
+    }
+
+    if (this._terminateTimer) {
+      clearTimeout(this._terminateTimer);
+      delete this._terminateTimer;
+    }
+
+    delete this._pendingDisconnect;
+
+    this._transport.setEventSink(null, null);
+
+    this._closeIncoming();
+    this._closeOutgoing();
+    this._presentationService.releaseControlChannel(this);
+  },
+
+  disconnect(aReason) {
+    DEBUG && log("TCPControlChannel - disconnect with reason: " + aReason);
+
+    // Pending disconnect during termination procedure.
+    if (this._terminateTimer) {
+      // Store only the first disconnect action.
+      if (!this._pendingDisconnect) {
+        this._pendingDisconnect = this.disconnect.bind(this, aReason);
+      }
+      return;
+    }
+
+    if (this._outgoingEnabled && !this._disconnectTimer) {
+      // default reason is NS_OK
+      aReason = !aReason ? Cr.NS_OK : aReason;
+
+      this._stateMachine.onChannelClosed(aReason, false);
+
+      // Start a guard timer to ensure the transport will be closed.
+      this._disconnectTimer = setTimeout(() => {
+        DEBUG && log("TCPControlChannel - disconnect timeout");
+        this._closeTransport();
+      }, kDisconnectTimeout);
+    }
+  },
+
+  reconnect(aPresentationId, aUrl) {
+    DEBUG && log("TCPControlChannel - reconnect with role: " + this._direction);
+    if (this._direction != "sender") {
+      throw Components.Exception("", Cr.NS_ERROR_FAILURE);
+    }
+
+    this._stateMachine.reconnect(aPresentationId, aUrl);
+  },
+
+  // callback from state machine
+  sendCommand(command) {
+    this._outgoingMsgs.push(command);
+    this._flushOutgoing();
+  },
+
+  notifyDeviceConnected(deviceId) {
+    switch (this._direction) {
+      case "receiver":
+        this._deviceInfo.id = deviceId;
+        break;
+    }
+    this._notifyConnected();
+  },
+
+  notifyDisconnected(reason) {
+    this._closeTransport();
+    this._notifyDisconnected(reason);
+  },
+
+  notifyLaunch(presentationId, url) {
+    switch (this._direction) {
+      case "receiver":
+        this._presentationService.onSessionRequest(
+          this._deviceInfo,
+          url,
+          presentationId,
+          this
+        );
+        break;
+    }
+  },
+
+  notifyTerminate(presentationId) {
+    if (!this._terminatingId) {
+      this._terminatingId = presentationId;
+      this._presentationService.onSessionTerminate(
+        this._deviceInfo,
+        presentationId,
+        this,
+        this._direction === "sender"
+      );
+      return;
+    }
+
+    // Cancel terminate guard timer after receiving terminate-ack.
+    if (this._terminateTimer) {
+      clearTimeout(this._terminateTimer);
+      delete this._terminateTimer;
+    }
+
+    if (this._terminatingId !== presentationId) {
+      // Requested presentation Id doesn't matched with the one in ACK.
+      // Disconnect the control channel with error.
+      DEBUG &&
+        log("TCPControlChannel - unmatched terminatingId: " + presentationId);
+      this.disconnect(Cr.NS_ERROR_FAILURE);
+    }
+
+    delete this._terminatingId;
+    if (this._pendingDisconnect) {
+      this._pendingDisconnect();
+    }
+  },
+
+  notifyReconnect(presentationId, url) {
+    switch (this._direction) {
+      case "receiver":
+        this._presentationService.onSessionReconnect(
+          this._deviceInfo,
+          url,
+          presentationId,
+          this
+        );
+        break;
+      case "sender":
+        this._notifyReconnected();
+        break;
+    }
+  },
+
+  notifyOffer(offer) {
+    this._onOffer(offer);
+  },
+
+  notifyAnswer(answer) {
+    this._onAnswer(answer);
+  },
+
+  notifyIceCandidate(candidate) {
+    this._listener.onIceCandidate(candidate);
+  },
+
+  classID: Components.ID("{fefb8286-0bdc-488b-98bf-0c11b485c955}"),
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIPresentationControlChannel",
+    "nsIStreamListener",
+  ]),
+};
+
+var EXPORTED_SYMBOLS = ["PresentationControlService"];
diff --git a/dom/presentation/provider/ReceiverStateMachine.jsm b/dom/presentation/provider/ReceiverStateMachine.jsm
new file mode 100644
index 0000000000..aaad83a20e
--- /dev/null
+++ b/dom/presentation/provider/ReceiverStateMachine.jsm
@@ -0,0 +1,232 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 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/. */
+
+"use strict";
+
+var EXPORTED_SYMBOLS = ["ReceiverStateMachine"];
+
+const { CommandType, State } = ChromeUtils.import(
+  "resource://gre/modules/presentation/StateMachineHelper.jsm"
+);
+
+const DEBUG = false;
+function debug(str) {
+  dump("-*- ReceiverStateMachine: " + str + "\n");
+}
+
+var handlers = [
+  function _initHandler(stateMachine, command) {
+    // shouldn't receive any command at init state
+    DEBUG && debug("unexpected command: " + JSON.stringify(command));
+  },
+  function _connectingHandler(stateMachine, command) {
+    switch (command.type) {
+      case CommandType.CONNECT:
+        stateMachine._sendCommand({
+          type: CommandType.CONNECT_ACK,
+        });
+        stateMachine.state = State.CONNECTED;
+        stateMachine._notifyDeviceConnected(command.deviceId);
+        break;
+      case CommandType.DISCONNECT:
+        stateMachine.state = State.CLOSED;
+        stateMachine._notifyDisconnected(command.reason);
+        break;
+      default:
+        debug("unexpected command: " + JSON.stringify(command));
+        // ignore unexpected command
+        break;
+    }
+  },
+  function _connectedHandler(stateMachine, command) {
+    switch (command.type) {
+      case CommandType.DISCONNECT:
+        stateMachine.state = State.CLOSED;
+        stateMachine._notifyDisconnected(command.reason);
+        break;
+      case CommandType.LAUNCH:
+        stateMachine._notifyLaunch(command.presentationId, command.url);
+        stateMachine._sendCommand({
+          type: CommandType.LAUNCH_ACK,
+          presentationId: command.presentationId,
+        });
+        break;
+      case CommandType.TERMINATE:
+        stateMachine._notifyTerminate(command.presentationId);
+        break;
+      case CommandType.TERMINATE_ACK:
+        stateMachine._notifyTerminate(command.presentationId);
+        break;
+      case CommandType.OFFER:
+      case CommandType.ICE_CANDIDATE:
+        stateMachine._notifyChannelDescriptor(command);
+        break;
+      case CommandType.RECONNECT:
+        stateMachine._notifyReconnect(command.presentationId, command.url);
+        stateMachine._sendCommand({
+          type: CommandType.RECONNECT_ACK,
+          presentationId: command.presentationId,
+        });
+        break;
+      default:
+        debug("unexpected command: " + JSON.stringify(command));
+        // ignore unexpected command
+        break;
+    }
+  },
+  function _closingHandler(stateMachine, command) {
+    switch (command.type) {
+      case CommandType.DISCONNECT:
+        stateMachine.state = State.CLOSED;
+        stateMachine._notifyDisconnected(command.reason);
+        break;
+      default:
+        debug("unexpected command: " + JSON.stringify(command));
+        // ignore unexpected command
+        break;
+    }
+  },
+  function _closedHandler(stateMachine, command) {
+    // ignore every command in closed state.
+    DEBUG && debug("unexpected command: " + JSON.stringify(command));
+  },
+];
+
+function ReceiverStateMachine(channel) {
+  this.state = State.INIT;
+  this._channel = channel;
+}
+
+ReceiverStateMachine.prototype = {
+  launch: function _launch() {
+    // presentation session can only be launched by controlling UA.
+    debug("receiver shouldn't trigger launch");
+  },
+
+  terminate: function _terminate(presentationId) {
+    if (this.state === State.CONNECTED) {
+      this._sendCommand({
+        type: CommandType.TERMINATE,
+        presentationId,
+      });
+    }
+  },
+
+  terminateAck: function _terminateAck(presentationId) {
+    if (this.state === State.CONNECTED) {
+      this._sendCommand({
+        type: CommandType.TERMINATE_ACK,
+        presentationId,
+      });
+    }
+  },
+
+  reconnect: function _reconnect() {
+    debug("receiver shouldn't trigger reconnect");
+  },
+
+  sendOffer: function _sendOffer() {
+    // offer can only be sent by controlling UA.
+    debug("receiver shouldn't generate offer");
+  },
+
+  sendAnswer: function _sendAnswer(answer) {
+    if (this.state === State.CONNECTED) {
+      this._sendCommand({
+        type: CommandType.ANSWER,
+        answer,
+      });
+    }
+  },
+
+  updateIceCandidate: function _updateIceCandidate(candidate) {
+    if (this.state === State.CONNECTED) {
+      this._sendCommand({
+        type: CommandType.ICE_CANDIDATE,
+        candidate,
+      });
+    }
+  },
+
+  onCommand: function _onCommand(command) {
+    handlers[this.state](this, command);
+  },
+
+  onChannelReady: function _onChannelReady() {
+    if (this.state === State.INIT) {
+      this.state = State.CONNECTING;
+    }
+  },
+
+  onChannelClosed: function _onChannelClose(reason, isByRemote) {
+    switch (this.state) {
+      case State.CONNECTED:
+        if (isByRemote) {
+          this.state = State.CLOSED;
+          this._notifyDisconnected(reason);
+        } else {
+          this._sendCommand({
+            type: CommandType.DISCONNECT,
+            reason,
+          });
+          this.state = State.CLOSING;
+          this._closeReason = reason;
+        }
+        break;
+      case State.CLOSING:
+        if (isByRemote) {
+          this.state = State.CLOSED;
+          if (this._closeReason) {
+            reason = this._closeReason;
+            delete this._closeReason;
+          }
+          this._notifyDisconnected(reason);
+        } else {
+          // do nothing and wait for remote channel closed.
+        }
+        break;
+      default:
+        DEBUG &&
+          debug("unexpected channel close: " + reason + ", " + isByRemote);
+        break;
+    }
+  },
+
+  _sendCommand: function _sendCommand(command) {
+    this._channel.sendCommand(command);
+  },
+
+  _notifyDeviceConnected: function _notifyDeviceConnected(deviceName) {
+    this._channel.notifyDeviceConnected(deviceName);
+  },
+
+  _notifyDisconnected: function _notifyDisconnected(reason) {
+    this._channel.notifyDisconnected(reason);
+  },
+
+  _notifyLaunch: function _notifyLaunch(presentationId, url) {
+    this._channel.notifyLaunch(presentationId, url);
+  },
+
+  _notifyTerminate: function _notifyTerminate(presentationId) {
+    this._channel.notifyTerminate(presentationId);
+  },
+
+  _notifyReconnect: function _notifyReconnect(presentationId, url) {
+    this._channel.notifyReconnect(presentationId, url);
+  },
+
+  _notifyChannelDescriptor: function _notifyChannelDescriptor(command) {
+    switch (command.type) {
+      case CommandType.OFFER:
+        this._channel.notifyOffer(command.offer);
+        break;
+      case CommandType.ICE_CANDIDATE:
+        this._channel.notifyIceCandidate(command.candidate);
+        break;
+    }
+  },
+};
diff --git a/dom/presentation/provider/StateMachineHelper.jsm b/dom/presentation/provider/StateMachineHelper.jsm
new file mode 100644
index 0000000000..cc2dc02895
--- /dev/null
+++ b/dom/presentation/provider/StateMachineHelper.jsm
@@ -0,0 +1,38 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 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/. */
+
+"use strict";
+
+var EXPORTED_SYMBOLS = ["State", "CommandType"];
+
+const State = Object.freeze({
+  INIT: 0,
+  CONNECTING: 1,
+  CONNECTED: 2,
+  CLOSING: 3,
+  CLOSED: 4,
+});
+
+const CommandType = Object.freeze({
+  // control channel life cycle
+  CONNECT: "connect", // { deviceId: <string> }
+  CONNECT_ACK: "connect-ack", // { presentationId: <string> }
+  DISCONNECT: "disconnect", // { reason: <int> }
+  // presentation session life cycle
+  LAUNCH: "launch", // { presentationId: <string>, url: <string> }
+  LAUNCH_ACK: "launch-ack", // { presentationId: <string> }
+  TERMINATE: "terminate", // { presentationId: <string> }
+  TERMINATE_ACK: "terminate-ack", // { presentationId: <string> }
+  RECONNECT: "reconnect", // { presentationId: <string> }
+  RECONNECT_ACK: "reconnect-ack", // { presentationId: <string> }
+  // session transport establishment
+  OFFER: "offer", // { offer: <json> }
+  ANSWER: "answer", // { answer: <json> }
+  ICE_CANDIDATE: "ice-candidate", // { candidate: <string> }
+});
+
+this.State = State;
+this.CommandType = CommandType;
diff --git a/dom/presentation/provider/components.conf b/dom/presentation/provider/components.conf
new file mode 100644
index 0000000000..04cb28ec75
--- /dev/null
+++ b/dom/presentation/provider/components.conf
@@ -0,0 +1,26 @@
+# -*- 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/.
+
+categories = {}
+
+if buildconfig.substs['MOZ_WIDGET_TOOLKIT'] in ('cocoa', 'android'):
+    categories["presentation-device-provider"] = "MulticastDNSDeviceProvider"
+
+Classes = [
+    {
+        'cid': '{f4079b8b-ede5-4b90-a112-5b415a931deb}',
+        'contract_ids': ['@mozilla.org/presentation/control-service;1'],
+        'jsm': 'resource://gre/modules/PresentationControlService.jsm',
+        'constructor': 'PresentationControlService',
+    },
+    {
+        'cid': '{814f947a-52f7-41c9-94a1-3684797284ac}',
+        'contract_ids': ['@mozilla.org/presentation-device/multicastdns-provider;1'],
+        'type': 'mozilla::dom::presentation::MulticastDNSDeviceProvider',
+        'headers': ['/dom/presentation/provider/MulticastDNSDeviceProvider.h'],
+        'categories': categories,
+    },
+]
diff --git a/dom/presentation/provider/moz.build b/dom/presentation/provider/moz.build
new file mode 100644
index 0000000000..f6c4527d2c
--- /dev/null
+++ b/dom/presentation/provider/moz.build
@@ -0,0 +1,29 @@
+# -*- 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/.
+
+EXTRA_JS_MODULES += ["PresentationControlService.jsm"]
+
+UNIFIED_SOURCES += [
+    "DeviceProviderHelpers.cpp",
+    "MulticastDNSDeviceProvider.cpp",
+]
+
+XPCOM_MANIFESTS += [
+    "components.conf",
+]
+
+XPCOM_MANIFESTS += [
+    "components.conf",
+]
+
+EXTRA_JS_MODULES.presentation += [
+    "ControllerStateMachine.jsm",
+    "ReceiverStateMachine.jsm",
+    "StateMachineHelper.jsm",
+]
+
+include("/ipc/chromium/chromium-config.mozbuild")
+FINAL_LIBRARY = "xul"
diff --git a/dom/presentation/provider/nsTCPDeviceInfo.h b/dom/presentation/provider/nsTCPDeviceInfo.h
new file mode 100644
index 0000000000..ef646f0bf7
--- /dev/null
+++ b/dom/presentation/provider/nsTCPDeviceInfo.h
@@ -0,0 +1,67 @@
+/* -*- 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 __TCPDeviceInfo_h__
+#define __TCPDeviceInfo_h__
+
+namespace mozilla {
+namespace dom {
+namespace presentation {
+
+class TCPDeviceInfo final : public nsITCPDeviceInfo {
+ public:
+  NS_DECL_ISUPPORTS
+  NS_DECL_NSITCPDEVICEINFO
+
+  explicit TCPDeviceInfo(const nsACString& aId, const nsACString& aAddress,
+                         const uint16_t aPort,
+                         const nsACString& aCertFingerprint)
+      : mId(aId),
+        mAddress(aAddress),
+        mPort(aPort),
+        mCertFingerprint(aCertFingerprint) {}
+
+ private:
+  virtual ~TCPDeviceInfo() = default;
+
+  nsCString mId;
+  nsCString mAddress;
+  uint16_t mPort;
+  nsCString mCertFingerprint;
+};
+
+NS_IMPL_ISUPPORTS(TCPDeviceInfo, nsITCPDeviceInfo)
+
+// nsITCPDeviceInfo
+NS_IMETHODIMP
+TCPDeviceInfo::GetId(nsACString& aId) {
+  aId = mId;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TCPDeviceInfo::GetAddress(nsACString& aAddress) {
+  aAddress = mAddress;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TCPDeviceInfo::GetPort(uint16_t* aPort) {
+  *aPort = mPort;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+TCPDeviceInfo::GetCertFingerprint(nsACString& aCertFingerprint) {
+  aCertFingerprint = mCertFingerprint;
+  return NS_OK;
+}
+
+}  // namespace presentation
+}  // namespace dom
+}  // namespace mozilla
+
+#endif /* !__TCPDeviceInfo_h__ */
diff --git a/dom/presentation/tests/mochitest/PresentationDeviceInfoChromeScript.js b/dom/presentation/tests/mochitest/PresentationDeviceInfoChromeScript.js
new file mode 100644
index 0000000000..83f8965b03
--- /dev/null
+++ b/dom/presentation/tests/mochitest/PresentationDeviceInfoChromeScript.js
@@ -0,0 +1,150 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+/* eslint-env mozilla/frame-script */
+
+const { XPCOMUtils } = ChromeUtils.import(
+  "resource://gre/modules/XPCOMUtils.jsm"
+);
+
+const manager = Cc["@mozilla.org/presentation-device/manager;1"].getService(
+  Ci.nsIPresentationDeviceManager
+);
+
+var testProvider = {
+  QueryInterface: ChromeUtils.generateQI(["nsIPresentationDeviceProvider"]),
+  forceDiscovery() {
+    sendAsyncMessage("force-discovery");
+  },
+  listener: null,
+};
+
+var testDevice = {
+  QueryInterface: ChromeUtils.generateQI(["nsIPresentationDevice"]),
+  establishControlChannel() {
+    return null;
+  },
+  disconnect() {},
+  isRequestedUrlSupported(requestedUrl) {
+    return true;
+  },
+  id: null,
+  name: null,
+  type: null,
+  listener: null,
+};
+
+var testDevice1 = {
+  QueryInterface: ChromeUtils.generateQI(["nsIPresentationDevice"]),
+  id: "dummyid",
+  name: "dummyName",
+  type: "dummyType",
+  establishControlChannel(url, presentationId) {
+    return null;
+  },
+  disconnect() {},
+  isRequestedUrlSupported(requestedUrl) {
+    return true;
+  },
+};
+
+var testDevice2 = {
+  QueryInterface: ChromeUtils.generateQI(["nsIPresentationDevice"]),
+  id: "dummyid",
+  name: "dummyName",
+  type: "dummyType",
+  establishControlChannel(url, presentationId) {
+    return null;
+  },
+  disconnect() {},
+  isRequestedUrlSupported(requestedUrl) {
+    return true;
+  },
+};
+
+var mockedDeviceWithoutSupportedURL = {
+  QueryInterface: ChromeUtils.generateQI(["nsIPresentationDevice"]),
+  id: "dummyid",
+  name: "dummyName",
+  type: "dummyType",
+  establishControlChannel(url, presentationId) {
+    return null;
+  },
+  disconnect() {},
+  isRequestedUrlSupported(requestedUrl) {
+    return false;
+  },
+};
+
+var mockedDeviceSupportHttpsURL = {
+  QueryInterface: ChromeUtils.generateQI(["nsIPresentationDevice"]),
+  id: "dummyid",
+  name: "dummyName",
+  type: "dummyType",
+  establishControlChannel(url, presentationId) {
+    return null;
+  },
+  disconnect() {},
+  isRequestedUrlSupported(requestedUrl) {
+    if (requestedUrl.includes("https://")) {
+      return true;
+    }
+    return false;
+  },
+};
+
+addMessageListener("setup", function() {
+  manager.addDeviceProvider(testProvider);
+
+  sendAsyncMessage("setup-complete");
+});
+
+addMessageListener("trigger-device-add", function(device) {
+  testDevice.id = device.id;
+  testDevice.name = device.name;
+  testDevice.type = device.type;
+  manager.addDevice(testDevice);
+});
+
+addMessageListener("trigger-add-unsupport-url-device", function() {
+  manager.addDevice(mockedDeviceWithoutSupportedURL);
+});
+
+addMessageListener("trigger-add-multiple-devices", function() {
+  manager.addDevice(testDevice1);
+  manager.addDevice(testDevice2);
+});
+
+addMessageListener("trigger-add-https-devices", function() {
+  manager.addDevice(mockedDeviceSupportHttpsURL);
+});
+
+addMessageListener("trigger-device-update", function(device) {
+  testDevice.id = device.id;
+  testDevice.name = device.name;
+  testDevice.type = device.type;
+  manager.updateDevice(testDevice);
+});
+
+addMessageListener("trigger-device-remove", function() {
+  manager.removeDevice(testDevice);
+});
+
+addMessageListener("trigger-remove-unsupported-device", function() {
+  manager.removeDevice(mockedDeviceWithoutSupportedURL);
+});
+
+addMessageListener("trigger-remove-multiple-devices", function() {
+  manager.removeDevice(testDevice1);
+  manager.removeDevice(testDevice2);
+});
+
+addMessageListener("trigger-remove-https-devices", function() {
+  manager.removeDevice(mockedDeviceSupportHttpsURL);
+});
+
+addMessageListener("teardown", function() {
+  manager.removeDeviceProvider(testProvider);
+});
diff --git a/dom/presentation/tests/mochitest/PresentationSessionChromeScript.js b/dom/presentation/tests/mochitest/PresentationSessionChromeScript.js
new file mode 100644
index 0000000000..5e5041a870
--- /dev/null
+++ b/dom/presentation/tests/mochitest/PresentationSessionChromeScript.js
@@ -0,0 +1,553 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+
+/* eslint-env mozilla/frame-script */
+
+const Cm = Components.manager;
+
+const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+const { setTimeout } = ChromeUtils.import("resource://gre/modules/Timer.jsm");
+
+const uuidGenerator = Cc["@mozilla.org/uuid-generator;1"].getService(
+  Ci.nsIUUIDGenerator
+);
+
+function registerMockedFactory(contractId, mockedClassId, mockedFactory) {
+  var originalClassId, originalFactory;
+
+  var registrar = Cm.QueryInterface(Ci.nsIComponentRegistrar);
+  if (!registrar.isCIDRegistered(mockedClassId)) {
+    try {
+      originalClassId = registrar.contractIDToCID(contractId);
+      originalFactory = Cm.getClassObject(Cc[contractId], Ci.nsIFactory);
+    } catch (ex) {
+      originalClassId = "";
+      originalFactory = null;
+    }
+    registrar.registerFactory(mockedClassId, "", contractId, mockedFactory);
+  }
+
+  return {
+    contractId,
+    mockedClassId,
+    mockedFactory,
+    originalClassId,
+    originalFactory,
+  };
+}
+
+function registerOriginalFactory(
+  contractId,
+  mockedClassId,
+  mockedFactory,
+  originalClassId,
+  originalFactory
+) {
+  if (originalFactory) {
+    var registrar = Cm.QueryInterface(Ci.nsIComponentRegistrar);
+    registrar.unregisterFactory(mockedClassId, mockedFactory);
+    // Passing null for the factory remaps the original CID to the
+    // contract ID.
+    registrar.registerFactory(originalClassId, "", contractId, null);
+  }
+}
+
+var sessionId = "test-session-id-" + uuidGenerator.generateUUID().toString();
+
+const address = Cc["@mozilla.org/supports-cstring;1"].createInstance(
+  Ci.nsISupportsCString
+);
+address.data = "127.0.0.1";
+const addresses = Cc["@mozilla.org/array;1"].createInstance(Ci.nsIMutableArray);
+addresses.appendElement(address);
+
+const mockedChannelDescription = {
+  QueryInterface: ChromeUtils.generateQI(["nsIPresentationChannelDescription"]),
+  get type() {
+    if (
+      Services.prefs.getBoolPref(
+        "dom.presentation.session_transport.data_channel.enable"
+      )
+    ) {
+      return Ci.nsIPresentationChannelDescription.TYPE_DATACHANNEL;
+    }
+    return Ci.nsIPresentationChannelDescription.TYPE_TCP;
+  },
+  tcpAddress: addresses,
+  tcpPort: 1234,
+};
+
+const mockedServerSocket = {
+  QueryInterface: ChromeUtils.generateQI(["nsIServerSocket", "nsIFactory"]),
+  createInstance(aOuter, aIID) {
+    if (aOuter) {
+      throw Components.Exception("", Cr.NS_ERROR_NO_AGGREGATION);
+    }
+    return this.QueryInterface(aIID);
+  },
+  get port() {
+    return this._port;
+  },
+  set listener(listener) {
+    this._listener = listener;
+  },
+  init(port, loopbackOnly, backLog) {
+    if (port != -1) {
+      this._port = port;
+    } else {
+      this._port = 5678;
+    }
+  },
+  asyncListen(listener) {
+    this._listener = listener;
+  },
+  close() {
+    this._listener.onStopListening(this, Cr.NS_BINDING_ABORTED);
+  },
+  simulateOnSocketAccepted(serverSocket, socketTransport) {
+    this._listener.onSocketAccepted(serverSocket, socketTransport);
+  },
+};
+
+const mockedSocketTransport = Cc[
+  "@mozilla.org/presentation/mockedsockettransport;1"
+].createInstance(Ci.nsISocketTransport);
+
+const mockedControlChannel = {
+  QueryInterface: ChromeUtils.generateQI(["nsIPresentationControlChannel"]),
+  set listener(listener) {
+    this._listener = listener;
+  },
+  get listener() {
+    return this._listener;
+  },
+  sendOffer(offer) {
+    sendAsyncMessage("offer-sent", this._isValidSDP(offer));
+  },
+  sendAnswer(answer) {
+    sendAsyncMessage("answer-sent", this._isValidSDP(answer));
+
+    if (answer.type == Ci.nsIPresentationChannelDescription.TYPE_TCP) {
+      this._listener
+        .QueryInterface(Ci.nsIPresentationSessionTransportCallback)
+        .notifyTransportReady();
+    }
+  },
+  _isValidSDP(aSDP) {
+    var isValid = false;
+    if (aSDP.type == Ci.nsIPresentationChannelDescription.TYPE_TCP) {
+      try {
+        var sdpAddresses = aSDP.tcpAddress;
+        if (sdpAddresses.length > 0) {
+          for (var i = 0; i < sdpAddresses.length; i++) {
+            // Ensure CString addresses are used. Otherwise, an error will be thrown.
+            sdpAddresses.queryElementAt(i, Ci.nsISupportsCString);
+          }
+
+          isValid = true;
+        }
+      } catch (e) {
+        isValid = false;
+      }
+    } else if (
+      aSDP.type == Ci.nsIPresentationChannelDescription.TYPE_DATACHANNEL
+    ) {
+      isValid = aSDP.dataChannelSDP == "test-sdp";
+    }
+    return isValid;
+  },
+  launch(presentationId, url) {
+    sessionId = presentationId;
+  },
+  terminate(presentationId) {
+    sendAsyncMessage("sender-terminate", presentationId);
+  },
+  reconnect(presentationId, url) {
+    sendAsyncMessage("start-reconnect", url);
+  },
+  notifyReconnected() {
+    this._listener
+      .QueryInterface(Ci.nsIPresentationControlChannelListener)
+      .notifyReconnected();
+  },
+  disconnect(reason) {
+    sendAsyncMessage("control-channel-closed", reason);
+    this._listener
+      .QueryInterface(Ci.nsIPresentationControlChannelListener)
+      .notifyDisconnected(reason);
+  },
+  simulateReceiverReady() {
+    this._listener
+      .QueryInterface(Ci.nsIPresentationControlChannelListener)
+      .notifyReceiverReady();
+  },
+  simulateOnOffer() {
+    sendAsyncMessage("offer-received");
+    this._listener
+      .QueryInterface(Ci.nsIPresentationControlChannelListener)
+      .onOffer(mockedChannelDescription);
+  },
+  simulateOnAnswer() {
+    sendAsyncMessage("answer-received");
+    this._listener
+      .QueryInterface(Ci.nsIPresentationControlChannelListener)
+      .onAnswer(mockedChannelDescription);
+  },
+  simulateNotifyConnected() {
+    sendAsyncMessage("control-channel-opened");
+    this._listener
+      .QueryInterface(Ci.nsIPresentationControlChannelListener)
+      .notifyConnected();
+  },
+};
+
+const mockedDevice = {
+  QueryInterface: ChromeUtils.generateQI(["nsIPresentationDevice"]),
+  id: "id",
+  name: "name",
+  type: "type",
+  establishControlChannel(url, presentationId) {
+    sendAsyncMessage("control-channel-established");
+    return mockedControlChannel;
+  },
+  disconnect() {},
+  isRequestedUrlSupported(requestedUrl) {
+    return true;
+  },
+};
+
+const mockedDevicePrompt = {
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIPresentationDevicePrompt",
+    "nsIFactory",
+  ]),
+  createInstance(aOuter, aIID) {
+    if (aOuter) {
+      throw Components.Exception("", Cr.NS_ERROR_NO_AGGREGATION);
+    }
+    return this.QueryInterface(aIID);
+  },
+  set request(request) {
+    this._request = request;
+  },
+  get request() {
+    return this._request;
+  },
+  promptDeviceSelection(request) {
+    this._request = request;
+    sendAsyncMessage("device-prompt");
+  },
+  simulateSelect() {
+    this._request.select(mockedDevice);
+  },
+  simulateCancel(result) {
+    this._request.cancel(result);
+  },
+};
+
+const mockedSessionTransport = {
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIPresentationSessionTransport",
+    "nsIPresentationSessionTransportBuilder",
+    "nsIPresentationTCPSessionTransportBuilder",
+    "nsIPresentationDataChannelSessionTransportBuilder",
+    "nsIPresentationControlChannelListener",
+    "nsIFactory",
+  ]),
+  createInstance(aOuter, aIID) {
+    if (aOuter) {
+      throw Components.Exception("", Cr.NS_ERROR_NO_AGGREGATION);
+    }
+    return this.QueryInterface(aIID);
+  },
+  set callback(callback) {
+    this._callback = callback;
+  },
+  get callback() {
+    return this._callback;
+  },
+  get selfAddress() {
+    return this._selfAddress;
+  },
+  buildTCPSenderTransport(transport, listener) {
+    this._listener = listener;
+    this._role = Ci.nsIPresentationService.ROLE_CONTROLLER;
+    this._listener.onSessionTransport(this);
+    this._listener = null;
+    sendAsyncMessage("data-transport-initialized");
+
+    setTimeout(() => {
+      this.simulateTransportReady();
+    }, 0);
+  },
+  buildTCPReceiverTransport(description, listener) {
+    this._listener = listener;
+    this._role = Ci.nsIPresentationService.ROLE_RECEIVER;
+
+    var tcpAddresses = description.QueryInterface(
+      Ci.nsIPresentationChannelDescription
+    ).tcpAddress;
+    this._selfAddress = {
+      QueryInterface: ChromeUtils.generateQI(["nsINetAddr"]),
+      address:
+        tcpAddresses.length > 0
+          ? tcpAddresses.queryElementAt(0, Ci.nsISupportsCString).data
+          : "",
+      port: description.QueryInterface(Ci.nsIPresentationChannelDescription)
+        .tcpPort,
+    };
+
+    setTimeout(() => {
+      this._listener.onSessionTransport(this);
+      this._listener = null;
+    }, 0);
+  },
+  // in-process case
+  buildDataChannelTransport(role, window, listener) {
+    this._listener = listener;
+    this._role = role;
+
+    var hasNavigator = window ? typeof window.navigator != "undefined" : false;
+    sendAsyncMessage("check-navigator", hasNavigator);
+
+    setTimeout(() => {
+      this._listener.onSessionTransport(this);
+      this._listener = null;
+      this.simulateTransportReady();
+    }, 0);
+  },
+  enableDataNotification() {
+    sendAsyncMessage("data-transport-notification-enabled");
+  },
+  send(data) {
+    sendAsyncMessage("message-sent", data);
+  },
+  close(reason) {
+    // Don't send a message after tearDown, to avoid a leak.
+    if (this._callback) {
+      sendAsyncMessage("data-transport-closed", reason);
+      this._callback
+        .QueryInterface(Ci.nsIPresentationSessionTransportCallback)
+        .notifyTransportClosed(reason);
+    }
+  },
+  simulateTransportReady() {
+    this._callback
+      .QueryInterface(Ci.nsIPresentationSessionTransportCallback)
+      .notifyTransportReady();
+  },
+  simulateIncomingMessage(message) {
+    this._callback
+      .QueryInterface(Ci.nsIPresentationSessionTransportCallback)
+      .notifyData(message, false);
+  },
+  onOffer(aOffer) {},
+  onAnswer(aAnswer) {},
+};
+
+const mockedNetworkInfo = {
+  QueryInterface: ChromeUtils.generateQI(["nsINetworkInfo"]),
+  getAddresses(ips, prefixLengths) {
+    ips.value = ["127.0.0.1"];
+    prefixLengths.value = [0];
+    return 1;
+  },
+};
+
+const mockedNetworkManager = {
+  QueryInterface: ChromeUtils.generateQI(["nsINetworkManager", "nsIFactory"]),
+  createInstance(aOuter, aIID) {
+    if (aOuter) {
+      throw Components.Exception("", Cr.NS_ERROR_NO_AGGREGATION);
+    }
+    return this.QueryInterface(aIID);
+  },
+  get activeNetworkInfo() {
+    return mockedNetworkInfo;
+  },
+};
+
+var requestPromise = null;
+
+const mockedRequestUIGlue = {
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIPresentationRequestUIGlue",
+    "nsIFactory",
+  ]),
+  createInstance(aOuter, aIID) {
+    if (aOuter) {
+      throw Components.Exception("", Cr.NS_ERROR_NO_AGGREGATION);
+    }
+    return this.QueryInterface(aIID);
+  },
+  sendRequest(aUrl, aSessionId) {
+    sendAsyncMessage("receiver-launching", aSessionId);
+    return requestPromise;
+  },
+};
+
+// Register mocked factories.
+const originalFactoryData = [];
+originalFactoryData.push(
+  registerMockedFactory(
+    "@mozilla.org/presentation-device/prompt;1",
+    uuidGenerator.generateUUID(),
+    mockedDevicePrompt
+  )
+);
+originalFactoryData.push(
+  registerMockedFactory(
+    "@mozilla.org/network/server-socket;1",
+    uuidGenerator.generateUUID(),
+    mockedServerSocket
+  )
+);
+originalFactoryData.push(
+  registerMockedFactory(
+    "@mozilla.org/presentation/presentationtcpsessiontransport;1",
+    uuidGenerator.generateUUID(),
+    mockedSessionTransport
+  )
+);
+originalFactoryData.push(
+  registerMockedFactory(
+    "@mozilla.org/presentation/datachanneltransportbuilder;1",
+    uuidGenerator.generateUUID(),
+    mockedSessionTransport
+  )
+);
+originalFactoryData.push(
+  registerMockedFactory(
+    "@mozilla.org/network/manager;1",
+    uuidGenerator.generateUUID(),
+    mockedNetworkManager
+  )
+);
+originalFactoryData.push(
+  registerMockedFactory(
+    "@mozilla.org/presentation/requestuiglue;1",
+    uuidGenerator.generateUUID(),
+    mockedRequestUIGlue
+  )
+);
+
+function tearDown() {
+  requestPromise = null;
+  mockedServerSocket.listener = null;
+  mockedControlChannel.listener = null;
+  mockedDevice.listener = null;
+  mockedDevicePrompt.request = null;
+  mockedSessionTransport.callback = null;
+
+  var deviceManager = Cc[
+    "@mozilla.org/presentation-device/manager;1"
+  ].getService(Ci.nsIPresentationDeviceManager);
+  deviceManager
+    .QueryInterface(Ci.nsIPresentationDeviceListener)
+    .removeDevice(mockedDevice);
+
+  // Register original factories.
+  for (var data of originalFactoryData) {
+    registerOriginalFactory(
+      data.contractId,
+      data.mockedClassId,
+      data.mockedFactory,
+      data.originalClassId,
+      data.originalFactory
+    );
+  }
+
+  sendAsyncMessage("teardown-complete");
+}
+
+addMessageListener("trigger-device-add", function() {
+  var deviceManager = Cc[
+    "@mozilla.org/presentation-device/manager;1"
+  ].getService(Ci.nsIPresentationDeviceManager);
+  deviceManager
+    .QueryInterface(Ci.nsIPresentationDeviceListener)
+    .addDevice(mockedDevice);
+});
+
+addMessageListener("trigger-device-prompt-select", function() {
+  mockedDevicePrompt.simulateSelect();
+});
+
+addMessageListener("trigger-device-prompt-cancel", function(result) {
+  mockedDevicePrompt.simulateCancel(result);
+});
+
+addMessageListener("trigger-incoming-session-request", function(url) {
+  var deviceManager = Cc[
+    "@mozilla.org/presentation-device/manager;1"
+  ].getService(Ci.nsIPresentationDeviceManager);
+  deviceManager
+    .QueryInterface(Ci.nsIPresentationDeviceListener)
+    .onSessionRequest(mockedDevice, url, sessionId, mockedControlChannel);
+});
+
+addMessageListener("trigger-incoming-terminate-request", function() {
+  var deviceManager = Cc[
+    "@mozilla.org/presentation-device/manager;1"
+  ].getService(Ci.nsIPresentationDeviceManager);
+  deviceManager
+    .QueryInterface(Ci.nsIPresentationDeviceListener)
+    .onTerminateRequest(mockedDevice, sessionId, mockedControlChannel, true);
+});
+
+addMessageListener("trigger-reconnected-acked", function(url) {
+  mockedControlChannel.notifyReconnected();
+});
+
+addMessageListener("trigger-incoming-offer", function() {
+  mockedControlChannel.simulateOnOffer();
+});
+
+addMessageListener("trigger-incoming-answer", function() {
+  mockedControlChannel.simulateOnAnswer();
+});
+
+addMessageListener("trigger-incoming-transport", function() {
+  mockedServerSocket.simulateOnSocketAccepted(
+    mockedServerSocket,
+    mockedSocketTransport
+  );
+});
+
+addMessageListener("trigger-control-channel-open", function(reason) {
+  mockedControlChannel.simulateNotifyConnected();
+});
+
+addMessageListener("trigger-control-channel-close", function(reason) {
+  mockedControlChannel.disconnect(reason);
+});
+
+addMessageListener("trigger-data-transport-close", function(reason) {
+  mockedSessionTransport.close(reason);
+});
+
+addMessageListener("trigger-incoming-message", function(message) {
+  mockedSessionTransport.simulateIncomingMessage(message);
+});
+
+addMessageListener("teardown", function() {
+  tearDown();
+});
+
+var controlChannelListener;
+addMessageListener("save-control-channel-listener", function() {
+  controlChannelListener = mockedControlChannel.listener;
+});
+
+addMessageListener("restore-control-channel-listener", function(message) {
+  mockedControlChannel.listener = controlChannelListener;
+  controlChannelListener = null;
+});
+
+Services.obs.addObserver(function observer(aSubject, aTopic, aData) {
+  Services.obs.removeObserver(observer, aTopic);
+
+  requestPromise = aSubject;
+}, "setup-request-promise");
diff --git a/dom/presentation/tests/mochitest/PresentationSessionChromeScript1UA.js b/dom/presentation/tests/mochitest/PresentationSessionChromeScript1UA.js
new file mode 100644
index 0000000000..fe5bb6d6be
--- /dev/null
+++ b/dom/presentation/tests/mochitest/PresentationSessionChromeScript1UA.js
@@ -0,0 +1,412 @@
+/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */
+/* 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/. */
+
+"use strict";
+
+/* eslint-env mozilla/frame-script */
+
+const Cm = Components.manager;
+
+const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+
+const uuidGenerator = Cc["@mozilla.org/uuid-generator;1"].getService(
+  Ci.nsIUUIDGenerator
+);
+
+function debug(str) {
+  // dump('DEBUG -*- PresentationSessionChromeScript1UA -*-: ' + str + '\n');
+}
+
+const originalFactoryData = [];
+var sessionId; // Store the uuid generated by PresentationRequest.
+var triggerControlChannelError = false; // For simulating error during control channel establishment.
+
+// control channel of sender
+const mockControlChannelOfSender = {
+  QueryInterface: ChromeUtils.generateQI(["nsIPresentationControlChannel"]),
+  set listener(listener) {
+    // PresentationControllingInfo::SetControlChannel
+    if (listener) {
+      debug("set listener for mockControlChannelOfSender without null");
+    } else {
+      debug("set listener for mockControlChannelOfSender with null");
+    }
+    this._listener = listener;
+  },
+  get listener() {
+    return this._listener;
+  },
+  notifyConnected() {
+    // send offer after notifyConnected immediately
+    this._listener
+      .QueryInterface(Ci.nsIPresentationControlChannelListener)
+      .notifyConnected();
+  },
+  notifyReconnected() {
+    // send offer after notifyOpened immediately
+    this._listener
+      .QueryInterface(Ci.nsIPresentationControlChannelListener)
+      .notifyReconnected();
+  },
+  sendOffer(offer) {
+    Services.tm.dispatchToMainThread(() => {
+      mockControlChannelOfReceiver.onOffer(offer);
+    });
+  },
+  onAnswer(answer) {
+    this._listener
+      .QueryInterface(Ci.nsIPresentationControlChannelListener)
+      .onAnswer(answer);
+  },
+  launch(presentationId, url) {
+    sessionId = presentationId;
+    sendAsyncMessage("sender-launch", url);
+  },
+  disconnect(reason) {
+    if (!this._listener) {
+      return;
+    }
+    this._listener
+      .QueryInterface(Ci.nsIPresentationControlChannelListener)
+      .notifyDisconnected(reason);
+    mockControlChannelOfReceiver.disconnect();
+  },
+  terminate(presentationId) {
+    sendAsyncMessage("sender-terminate");
+  },
+  reconnect(presentationId, url) {
+    sendAsyncMessage("start-reconnect", url);
+  },
+  sendIceCandidate(candidate) {
+    mockControlChannelOfReceiver.notifyIceCandidate(candidate);
+  },
+  notifyIceCandidate(candidate) {
+    if (!this._listener) {
+      return;
+    }
+
+    this._listener
+      .QueryInterface(Ci.nsIPresentationControlChannelListener)
+      .onIceCandidate(candidate);
+  },
+};
+
+// control channel of receiver
+const mockControlChannelOfReceiver = {
+  QueryInterface: ChromeUtils.generateQI(["nsIPresentationControlChannel"]),
+  set listener(listener) {
+    // PresentationPresentingInfo::SetControlChannel
+    if (listener) {
+      debug("set listener for mockControlChannelOfReceiver without null");
+    } else {
+      debug("set listener for mockControlChannelOfReceiver with null");
+    }
+    this._listener = listener;
+
+    if (this._pendingOpened) {
+      this._pendingOpened = false;
+      this.notifyConnected();
+    }
+  },
+  get listener() {
+    return this._listener;
+  },
+  notifyConnected() {
+    // do nothing
+    if (!this._listener) {
+      this._pendingOpened = true;
+      return;
+    }
+    this._listener
+      .QueryInterface(Ci.nsIPresentationControlChannelListener)
+      .notifyConnected();
+  },
+  onOffer(offer) {
+    this._listener
+      .QueryInterface(Ci.nsIPresentationControlChannelListener)
+      .onOffer(offer);
+  },
+  sendAnswer(answer) {
+    Services.tm.dispatchToMainThread(() => {
+      mockControlChannelOfSender.onAnswer(answer);
+    });
+  },
+  disconnect(reason) {
+    if (!this._listener) {
+      return;
+    }
+
+    this._listener
+      .QueryInterface(Ci.nsIPresentationControlChannelListener)
+      .notifyDisconnected(reason);
+    sendAsyncMessage("control-channel-receiver-closed", reason);
+  },
+  terminate(presentaionId) {},
+  sendIceCandidate(candidate) {
+    mockControlChannelOfSender.notifyIceCandidate(candidate);
+  },
+  notifyIceCandidate(candidate) {
+    if (!this._listener) {
+      return;
+    }
+
+    this._listener
+      .QueryInterface(Ci.nsIPresentationControlChannelListener)
+      .onIceCandidate(candidate);
+  },
+};
+
+const mockDevice = {
+  QueryInterface: ChromeUtils.generateQI(["nsIPresentationDevice"]),
+  id: "id",
+  name: "name",
+  type: "type",
+  establishControlChannel(url, presentationId) {
+    if (triggerControlChannelError) {
+      throw Components.Exception("", Cr.NS_ERROR_FAILURE);
+    }
+    sendAsyncMessage("control-channel-established");
+    return mockControlChannelOfSender;
+  },
+  disconnect() {
+    sendAsyncMessage("device-disconnected");
+  },
+  isRequestedUrlSupported(requestedUrl) {
+    return true;
+  },
+};
+
+const mockDevicePrompt = {
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIPresentationDevicePrompt",
+    "nsIFactory",
+  ]),
+  createInstance(aOuter, aIID) {
+    if (aOuter) {
+      throw Components.Exception("", Cr.NS_ERROR_NO_AGGREGATION);
+    }
+    return this.QueryInterface(aIID);
+  },
+  set request(request) {
+    this._request = request;
+  },
+  get request() {
+    return this._request;
+  },
+  promptDeviceSelection(request) {
+    this._request = request;
+    sendAsyncMessage("device-prompt");
+  },
+  simulateSelect() {
+    this._request.select(mockDevice);
+  },
+  simulateCancel() {
+    this._request.cancel();
+  },
+};
+
+const mockRequestUIGlue = {
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIPresentationRequestUIGlue",
+    "nsIFactory",
+  ]),
+  set promise(aPromise) {
+    this._promise = aPromise;
+  },
+  get promise() {
+    return this._promise;
+  },
+  createInstance(aOuter, aIID) {
+    if (aOuter) {
+      throw Components.Exception("", Cr.NS_ERROR_NO_AGGREGATION);
+    }
+    return this.QueryInterface(aIID);
+  },
+  sendRequest(aUrl, aSessionId) {
+    return this.promise;
+  },
+};
+
+function initMockAndListener() {
+  function registerMockFactory(contractId, mockClassId, mockFactory) {
+    var originalClassId, originalFactory;
+
+    var registrar = Cm.QueryInterface(Ci.nsIComponentRegistrar);
+    if (!registrar.isCIDRegistered(mockClassId)) {
+      try {
+        originalClassId = registrar.contractIDToCID(contractId);
+        originalFactory = Cm.getClassObject(Cc[contractId], Ci.nsIFactory);
+      } catch (ex) {
+        originalClassId = "";
+        originalFactory = null;
+      }
+      if (originalFactory) {
+        registrar.unregisterFactory(originalClassId, originalFactory);
+      }
+      registrar.registerFactory(mockClassId, "", contractId, mockFactory);
+    }
+
+    return {
+      contractId,
+      mockClassId,
+      mockFactory,
+      originalClassId,
+      originalFactory,
+    };
+  }
+  // Register mock factories.
+  originalFactoryData.push(
+    registerMockFactory(
+      "@mozilla.org/presentation-device/prompt;1",
+      uuidGenerator.generateUUID(),
+      mockDevicePrompt
+    )
+  );
+  originalFactoryData.push(
+    registerMockFactory(
+      "@mozilla.org/presentation/requestuiglue;1",
+      uuidGenerator.generateUUID(),
+      mockRequestUIGlue
+    )
+  );
+
+  addMessageListener("trigger-device-add", function() {
+    debug("Got message: trigger-device-add");
+    var deviceManager = Cc[
+      "@mozilla.org/presentation-device/manager;1"
+    ].getService(Ci.nsIPresentationDeviceManager);
+    deviceManager
+      .QueryInterface(Ci.nsIPresentationDeviceListener)
+      .addDevice(mockDevice);
+  });
+
+  addMessageListener("trigger-device-prompt-select", function() {
+    debug("Got message: trigger-device-prompt-select");
+    mockDevicePrompt.simulateSelect();
+  });
+
+  addMessageListener("trigger-on-session-request", function(url) {
+    debug("Got message: trigger-on-session-request");
+    var deviceManager = Cc[
+      "@mozilla.org/presentation-device/manager;1"
+    ].getService(Ci.nsIPresentationDeviceManager);
+    deviceManager
+      .QueryInterface(Ci.nsIPresentationDeviceListener)
+      .onSessionRequest(
+        mockDevice,
+        url,
+        sessionId,
+        mockControlChannelOfReceiver
+      );
+  });
+
+  addMessageListener("trigger-on-terminate-request", function() {
+    debug("Got message: trigger-on-terminate-request");
+    var deviceManager = Cc[
+      "@mozilla.org/presentation-device/manager;1"
+    ].getService(Ci.nsIPresentationDeviceManager);
+    deviceManager
+      .QueryInterface(Ci.nsIPresentationDeviceListener)
+      .onTerminateRequest(
+        mockDevice,
+        sessionId,
+        mockControlChannelOfReceiver,
+        false
+      );
+  });
+
+  addMessageListener("trigger-control-channel-open", function(reason) {
+    debug("Got message: trigger-control-channel-open");
+    mockControlChannelOfSender.notifyConnected();
+    mockControlChannelOfReceiver.notifyConnected();
+  });
+
+  addMessageListener("trigger-control-channel-error", function(reason) {
+    debug("Got message: trigger-control-channel-open");
+    triggerControlChannelError = true;
+  });
+
+  addMessageListener("trigger-reconnected-acked", function(url) {
+    debug("Got message: trigger-reconnected-acked");
+    mockControlChannelOfSender.notifyReconnected();
+    var deviceManager = Cc[
+      "@mozilla.org/presentation-device/manager;1"
+    ].getService(Ci.nsIPresentationDeviceManager);
+    deviceManager
+      .QueryInterface(Ci.nsIPresentationDeviceListener)
+      .onReconnectRequest(
+        mockDevice,
+        url,
+        sessionId,
+        mockControlChannelOfReceiver
+      );
+  });
+
+  // Used to call sendAsyncMessage in chrome script from receiver.
+  addMessageListener("forward-command", function(command_data) {
+    let command = JSON.parse(command_data);
+    sendAsyncMessage(command.name, command.data);
+  });
+
+  addMessageListener("teardown", teardown);
+
+  Services.obs.addObserver(function setupRequestPromiseHandler(
+    aSubject,
+    aTopic,
+    aData
+  ) {
+    debug("Got observer: setup-request-promise");
+    Services.obs.removeObserver(setupRequestPromiseHandler, aTopic);
+    mockRequestUIGlue.promise = aSubject;
+    sendAsyncMessage("promise-setup-ready");
+  },
+  "setup-request-promise");
+}
+
+function teardown() {
+  function registerOriginalFactory(
+    contractId,
+    mockedClassId,
+    mockedFactory,
+    originalClassId,
+    originalFactory
+  ) {
+    if (originalFactory) {
+      var registrar = Cm.QueryInterface(Ci.nsIComponentRegistrar);
+      registrar.unregisterFactory(mockedClassId, mockedFactory);
+      registrar.registerFactory(
+        originalClassId,
+        "",
+        contractId,
+        originalFactory
+      );
+    }
+  }
+
+  mockRequestUIGlue.promise = null;
+  mockControlChannelOfSender.listener = null;
+  mockControlChannelOfReceiver.listener = null;
+  mockDevicePrompt.request = null;
+
+  var deviceManager = Cc[
+    "@mozilla.org/presentation-device/manager;1"
+  ].getService(Ci.nsIPresentationDeviceManager);
+  deviceManager
+    .QueryInterface(Ci.nsIPresentationDeviceListener)
+    .removeDevice(mockDevice);
+  // Register original factories.
+  for (var data of originalFactoryData) {
+    registerOriginalFactory(
+      data.contractId,
+      data.mockClassId,
+      data.mockFactory,
+      data.originalClassId,
+      data.originalFactory
+    );
+  }
+  sendAsyncMessage("teardown-complete");
+}
+
+initMockAndListener();
diff --git a/dom/presentation/tests/mochitest/PresentationSessionFrameScript.js b/dom/presentation/tests/mochitest/PresentationSessionFrameScript.js
new file mode 100644
index 0000000000..5385e5d9b9
--- /dev/null
+++ b/dom/presentation/tests/mochitest/PresentationSessionFrameScript.js
@@ -0,0 +1,291 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* Any copyright is dedicated to the Public Domain.
+   http://creativecommons.org/publicdomain/zero/1.0/ */
+
+/* eslint-env mozilla/frame-script */
+
+function loadPrivilegedScriptTest() {
+  /**
+   * The script is loaded as
+   * (a) a privileged script in content process for dc_sender.html
+   * (b) a frame script in the remote iframe process for dc_receiver_oop.html
+   * |type port == "undefined"| indicates the script is load by
+   * |loadPrivilegedScript| which is the first case.
+   */
+  function sendMessage(type, data) {
+    if (typeof port == "undefined") {
+      sendAsyncMessage(type, { data });
+    } else {
+      port.postMessage({ type, data });
+    }
+  }
+
+  if (typeof port != "undefined") {
+    /**
+     * When the script is loaded by |loadPrivilegedScript|, these APIs
+     * are exposed to this script.
+     */
+    port.onmessage = e => {
+      var type = e.data.type;
+      if (!handlers.hasOwnProperty(type)) {
+        return;
+      }
+      var args = [e];
+      handlers[type].forEach(handler => handler.apply(null, args));
+    };
+    var handlers = {};
+    /* eslint-disable-next-line no-global-assign */
+    addMessageListener = function(message, handler) {
+      if (handlers.hasOwnProperty(message)) {
+        handlers[message].push(handler);
+      } else {
+        handlers[message] = [handler];
+      }
+    };
+    /* eslint-disable-next-line no-global-assign */
+    removeMessageListener = function(message, handler) {
+      if (!handler || !handlers.hasOwnProperty(message)) {
+        return;
+      }
+      var index = handlers[message].indexOf(handler);
+      if (index != -1) {
+        handlers[message].splice(index, 1);
+      }
+    };
+  }
+
+  const Cm = Components.manager;
+
+  const mockedChannelDescription = {
+    /* eslint-disable-next-line mozilla/use-chromeutils-generateqi */
+    QueryInterface(iid) {
+      const interfaces = [Ci.nsIPresentationChannelDescription];
+
+      if (!interfaces.some(v => iid.equals(v))) {
+        throw Components.Exception("", Cr.NS_ERROR_NO_INTERFACE);
+      }
+      return this;
+    },
+    get type() {
+      /* global Services */
+      if (
+        Services.prefs.getBoolPref(
+          "dom.presentation.session_transport.data_channel.enable"
+        )
+      ) {
+        return Ci.nsIPresentationChannelDescription.TYPE_DATACHANNEL;
+      }
+      return Ci.nsIPresentationChannelDescription.TYPE_TCP;
+    },
+    get dataChannelSDP() {
+      return "test-sdp";
+    },
+  };
+
+  function setTimeout(callback, delay) {
+    let timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+    timer.initWithCallback(
+      { notify: callback },
+      delay,
+      Ci.nsITimer.TYPE_ONE_SHOT
+    );
+    return timer;
+  }
+
+  const mockedSessionTransport = {
+    /* eslint-disable-next-line mozilla/use-chromeutils-generateqi */
+    QueryInterface(iid) {
+      const interfaces = [
+        Ci.nsIPresentationSessionTransport,
+        Ci.nsIPresentationDataChannelSessionTransportBuilder,
+        Ci.nsIFactory,
+      ];
+
+      if (!interfaces.some(v => iid.equals(v))) {
+        throw Components.Exception("", Cr.NS_ERROR_NO_INTERFACE);
+      }
+      return this;
+    },
+    createInstance(aOuter, aIID) {
+      if (aOuter) {
+        throw Components.Exception("", Cr.NS_ERROR_NO_AGGREGATION);
+      }
+      return this.QueryInterface(aIID);
+    },
+    set callback(callback) {
+      this._callback = callback;
+    },
+    get callback() {
+      return this._callback;
+    },
+    /* OOP case */
+    buildDataChannelTransport(role, window, listener) {
+      dump("PresentationSessionFrameScript: build data channel transport\n");
+      this._listener = listener;
+      this._role = role;
+
+      var hasNavigator = window
+        ? typeof window.navigator != "undefined"
+        : false;
+      sendMessage("check-navigator", hasNavigator);
+
+      if (this._role == Ci.nsIPresentationService.ROLE_CONTROLLER) {
+        this._listener.sendOffer(mockedChannelDescription);
+      }
+    },
+
+    enableDataNotification() {
+      sendMessage("data-transport-notification-enabled");
+    },
+    send(data) {
+      sendMessage("message-sent", data);
+    },
+    close(reason) {
+      sendMessage("data-transport-closed", reason);
+      this._callback
+        .QueryInterface(Ci.nsIPresentationSessionTransportCallback)
+        .notifyTransportClosed(reason);
+      this._callback = null;
+    },
+    simulateTransportReady() {
+      this._callback
+        .QueryInterface(Ci.nsIPresentationSessionTransportCallback)
+        .notifyTransportReady();
+    },
+    simulateIncomingMessage(message) {
+      this._callback
+        .QueryInterface(Ci.nsIPresentationSessionTransportCallback)
+        .notifyData(message, false);
+    },
+    onOffer(aOffer) {
+      this._listener.sendAnswer(mockedChannelDescription);
+      this._onSessionTransport();
+    },
+    onAnswer(aAnswer) {
+      this._onSessionTransport();
+    },
+    _onSessionTransport() {
+      setTimeout(() => {
+        this._listener.onSessionTransport(this);
+        this.simulateTransportReady();
+        this._listener = null;
+      }, 0);
+    },
+  };
+
+  function tearDown() {
+    mockedSessionTransport.callback = null;
+
+    /* Register original factories. */
+    for (var data of originalFactoryData) {
+      registerOriginalFactory(
+        data.contractId,
+        data.mockedClassId,
+        data.mockedFactory,
+        data.originalClassId,
+        data.originalFactory
+      );
+    }
+    sendMessage("teardown-complete");
+  }
+
+  function registerMockedFactory(contractId, mockedClassId, mockedFactory) {
+    var originalClassId, originalFactory;
+    var registrar = Cm.QueryInterface(Ci.nsIComponentRegistrar);
+
+    if (!registrar.isCIDRegistered(mockedClassId)) {
+      try {
+        originalClassId = registrar.contractIDToCID(contractId);
+        originalFactory = Cm.getClassObject(Cc[contractId], Ci.nsIFactory);
+      } catch (ex) {
+        originalClassId = "";
+        originalFactory = null;
+      }
+      registrar.registerFactory(mockedClassId, "", contractId, mockedFactory);
+    }
+
+    return {
+      contractId,
+      mockedClassId,
+      mockedFactory,
+      originalClassId,
+      originalFactory,
+    };
+  }
+
+  function registerOriginalFactory(
+    contractId,
+    mockedClassId,
+    mockedFactory,
+    originalClassId,
+    originalFactory
+  ) {
+    if (originalFactory) {
+      var registrar = Cm.QueryInterface(Ci.nsIComponentRegistrar);
+      registrar.unregisterFactory(mockedClassId, mockedFactory);
+      registrar.registerFactory(originalClassId, "", contractId, null);
+    }
+  }
+
+  /* Register mocked factories. */
+  const originalFactoryData = [];
+  const uuidGenerator = Cc["@mozilla.org/uuid-generator;1"].getService(
+    Ci.nsIUUIDGenerator
+  );
+  originalFactoryData.push(
+    registerMockedFactory(
+      "@mozilla.org/presentation/datachanneltransportbuilder;1",
+      uuidGenerator.generateUUID(),
+      mockedSessionTransport
+    )
+  );
+
+  addMessageListener("trigger-incoming-message", function(event) {
+    mockedSessionTransport.simulateIncomingMessage(event.data.data);
+  });
+  addMessageListener("teardown", () => tearDown());
+}
+
+// Exposed to the caller of |loadPrivilegedScript|
+var contentScript = {
+  handlers: {},
+  addMessageListener(message, handler) {
+    if (this.handlers.hasOwnProperty(message)) {
+      this.handlers[message].push(handler);
+    } else {
+      this.handlers[message] = [handler];
+    }
+  },
+  removeMessageListener(message, handler) {
+    if (!handler || !this.handlers.hasOwnProperty(message)) {
+      return;
+    }
+    var index = this.handlers[message].indexOf(handler);
+    if (index != -1) {
+      this.handlers[message].splice(index, 1);
+    }
+  },
+  sendAsyncMessage(message, data) {
+    port.postMessage({ type: message, data });
+  },
+};
+
+if (!SpecialPowers.isMainProcess()) {
+  var port;
+  try {
+    port = SpecialPowers.loadPrivilegedScript(
+      loadPrivilegedScriptTest.toString()
+    );
+  } catch (e) {
+    ok(false, "loadPrivilegedScript should not throw" + e);
+  }
+
+  port.onmessage = e => {
+    var type = e.data.type;
+    if (!contentScript.handlers.hasOwnProperty(type)) {
+      return;
+    }
+    var args = [e.data.data];
+    contentScript.handlers[type].forEach(handler => handler.apply(null, args));
+  };
+}
diff --git a/dom/presentation/tests/mochitest/chrome.ini b/dom/presentation/tests/mochitest/chrome.ini
new file mode 100644
index 0000000000..22ecc244ee
--- /dev/null
+++ b/dom/presentation/tests/mochitest/chrome.ini
@@ -0,0 +1,13 @@
+[DEFAULT]
+support-files =
+  PresentationDeviceInfoChromeScript.js
+  PresentationSessionChromeScript.js
+
+[test_presentation_datachannel_sessiontransport.html]
+skip-if = os == 'android'
+[test_presentation_sender_startWithDevice.html]
+skip-if = toolkit == 'android' # Bug 1129785
+[test_presentation_tcp_sender.html]
+skip-if = toolkit == 'android' # Bug 1129785
+[test_presentation_tcp_sender_default_request.html]
+skip-if = toolkit == 'android' # Bug 1129785
diff --git a/dom/presentation/tests/mochitest/file_presentation_1ua_receiver.html b/dom/presentation/tests/mochitest/file_presentation_1ua_receiver.html
new file mode 100644
index 0000000000..3d98d12a2b
--- /dev/null
+++ b/dom/presentation/tests/mochitest/file_presentation_1ua_receiver.html
@@ -0,0 +1,216 @@
+<!DOCTYPE HTML>
+<!-- vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: -->
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>Test for B2G PresentationReceiver at receiver side</title>
+  </head>
+  <body>
+    <div id="content"></div>
+<script type="application/javascript">
+
+"use strict";
+
+function is(a, b, msg) {
+  if (a === b) {
+    alert("OK " + msg);
+  } else {
+    alert("KO " + msg + " | reason: " + a + " != " + b);
+  }
+}
+
+function ok(a, msg) {
+  alert((a ? "OK " : "KO ") + msg);
+}
+
+function info(msg) {
+  alert("INFO " + msg);
+}
+
+function command(name, data) {
+  alert("COMMAND " + JSON.stringify({name, data}));
+}
+
+function finish() {
+  alert("DONE");
+}
+
+var connection;
+const DATA_ARRAY = [0, 255, 254, 0, 1, 2, 3, 0, 255, 255, 254, 0];
+const DATA_ARRAY_BUFFER = new ArrayBuffer(DATA_ARRAY.length);
+const TYPED_DATA_ARRAY = new Uint8Array(DATA_ARRAY_BUFFER);
+TYPED_DATA_ARRAY.set(DATA_ARRAY);
+
+function is_same_buffer(recv_data, expect_data) {
+  let recv_dataview = new Uint8Array(recv_data);
+  let expected_dataview = new Uint8Array(expect_data);
+
+  if (recv_dataview.length !== expected_dataview.length) {
+    return false;
+  }
+
+  for (let i = 0; i < recv_dataview.length; i++) {
+    if (recv_dataview[i] != expected_dataview[i]) {
+      info("discover byte differenct at " + i);
+      return false;
+    }
+  }
+  return true;
+}
+
+function testConnectionAvailable() {
+  return new Promise(function(aResolve, aReject) {
+    info("Receiver: --- testConnectionAvailable ---");
+    ok(navigator.presentation, "Receiver: navigator.presentation should be available.");
+    ok(navigator.presentation.receiver, "Receiver: navigator.presentation.receiver should be available.");
+    is(navigator.presentation.defaultRequest, null, "Receiver: navigator.presentation.defaultRequest should be null.");
+
+    navigator.presentation.receiver.connectionList
+    .then((aList) => {
+      is(aList.connections.length, 1, "Should get one conncetion.");
+      connection = aList.connections[0];
+      ok(connection.id, "Connection ID should be set: " + connection.id);
+      is(connection.state, "connected", "Connection state at receiver side should be connected.");
+      aResolve();
+    })
+    .catch((aError) => {
+      ok(false, "Receiver: Error occurred when getting the connection: " + aError);
+      finish();
+      aReject();
+    });
+  });
+}
+
+function testConnectionReady() {
+  return new Promise(function(aResolve, aReject) {
+    info("Receiver: --- testConnectionReady ---");
+    connection.onconnect = function() {
+      connection.onconnect = null;
+      ok(false, "Should not get |onconnect| event.");
+      aReject();
+    };
+    if (connection.state === "connected") {
+      connection.onconnect = null;
+      is(connection.state, "connected", "Receiver: Connection state should become connected.");
+      aResolve();
+    }
+  });
+}
+
+function testIncomingMessage() {
+  return new Promise(function(aResolve, aReject) {
+    info("Receiver: --- testIncomingMessage ---");
+    connection.addEventListener("message", function(evt) {
+      let msg = evt.data;
+      is(msg, "msg-sender-to-receiver", "Receiver: Receiver should receive message from sender.");
+      command("forward-command", JSON.stringify({ name: "message-from-sender-received" }));
+      aResolve();
+    }, {once: true});
+    command("forward-command", JSON.stringify({ name: "trigger-message-from-sender" }));
+  });
+}
+
+function testSendMessage() {
+  return new Promise(function(aResolve, aReject) {
+    window.addEventListener("hashchange", function hashchangeHandler(evt) {
+      var message = JSON.parse(decodeURIComponent(window.location.hash.substring(1)));
+      if (message.type === "trigger-message-from-receiver") {
+        info("Receiver: --- testSendMessage ---");
+        connection.send("msg-receiver-to-sender");
+      }
+      if (message.type === "message-from-receiver-received") {
+        window.removeEventListener("hashchange", hashchangeHandler);
+        aResolve();
+      }
+    });
+  });
+}
+
+function testIncomingBlobMessage() {
+  return new Promise(function(aResolve, aReject) {
+    info("Receiver: --- testIncomingBlobMessage ---");
+    connection.send("testIncomingBlobMessage");
+    connection.addEventListener("message", function(evt) {
+      let recvData = String.fromCharCode.apply(null, new Uint8Array(evt.data));
+      is(recvData, "Hello World", "expected same string data");
+      aResolve();
+    }, {once: true});
+  });
+}
+
+function testConnectionClosed() {
+  return new Promise(function(aResolve, aReject) {
+    info("Receiver: --- testConnectionClosed ---");
+    connection.onclose = function() {
+      connection.onclose = null;
+      is(connection.state, "closed", "Receiver: Connection should be closed.");
+      command("forward-command", JSON.stringify({ name: "receiver-closed" }));
+      aResolve();
+    };
+    command("forward-command", JSON.stringify({ name: "ready-to-close" }));
+  });
+}
+
+function testReconnectConnection() {
+  return new Promise(function(aResolve, aReject) {
+    info("Receiver: --- testReconnectConnection ---");
+    window.addEventListener("hashchange", function hashchangeHandler(evt) {
+      var message = JSON.parse(decodeURIComponent(window.location.hash.substring(1)));
+      if (message.type === "prepare-for-reconnect") {
+        command("forward-command", JSON.stringify({ name: "ready-to-reconnect" }));
+      }
+    });
+    connection.onconnect = function() {
+      connection.onconnect = null;
+      ok(true, "The connection is reconnected.");
+      aResolve();
+    };
+  });
+}
+
+function testIncomingArrayBuffer() {
+  return new Promise(function(aResolve, aReject) {
+    info("Receiver: --- testIncomingArrayBuffer ---");
+    connection.binaryType = "blob";
+    connection.send("testIncomingArrayBuffer");
+    connection.addEventListener("message", function(evt) {
+      var fileReader = new FileReader();
+      fileReader.onload = function() {
+        ok(is_same_buffer(DATA_ARRAY_BUFFER, this.result), "expected same buffer data");
+        aResolve();
+      };
+      fileReader.readAsArrayBuffer(evt.data);
+    }, {once: true});
+  });
+}
+
+function testIncomingArrayBufferView() {
+  return new Promise(function(aResolve, aReject) {
+    info("Receiver: --- testIncomingArrayBufferView ---");
+    connection.binaryType = "arraybuffer";
+    connection.send("testIncomingArrayBufferView");
+    connection.addEventListener("message", function(evt) {
+      ok(is_same_buffer(evt.data, TYPED_DATA_ARRAY), "expected same buffer data");
+      aResolve();
+    }, {once: true});
+  });
+}
+
+function runTests() {
+  testConnectionAvailable()
+  .then(testConnectionReady)
+  .then(testIncomingMessage)
+  .then(testSendMessage)
+  .then(testIncomingBlobMessage)
+  .then(testConnectionClosed)
+  .then(testReconnectConnection)
+  .then(testIncomingArrayBuffer)
+  .then(testIncomingArrayBufferView)
+  .then(testConnectionClosed);
+}
+
+runTests();
+
+</script>
+  </body>
+</html>
diff --git a/dom/presentation/tests/mochitest/file_presentation_1ua_wentaway.html b/dom/presentation/tests/mochitest/file_presentation_1ua_wentaway.html
new file mode 100644
index 0000000000..5198e76be8
--- /dev/null
+++ b/dom/presentation/tests/mochitest/file_presentation_1ua_wentaway.html
@@ -0,0 +1,95 @@
+<!DOCTYPE HTML>
+<!-- vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: -->
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>Test for B2G PresentationReceiver at receiver side</title>
+  </head>
+  <body>
+    <div id="content"></div>
+<script type="application/javascript">
+
+"use strict";
+
+function is(a, b, msg) {
+  if (a === b) {
+    alert("OK " + msg);
+  } else {
+    alert("KO " + msg + " | reason: " + a + " != " + b);
+  }
+}
+
+function ok(a, msg) {
+  alert((a ? "OK " : "KO ") + msg);
+}
+
+function info(msg) {
+  alert("INFO " + msg);
+}
+
+function command(name, data) {
+  alert("COMMAND " + JSON.stringify({name, data}));
+}
+
+function finish() {
+  alert("DONE");
+}
+
+var connection;
+
+function testConnectionAvailable() {
+  return new Promise(function(aResolve, aReject) {
+    info("Receiver: --- testConnectionAvailable ---");
+    ok(navigator.presentation, "Receiver: navigator.presentation should be available.");
+    ok(navigator.presentation.receiver, "Receiver: navigator.presentation.receiver should be available.");
+
+    navigator.presentation.receiver.connectionList
+    .then((aList) => {
+      is(aList.connections.length, 1, "Should get one conncetion.");
+      connection = aList.connections[0];
+      ok(connection.id, "Connection ID should be set: " + connection.id);
+      is(connection.state, "connected", "Connection state at receiver side should be connected.");
+      aResolve();
+    })
+    .catch((aError) => {
+      ok(false, "Receiver: Error occurred when getting the connection: " + aError);
+      finish();
+      aReject();
+    });
+  });
+}
+
+function testConnectionReady() {
+  return new Promise(function(aResolve, aReject) {
+    info("Receiver: --- testConnectionReady ---");
+    connection.onconnect = function() {
+      connection.onconnect = null;
+      ok(false, "Should not get |onconnect| event.");
+      aReject();
+    };
+    if (connection.state === "connected") {
+      connection.onconnect = null;
+      is(connection.state, "connected", "Receiver: Connection state should become connected.");
+      aResolve();
+    }
+  });
+}
+
+function testConnectionWentaway() {
+  return new Promise(function(aResolve, aReject) {
+    info("Receiver: --- testConnectionWentaway ---\n");
+    command("forward-command", JSON.stringify({ name: "ready-to-remove-receiverFrame" }));
+  });
+}
+
+function runTests() {
+  testConnectionAvailable()
+  .then(testConnectionReady)
+  .then(testConnectionWentaway);
+}
+
+runTests();
+
+</script>
+  </body>
+</html>
diff --git a/dom/presentation/tests/mochitest/file_presentation_fingerprinting_resistance_receiver.html b/dom/presentation/tests/mochitest/file_presentation_fingerprinting_resistance_receiver.html
new file mode 100644
index 0000000000..5fd1967331
--- /dev/null
+++ b/dom/presentation/tests/mochitest/file_presentation_fingerprinting_resistance_receiver.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<script>
+function testReceiver() {
+  alert(!!navigator.presentation.receiver);
+}
+
+testReceiver();
+window.addEventListener("hashchange", testReceiver);
+</script>
diff --git a/dom/presentation/tests/mochitest/file_presentation_mixed_security_contexts.html b/dom/presentation/tests/mochitest/file_presentation_mixed_security_contexts.html
new file mode 100644
index 0000000000..d31b3578b2
--- /dev/null
+++ b/dom/presentation/tests/mochitest/file_presentation_mixed_security_contexts.html
@@ -0,0 +1,158 @@
+
+<!DOCTYPE HTML>
+<html>
+<head>
+<meta charset="utf-8">
+<title>Test allow-presentation sandboxing flag</title>
+<script type="application/javascript">
+
+"use strict";
+
+function is(a, b, msg) {
+  window.parent.postMessage((a === b ? "OK " : "KO ") + msg, "*");
+}
+
+function ok(a, msg) {
+  window.parent.postMessage((a ? "OK " : "KO ") + msg, "*");
+}
+
+function info(msg) {
+  window.parent.postMessage("INFO " + msg, "*");
+}
+
+function command(msg) {
+  window.parent.postMessage("COMMAND " + JSON.stringify(msg), "*");
+}
+
+function finish() {
+  window.parent.postMessage("DONE", "*");
+}
+
+function testGetAvailability() {
+  return new Promise(function(aResolve, aReject) {
+    ok(navigator.presentation, "navigator.presentation should be available.");
+    var request = new PresentationRequest("http://example.com");
+
+    request.getAvailability().then(
+      function(aAvailability) {
+        ok(false, "Unexpected success, should get a security error.");
+        aReject();
+      },
+      function(aError) {
+        is(aError.name, "SecurityError", "Should get a security error.");
+        aResolve();
+      }
+    );
+  });
+}
+
+function testStartRequest() {
+  return new Promise(function(aResolve, aReject) {
+    var request = new PresentationRequest("http://example.com");
+
+    request.start().then(
+      function(aAvailability) {
+        ok(false, "Unexpected success, should get a security error.");
+        aReject();
+      },
+      function(aError) {
+        is(aError.name, "SecurityError", "Should get a security error.");
+        aResolve();
+      }
+    );
+  });
+}
+
+function testReconnectRequest() {
+  return new Promise(function(aResolve, aReject) {
+    var request = new PresentationRequest("http://example.com");
+
+    request.reconnect("dummyId").then(
+      function(aConnection) {
+        ok(false, "Unexpected success, should get a security error.");
+        aReject();
+      },
+      function(aError) {
+        is(aError.name, "SecurityError", "Should get a security error.");
+        aResolve();
+      }
+    );
+  });
+}
+
+function testGetAvailabilityForAboutBlank() {
+  return new Promise(function(aResolve, aReject) {
+    var request = new PresentationRequest("about:blank");
+
+    request.getAvailability().then(
+      function(aAvailability) {
+        ok(true, "Success due to a priori authenticated URL.");
+        aResolve();
+      },
+      function(aError) {
+        ok(false, "Error occurred when getting availability: " + aError);
+        aReject();
+      }
+    );
+  });
+}
+
+function testGetAvailabilityForAboutSrcdoc() {
+  return new Promise(function(aResolve, aReject) {
+    var request = new PresentationRequest("about:srcdoc");
+
+    request.getAvailability().then(
+      function(aAvailability) {
+        ok(true, "Success due to a priori authenticated URL.");
+        aResolve();
+      },
+      function(aError) {
+        ok(false, "Error occurred when getting availability: " + aError);
+        aReject();
+      }
+    );
+  });
+}
+
+function testGetAvailabilityForDataURL() {
+  return new Promise(function(aResolve, aReject) {
+    var request = new PresentationRequest("data:text/html,1");
+
+    request.getAvailability().then(
+      function(aAvailability) {
+        ok(true, "Success due to a priori authenticated URL.");
+        aResolve();
+      },
+      function(aError) {
+        ok(false, "Error occurred when getting availability: " + aError);
+        aReject();
+      }
+    );
+  });
+}
+
+function runTest() {
+  testGetAvailability()
+  .then(testStartRequest)
+  .then(testReconnectRequest)
+  .then(testGetAvailabilityForAboutBlank)
+  .then(testGetAvailabilityForAboutSrcdoc)
+  .then(testGetAvailabilityForDataURL)
+  .then(finish);
+}
+
+window.addEventListener("message", function(evt) {
+  if (evt.data === "start") {
+    runTest();
+  }
+}, {once: true});
+
+window.setTimeout(function() {
+  command("ready-to-start");
+}, 3000);
+
+</script>
+</head>
+<body>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/file_presentation_non_receiver.html b/dom/presentation/tests/mochitest/file_presentation_non_receiver.html
new file mode 100644
index 0000000000..75ffe6b4ad
--- /dev/null
+++ b/dom/presentation/tests/mochitest/file_presentation_non_receiver.html
@@ -0,0 +1,41 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Test for B2G PresentationReceiver on a non-receiver page at receiver side</title>
+</head>
+<body>
+<div id="content"></div>
+<script type="application/javascript">
+
+"use strict";
+
+function is(a, b, msg) {
+  alert((a === b ? "OK " : "KO ") + msg);
+}
+
+function ok(a, msg) {
+  alert((a ? "OK " : "KO ") + msg);
+}
+
+function info(msg) {
+  alert("INFO " + msg);
+}
+
+function finish() {
+  alert("DONE");
+}
+
+function testConnectionAvailable() {
+  return new Promise(function(aResolve, aReject) {
+    is(navigator.presentation.receiver, null, "navigator.presentation.receiver shouldn't be available in non-receiving pages.");
+    aResolve();
+  });
+}
+
+testConnectionAvailable().
+then(finish);
+
+</script>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/file_presentation_non_receiver_inner_iframe.html b/dom/presentation/tests/mochitest/file_presentation_non_receiver_inner_iframe.html
new file mode 100644
index 0000000000..c1b5c10610
--- /dev/null
+++ b/dom/presentation/tests/mochitest/file_presentation_non_receiver_inner_iframe.html
@@ -0,0 +1,26 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Test for B2G PresentationReceiver on a non-receiver inner iframe of the receiver page at receiver side</title>
+</head>
+<body onload="testConnectionAvailable()">
+<div id="content"></div>
+<script type="application/javascript">
+
+"use strict";
+
+function is(a, b, msg) {
+  alert((a === b ? "OK " : "KO ") + msg);
+}
+
+function testConnectionAvailable() {
+  return new Promise(function(aResolve, aReject) {
+    is(navigator.presentation.receiver, null, "navigator.presentation.receiver shouldn't be available in inner iframes with different origins from receiving pages.");
+    aResolve();
+  });
+}
+
+</script>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/file_presentation_receiver.html b/dom/presentation/tests/mochitest/file_presentation_receiver.html
new file mode 100644
index 0000000000..b864fb7c56
--- /dev/null
+++ b/dom/presentation/tests/mochitest/file_presentation_receiver.html
@@ -0,0 +1,139 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Test for B2G PresentationReceiver at receiver side</title>
+</head>
+<body>
+<div id="content"></div>
+<script type="application/javascript">
+
+"use strict";
+
+function is(a, b, msg) {
+  alert((a === b ? "OK " : "KO ") + msg);
+}
+
+function ok(a, msg) {
+  alert((a ? "OK " : "KO ") + msg);
+}
+
+function info(msg) {
+  alert("INFO " + msg);
+}
+
+function command(msg) {
+  alert("COMMAND " + JSON.stringify(msg));
+}
+
+function finish() {
+  alert("DONE");
+}
+
+var connection;
+
+function testConnectionAvailable() {
+  return new Promise(function(aResolve, aReject) {
+    ok(navigator.presentation, "navigator.presentation should be available in receiving pages.");
+    ok(navigator.presentation.receiver, "navigator.presentation.receiver should be available in receiving pages.");
+
+    navigator.presentation.receiver.connectionList.then(
+      function(aList) {
+        is(aList.connections.length, 1, "Should get one conncetion.");
+        connection = aList.connections[0];
+        ok(connection.id, "Connection ID should be set: " + connection.id);
+        is(connection.state, "connected", "Connection state at receiver side should be connected.");
+        aResolve();
+      },
+      function(aError) {
+        ok(false, "Error occurred when getting the connection list: " + aError);
+        finish();
+        aReject();
+      }
+    );
+    command({ name: "trigger-incoming-offer" });
+  });
+}
+
+function testDefaultRequestIsUndefined() {
+  return new Promise(function(aResolve, aReject) {
+    is(navigator.presentation.defaultRequest, undefined, "navigator.presentation.defaultRequest should not be available in receiving UA");
+    aResolve();
+  });
+}
+
+function testConnectionAvailableSameOriginInnerIframe() {
+  return new Promise(function(aResolve, aReject) {
+    var iframe = document.createElement("iframe");
+    iframe.setAttribute("src", "./file_presentation_receiver_inner_iframe.html");
+    document.body.appendChild(iframe);
+
+    aResolve();
+  });
+}
+
+function testConnectionUnavailableDiffOriginInnerIframe() {
+  return new Promise(function(aResolve, aReject) {
+    var iframe = document.createElement("iframe");
+    iframe.setAttribute("src", "http://example.com/tests/dom/presentation/tests/mochitest/file_presentation_non_receiver_inner_iframe.html");
+    document.body.appendChild(iframe);
+
+    aResolve();
+  });
+}
+
+function testConnectionListSameObject() {
+  return new Promise(function(aResolve, aReject) {
+    is(navigator.presentation.receiver.connectionList, navigator.presentation.receiver.connectionList, "The promise should be the same object.");
+    navigator.presentation.receiver.connectionList.then(
+      function(aList) {
+        is(connection, aList.connections[0], "The connection from list and the one from |connectionavailable| event should be the same.");
+        aResolve();
+      },
+      function(aError) {
+        ok(false, "Error occurred when getting the connection list: " + aError);
+        finish();
+        aReject();
+      }
+    );
+  });
+}
+
+function testIncomingMessage() {
+  return new Promise(function(aResolve, aReject) {
+    const incomingMessage = "test incoming message";
+
+    connection.addEventListener("message", function(aEvent) {
+      is(aEvent.data, incomingMessage, "An incoming message should be received.");
+      aResolve();
+    }, {once: true});
+
+    command({ name: "trigger-incoming-message",
+              data: incomingMessage });
+  });
+}
+
+function testCloseConnection() {
+  return new Promise(function(aResolve, aReject) {
+    connection.onclose = function() {
+      connection.onclose = null;
+      is(connection.state, "closed", "Connection should be closed.");
+      aResolve();
+    };
+
+    connection.close();
+  });
+}
+
+testConnectionAvailable().
+then(testDefaultRequestIsUndefined).
+then(testConnectionAvailableSameOriginInnerIframe).
+then(testConnectionUnavailableDiffOriginInnerIframe).
+then(testConnectionListSameObject).
+then(testIncomingMessage).
+then(testCloseConnection).
+then(finish);
+
+</script>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/file_presentation_receiver_auxiliary_navigation.html b/dom/presentation/tests/mochitest/file_presentation_receiver_auxiliary_navigation.html
new file mode 100644
index 0000000000..6bd3da1f47
--- /dev/null
+++ b/dom/presentation/tests/mochitest/file_presentation_receiver_auxiliary_navigation.html
@@ -0,0 +1,60 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Test for sandboxed auxiliary navigation flag in receiver page</title>
+</head>
+<body>
+<div id="content"></div>
+<script type="application/javascript">
+
+"use strict";
+
+function is(a, b, msg) {
+  alert((a === b ? "OK " : "KO ") + msg);
+}
+
+function ok(a, msg) {
+  alert((a ? "OK " : "KO ") + msg);
+}
+
+function info(msg) {
+  alert("INFO " + msg);
+}
+
+function command(msg) {
+  alert("COMMAND " + JSON.stringify(msg));
+}
+
+function finish() {
+  alert("DONE");
+}
+
+function testConnectionAvailable() {
+  return new Promise(function(aResolve, aReject) {
+    ok(navigator.presentation, "navigator.presentation should be available in OOP receiving pages.");
+    ok(navigator.presentation.receiver, "navigator.presentation.receiver should be available in receiving pages.");
+
+    aResolve();
+  });
+}
+
+function testOpenWindow() {
+  return new Promise(function(aResolve, aReject) {
+    try {
+      window.open("http://example.com");
+      ok(false, "receiver page should not be able to open a new window.");
+    } catch (e) {
+      ok(true, "receiver page should not be able to open a new window.");
+      aResolve();
+    }
+  });
+}
+
+testConnectionAvailable().
+then(testOpenWindow).
+then(finish);
+
+</script>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/file_presentation_receiver_establish_connection_error.html b/dom/presentation/tests/mochitest/file_presentation_receiver_establish_connection_error.html
new file mode 100644
index 0000000000..f6dd10797e
--- /dev/null
+++ b/dom/presentation/tests/mochitest/file_presentation_receiver_establish_connection_error.html
@@ -0,0 +1,79 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Test for connection establishing errors of B2G Presentation API at receiver side</title>
+</head>
+<body>
+<div id="content"></div>
+<script type="application/javascript">
+
+"use strict";
+
+function is(a, b, msg) {
+  if (a === b) {
+    alert("OK " + msg);
+  } else {
+    alert("KO " + msg + " | reason: " + a + " != " + b);
+  }
+}
+
+function ok(a, msg) {
+  alert((a ? "OK " : "KO ") + msg);
+}
+
+function info(msg) {
+  alert("INFO " + msg);
+}
+
+function command(name, data) {
+  alert("COMMAND " + JSON.stringify({name, data}));
+}
+
+function finish() {
+  alert("DONE");
+}
+
+function testConnectionAvailable() {
+  return new Promise(function(aResolve, aReject) {
+    ok(navigator.presentation, "navigator.presentation should be available.");
+    ok(navigator.presentation.receiver, "navigator.presentation.receiver should be available.");
+    aResolve();
+  });
+}
+
+function testUnexpectedControlChannelClose() {
+  // Trigger the control channel to be closed with error code.
+  command({ name: "trigger-control-channel-close", data: 0x80004004 /* NS_ERROR_ABORT */ });
+
+  return new Promise(function(aResolve, aReject) {
+    return Promise.race([
+      navigator.presentation.receiver.connectionList.then(
+        (aList) => {
+          ok(false, "Should not get a connection list.");
+          aReject();
+        },
+        (aError) => {
+          ok(false, "Error occurred when getting the connection list: " + aError);
+          aReject();
+        }
+      ),
+      new Promise(
+        () => {
+          setTimeout(() => {
+            ok(true, "Not getting a conenction list.");
+            aResolve();
+          }, 3000);
+        }
+      ),
+    ]);
+  });
+}
+
+testConnectionAvailable().
+then(testUnexpectedControlChannelClose).
+then(finish);
+
+</script>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/file_presentation_receiver_inner_iframe.html b/dom/presentation/tests/mochitest/file_presentation_receiver_inner_iframe.html
new file mode 100644
index 0000000000..dac1abac14
--- /dev/null
+++ b/dom/presentation/tests/mochitest/file_presentation_receiver_inner_iframe.html
@@ -0,0 +1,26 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Test for B2G PresentationReceiver in an inner iframe of the receiver page at receiver side</title>
+</head>
+<body onload="testConnectionAvailable()">
+<div id="content"></div>
+<script type="application/javascript">
+
+"use strict";
+
+function ok(a, msg) {
+  alert((a ? "OK " : "KO ") + msg);
+}
+
+function testConnectionAvailable() {
+  return new Promise(function(aResolve, aReject) {
+    ok(navigator.presentation.receiver, "navigator.presentation.receiver should be available in same-origin inner iframes of receiving pages.");
+    aResolve();
+  });
+}
+
+</script>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/file_presentation_reconnect.html b/dom/presentation/tests/mochitest/file_presentation_reconnect.html
new file mode 100644
index 0000000000..31d6e0aa1c
--- /dev/null
+++ b/dom/presentation/tests/mochitest/file_presentation_reconnect.html
@@ -0,0 +1,100 @@
+
+<!DOCTYPE HTML>
+<html>
+<head>
+<meta charset="utf-8">
+<title>Test allow-presentation sandboxing flag</title>
+<script type="application/javascript">
+
+"use strict";
+
+function is(a, b, msg) {
+  window.parent.postMessage((a === b ? "OK " : "KO ") + msg, "*");
+}
+
+function ok(a, msg) {
+  window.parent.postMessage((a ? "OK " : "KO ") + msg, "*");
+}
+
+function info(msg) {
+  window.parent.postMessage("INFO " + msg, "*");
+}
+
+function command(msg) {
+  window.parent.postMessage("COMMAND " + JSON.stringify(msg), "*");
+}
+
+function finish() {
+  window.parent.postMessage("DONE", "*");
+}
+
+var request;
+var connection;
+
+function testStartRequest() {
+  return new Promise(function(aResolve, aReject) {
+    ok(navigator.presentation, "navigator.presentation should be available.");
+    request = new PresentationRequest("http://example1.com");
+
+    request.start().then(
+      function(aConnection) {
+        connection = aConnection;
+        ok(connection, "Connection should be available.");
+        ok(connection.id, "Connection ID should be set.");
+        is(connection.state, "connecting", "The initial state should be connecting.");
+
+        connection.onclose = function() {
+          connection.onclose = null;
+          command({ name: "notify-connection-closed", id: connection.id });
+        };
+        connection.onconnect = function() {
+          connection.onconnect = null;
+          is(connection.state, "connected", "Connection should be connected.");
+          aResolve();
+        };
+      },
+      function(aError) {
+        ok(false, "Error occurred when establishing a connection: " + aError);
+        aReject();
+      }
+    );
+  });
+}
+
+function testCloseConnection() {
+  return new Promise(function(aResolve, aReject) {
+    if (connection.state === "closed") {
+      aResolve();
+      return;
+    }
+    connection.onclose = function() {
+      connection.onclose = null;
+      is(connection.state, "closed", "The connection should be closed.");
+      aResolve();
+    };
+
+    connection.close();
+  });
+}
+
+window.addEventListener("message", function onMessage(evt) {
+  if (evt.data === "startConnection") {
+    testStartRequest().then(
+      function() {
+        command({ name: "connection-connected", id: connection.id });
+      }
+    );
+  } else if (evt.data === "closeConnection") {
+    testCloseConnection().then(
+      function() {
+        command({ name: "connection-closed", id: connection.id });
+      }
+    );
+  }
+});
+
+</script>
+</head>
+<body>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/file_presentation_sandboxed_presentation.html b/dom/presentation/tests/mochitest/file_presentation_sandboxed_presentation.html
new file mode 100644
index 0000000000..162e4209e7
--- /dev/null
+++ b/dom/presentation/tests/mochitest/file_presentation_sandboxed_presentation.html
@@ -0,0 +1,113 @@
+
+<!DOCTYPE HTML>
+<html>
+<head>
+<meta charset="utf-8">
+<title>Test allow-presentation sandboxing flag</title>
+<script type="application/javascript">
+
+"use strict";
+
+function is(a, b, msg) {
+  window.parent.postMessage((a === b ? "OK " : "KO ") + msg, "*");
+}
+
+function ok(a, msg) {
+  window.parent.postMessage((a ? "OK " : "KO ") + msg, "*");
+}
+
+function info(msg) {
+  window.parent.postMessage("INFO " + msg, "*");
+}
+
+function command(msg) {
+  window.parent.postMessage("COMMAND " + JSON.stringify(msg), "*");
+}
+
+function finish() {
+  window.parent.postMessage("DONE", "*");
+}
+
+function testGetAvailability() {
+  return new Promise(function(aResolve, aReject) {
+    ok(navigator.presentation, "navigator.presentation should be available.");
+    var request = new PresentationRequest("http://example.com");
+
+    request.getAvailability().then(
+      function(aAvailability) {
+        ok(false, "Unexpected success, should get a security error.");
+        aReject();
+      },
+      function(aError) {
+        is(aError.name, "SecurityError", "Should get a security error.");
+        aResolve();
+      }
+    );
+  });
+}
+
+function testStartRequest() {
+  return new Promise(function(aResolve, aReject) {
+    var request = new PresentationRequest("http://example.com");
+
+    request.start().then(
+      function(aAvailability) {
+        ok(false, "Unexpected success, should get a security error.");
+        aReject();
+      },
+      function(aError) {
+        is(aError.name, "SecurityError", "Should get a security error.");
+        aResolve();
+      }
+    );
+  });
+}
+
+function testDefaultRequest() {
+  return new Promise(function(aResolve, aReject) {
+    navigator.presentation.defaultRequest = new PresentationRequest("http://example.com");
+    is(navigator.presentation.defaultRequest, null, "DefaultRequest shoud be null.");
+    aResolve();
+  });
+}
+
+function testReconnectRequest() {
+  return new Promise(function(aResolve, aReject) {
+    var request = new PresentationRequest("http://example.com");
+
+    request.reconnect("dummyId").then(
+      function(aConnection) {
+        ok(false, "Unexpected success, should get a security error.");
+        aReject();
+      },
+      function(aError) {
+        is(aError.name, "SecurityError", "Should get a security error.");
+        aResolve();
+      }
+    );
+  });
+}
+
+function runTest() {
+  testGetAvailability()
+  .then(testStartRequest)
+  .then(testDefaultRequest)
+  .then(testReconnectRequest)
+  .then(finish);
+}
+
+window.addEventListener("message", function(evt) {
+  if (evt.data === "start") {
+    runTest();
+  }
+}, {once: true});
+
+window.setTimeout(function() {
+  command("ready-to-start");
+}, 3000);
+
+</script>
+</head>
+<body>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/file_presentation_terminate.html b/dom/presentation/tests/mochitest/file_presentation_terminate.html
new file mode 100644
index 0000000000..db5972f8d1
--- /dev/null
+++ b/dom/presentation/tests/mochitest/file_presentation_terminate.html
@@ -0,0 +1,104 @@
+<!DOCTYPE HTML>
+<!-- vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: -->
+<html>
+  <head>
+    <meta charset='utf-8'>
+    <title>Test for B2G PresentationReceiver at receiver side</title>
+  </head>
+  <body>
+    <div id='content'></div>
+<script type='application/javascript'>
+
+"use strict";
+
+function is(a, b, msg) {
+  if (a === b) {
+    alert("OK " + msg);
+  } else {
+    alert("KO " + msg + " | reason: " + a + " != " + b);
+  }
+}
+
+function ok(a, msg) {
+  alert((a ? "OK " : "KO ") + msg);
+}
+
+function info(msg) {
+  alert("INFO " + msg);
+}
+
+function command(name, data) {
+  alert("COMMAND " + JSON.stringify({name, data}));
+}
+
+function finish() {
+  alert("DONE");
+}
+
+var connection;
+
+function testConnectionAvailable() {
+  return new Promise(function(aResolve, aReject) {
+    info("Receiver: --- testConnectionAvailable ---");
+    ok(navigator.presentation, "Receiver: navigator.presentation should be available.");
+    ok(navigator.presentation.receiver, "Receiver: navigator.presentation.receiver should be available.");
+
+    navigator.presentation.receiver.connectionList
+    .then((aList) => {
+      is(aList.connections.length, 1, "Should get one conncetion.");
+      connection = aList.connections[0];
+      ok(connection.id, "Connection ID should be set: " + connection.id);
+      is(connection.state, "connected", "Connection state at receiver side should be connected.");
+      aResolve();
+    })
+    .catch((aError) => {
+      ok(false, "Receiver: Error occurred when getting the connection: " + aError);
+      finish();
+      aReject();
+    });
+  });
+}
+
+function testConnectionReady() {
+  return new Promise(function(aResolve, aReject) {
+    info("Receiver: --- testConnectionReady ---");
+    connection.onconnect = function() {
+      connection.onconnect = null;
+      ok(false, "Should not get |onconnect| event.");
+      aReject();
+    };
+    if (connection.state === "connected") {
+      connection.onconnect = null;
+      is(connection.state, "connected", "Receiver: Connection state should become connected.");
+      aResolve();
+    }
+  });
+}
+
+function testConnectionTerminate() {
+  return new Promise(function(aResolve, aReject) {
+    info("Receiver: --- testConnectionTerminate ---");
+    connection.onterminate = function() {
+      connection.onterminate = null;
+      // Using window.alert at this stage will cause window.close() fail.
+      // Only trigger it if verdict fail.
+      if (connection.state !== "terminated") {
+        is(connection.state, "terminated", "Receiver: Connection should be terminated.");
+      }
+      aResolve();
+     };
+    command("forward-command", JSON.stringify({ name: "ready-to-terminate" }));
+  });
+}
+
+function runTests() {
+  testConnectionAvailable()
+  .then(testConnectionReady)
+  .then(testConnectionTerminate);
+}
+
+runTests();
+
+</script>
+  </body>
+</html>
diff --git a/dom/presentation/tests/mochitest/file_presentation_terminate_establish_connection_error.html b/dom/presentation/tests/mochitest/file_presentation_terminate_establish_connection_error.html
new file mode 100644
index 0000000000..3dfb692e88
--- /dev/null
+++ b/dom/presentation/tests/mochitest/file_presentation_terminate_establish_connection_error.html
@@ -0,0 +1,114 @@
+<!DOCTYPE HTML>
+<!-- vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: -->
+<html>
+  <head>
+    <meta charset='utf-8'>
+    <title>Test for B2G PresentationReceiver at receiver side</title>
+  </head>
+  <body>
+    <div id='content'></div>
+<script type='application/javascript'>
+
+"use strict";
+
+function is(a, b, msg) {
+  if (a === b) {
+    alert("OK " + msg);
+  } else {
+    alert("KO " + msg + " | reason: " + a + " != " + b);
+  }
+}
+
+function ok(a, msg) {
+  alert((a ? "OK " : "KO ") + msg);
+}
+
+function info(msg) {
+  alert("INFO " + msg);
+}
+
+function command(name, data) {
+  alert("COMMAND " + JSON.stringify({name, data}));
+}
+
+function finish() {
+  alert("DONE");
+}
+
+var connection;
+
+function testConnectionAvailable() {
+  return new Promise(function(aResolve, aReject) {
+    info("Receiver: --- testConnectionAvailable ---");
+    ok(navigator.presentation, "Receiver: navigator.presentation should be available.");
+    ok(navigator.presentation.receiver, "Receiver: navigator.presentation.receiver should be available.");
+
+    navigator.presentation.receiver.connectionList
+    .then((aList) => {
+      is(aList.connections.length, 1, "Should get one connection.");
+      connection = aList.connections[0];
+      ok(connection.id, "Connection ID should be set: " + connection.id);
+      is(connection.state, "connected", "Connection state at receiver side should be connected.");
+      aResolve();
+    })
+    .catch((aError) => {
+      ok(false, "Receiver: Error occurred when getting the connection: " + aError);
+      finish();
+      aReject();
+    });
+  });
+}
+
+function testConnectionReady() {
+  return new Promise(function(aResolve, aReject) {
+    info("Receiver: --- testConnectionReady ---");
+    connection.onconnect = function() {
+      connection.onconnect = null;
+      ok(false, "Should not get |onconnect| event.");
+      aReject();
+    };
+    if (connection.state === "connected") {
+      connection.onconnect = null;
+      is(connection.state, "connected", "Receiver: Connection state should become connected.");
+      aResolve();
+    }
+  });
+}
+
+function testConnectionTerminate() {
+  return new Promise(function(aResolve, aReject) {
+    info("Receiver: --- testConnectionTerminate ---");
+    connection.onterminate = function() {
+      connection.onterminate = null;
+      // Using window.alert at this stage will cause window.close() fail.
+      // Only trigger it if verdict fail.
+      if (connection.state !== "terminated") {
+        is(connection.state, "terminated", "Receiver: Connection should be terminated.");
+      }
+      aResolve();
+    };
+
+    window.addEventListener("hashchange", function hashchangeHandler(evt) {
+      var message = JSON.parse(decodeURIComponent(window.location.hash.substring(1)));
+      if (message.type === "ready-to-terminate") {
+        info("Receiver: --- ready-to-terminate ---");
+        connection.terminate();
+      }
+    });
+
+
+    command("forward-command", JSON.stringify({ name: "prepare-for-terminate" }));
+  });
+}
+
+function runTests() {
+  testConnectionAvailable()
+  .then(testConnectionReady)
+  .then(testConnectionTerminate);
+}
+
+runTests();
+
+</script>
+  </body>
+</html>
diff --git a/dom/presentation/tests/mochitest/file_presentation_unknown_content_type.test b/dom/presentation/tests/mochitest/file_presentation_unknown_content_type.test
new file mode 100644
index 0000000000..8b13789179
--- /dev/null
+++ b/dom/presentation/tests/mochitest/file_presentation_unknown_content_type.test
@@ -0,0 +1 @@
+
diff --git a/dom/presentation/tests/mochitest/file_presentation_unknown_content_type.test^headers^ b/dom/presentation/tests/mochitest/file_presentation_unknown_content_type.test^headers^
new file mode 100644
index 0000000000..fc044e3c49
--- /dev/null
+++ b/dom/presentation/tests/mochitest/file_presentation_unknown_content_type.test^headers^
@@ -0,0 +1 @@
+Content-Type: application/unknown
diff --git a/dom/presentation/tests/mochitest/mochitest.ini b/dom/presentation/tests/mochitest/mochitest.ini
new file mode 100644
index 0000000000..3ff134cc4c
--- /dev/null
+++ b/dom/presentation/tests/mochitest/mochitest.ini
@@ -0,0 +1,81 @@
+[DEFAULT]
+support-files =
+  PresentationDeviceInfoChromeScript.js
+  PresentationSessionChromeScript.js
+  PresentationSessionFrameScript.js
+  PresentationSessionChromeScript1UA.js
+  file_presentation_1ua_receiver.html
+  test_presentation_1ua_sender_and_receiver.js
+  file_presentation_non_receiver_inner_iframe.html
+  file_presentation_non_receiver.html
+  file_presentation_receiver.html
+  file_presentation_receiver_establish_connection_error.html
+  file_presentation_receiver_inner_iframe.html
+  file_presentation_1ua_wentaway.html
+  test_presentation_1ua_connection_wentaway.js
+  file_presentation_receiver_auxiliary_navigation.html
+  test_presentation_receiver_auxiliary_navigation.js
+  file_presentation_sandboxed_presentation.html
+  file_presentation_terminate.html
+  test_presentation_terminate.js
+  file_presentation_terminate_establish_connection_error.html
+  test_presentation_terminate_establish_connection_error.js
+  file_presentation_reconnect.html
+  file_presentation_unknown_content_type.test
+  file_presentation_unknown_content_type.test^headers^
+  test_presentation_tcp_receiver_establish_connection_unknown_content_type.js
+  file_presentation_mixed_security_contexts.html
+
+[test_presentation_dc_sender.html]
+skip-if = e10s # Bug 1656033
+[test_presentation_dc_receiver.html]
+skip-if = e10s # Bug 1129785
+[test_presentation_dc_receiver_oop.html]
+skip-if = e10s # Bug 1129785
+[test_presentation_1ua_sender_and_receiver_inproc.html]
+skip-if = e10s # Bug 1129785
+[test_presentation_1ua_sender_and_receiver_oop.html]
+skip-if = e10s # Bug 1129785
+[test_presentation_1ua_connection_wentaway_inproc.html]
+skip-if = e10s # Bug 1129785
+[test_presentation_1ua_connection_wentaway_oop.html]
+skip-if = e10s # Bug 1129785
+[test_presentation_tcp_sender_disconnect.html]
+skip-if = os == 'android'
+[test_presentation_tcp_sender_establish_connection_error.html]
+skip-if = os == 'android'
+[test_presentation_tcp_receiver_establish_connection_error.html]
+skip-if = (e10s || os == 'mac' || os == 'win') # Bug 1129785, Bug 1204709
+[test_presentation_tcp_receiver_establish_connection_timeout.html]
+skip-if = e10s # Bug 1129785
+[test_presentation_tcp_receiver_establish_connection_unknown_content_type_inproc.html]
+skip-if = e10s
+[test_presentation_tcp_receiver_establish_connection_unknown_content_type_oop.html]
+skip-if = e10s
+[test_presentation_tcp_receiver.html]
+skip-if = e10s # Bug 1129785
+[test_presentation_tcp_receiver_oop.html]
+skip-if = e10s # Bug 1129785
+[test_presentation_receiver_auxiliary_navigation_inproc.html]
+skip-if = e10s
+[test_presentation_receiver_auxiliary_navigation_oop.html]
+skip-if = e10s
+[test_presentation_terminate_inproc.html]
+skip-if = e10s
+[test_presentation_terminate_oop.html]
+skip-if = e10s
+[test_presentation_terminate_establish_connection_error_inproc.html]
+skip-if = e10s
+[test_presentation_terminate_establish_connection_error_oop.html]
+skip-if = e10s
+[test_presentation_sender_on_terminate_request.html]
+skip-if = os == 'android'
+[test_presentation_sandboxed_presentation.html]
+skip-if = true # bug 1315867
+[test_presentation_reconnect.html]
+[test_presentation_mixed_security_contexts.html]
+[test_presentation_availability.html]
+support-files = test_presentation_availability_iframe.html
+[test_presentation_fingerprinting_resistance.html]
+skip-if = e10s
+support-files = file_presentation_fingerprinting_resistance_receiver.html
diff --git a/dom/presentation/tests/mochitest/test_presentation_1ua_connection_wentaway.js b/dom/presentation/tests/mochitest/test_presentation_1ua_connection_wentaway.js
new file mode 100644
index 0000000000..cff2280b72
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_1ua_connection_wentaway.js
@@ -0,0 +1,241 @@
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+SimpleTest.requestFlakyTimeout("Test for guarantee not firing async event");
+
+function debug(str) {
+  // info(str);
+}
+
+var gScript = SpecialPowers.loadChromeScript(
+  SimpleTest.getTestFileURL("PresentationSessionChromeScript1UA.js")
+);
+var receiverUrl = SimpleTest.getTestFileURL(
+  "file_presentation_1ua_wentaway.html"
+);
+var request;
+var connection;
+var receiverIframe;
+
+function setup() {
+  gScript.addMessageListener("device-prompt", function devicePromptHandler() {
+    debug("Got message: device-prompt");
+    gScript.removeMessageListener("device-prompt", devicePromptHandler);
+    gScript.sendAsyncMessage("trigger-device-prompt-select");
+  });
+
+  gScript.addMessageListener(
+    "control-channel-established",
+    function controlChannelEstablishedHandler() {
+      gScript.removeMessageListener(
+        "control-channel-established",
+        controlChannelEstablishedHandler
+      );
+      gScript.sendAsyncMessage("trigger-control-channel-open");
+    }
+  );
+
+  gScript.addMessageListener("sender-launch", function senderLaunchHandler(
+    url
+  ) {
+    debug("Got message: sender-launch");
+    gScript.removeMessageListener("sender-launch", senderLaunchHandler);
+    is(url, receiverUrl, "Receiver: should receive the same url");
+    receiverIframe = document.createElement("iframe");
+    receiverIframe.setAttribute("mozbrowser", "true");
+    receiverIframe.setAttribute("mozpresentation", receiverUrl);
+    var oop = !location.pathname.includes("_inproc");
+    receiverIframe.setAttribute("remote", oop);
+
+    receiverIframe.setAttribute("src", receiverUrl);
+    receiverIframe.addEventListener(
+      "mozbrowserloadend",
+      function() {
+        info("Receiver loaded.");
+      },
+      { once: true }
+    );
+
+    // This event is triggered when the iframe calls "alert".
+    receiverIframe.addEventListener(
+      "mozbrowsershowmodalprompt",
+      function receiverListener(evt) {
+        var message = evt.detail.message;
+        if (/^OK /.exec(message)) {
+          ok(true, message.replace(/^OK /, ""));
+        } else if (/^KO /.exec(message)) {
+          ok(false, message.replace(/^KO /, ""));
+        } else if (/^INFO /.exec(message)) {
+          info(message.replace(/^INFO /, ""));
+        } else if (/^COMMAND /.exec(message)) {
+          var command = JSON.parse(message.replace(/^COMMAND /, ""));
+          gScript.sendAsyncMessage(command.name, command.data);
+        } else if (/^DONE$/.exec(message)) {
+          receiverIframe.removeEventListener(
+            "mozbrowsershowmodalprompt",
+            receiverListener
+          );
+          teardown();
+        }
+      }
+    );
+
+    var promise = new Promise(function(aResolve, aReject) {
+      document.body.appendChild(receiverIframe);
+      aResolve(receiverIframe);
+    });
+
+    var obs = SpecialPowers.Services.obs;
+    obs.notifyObservers(promise, "setup-request-promise");
+  });
+
+  gScript.addMessageListener(
+    "promise-setup-ready",
+    function promiseSetupReadyHandler() {
+      debug("Got message: promise-setup-ready");
+      gScript.removeMessageListener(
+        "promise-setup-ready",
+        promiseSetupReadyHandler
+      );
+      gScript.sendAsyncMessage("trigger-on-session-request", receiverUrl);
+    }
+  );
+
+  return Promise.resolve();
+}
+
+function testCreateRequest() {
+  return new Promise(function(aResolve, aReject) {
+    info("Sender: --- testCreateRequest ---");
+    request = new PresentationRequest(receiverUrl);
+    request
+      .getAvailability()
+      .then(aAvailability => {
+        is(
+          aAvailability.value,
+          false,
+          "Sender: should have no available device after setup"
+        );
+        aAvailability.onchange = function() {
+          aAvailability.onchange = null;
+          ok(aAvailability.value, "Sender: Device should be available.");
+          aResolve();
+        };
+
+        gScript.sendAsyncMessage("trigger-device-add");
+      })
+      .catch(aError => {
+        ok(
+          false,
+          "Sender: Error occurred when getting availability: " + aError
+        );
+        teardown();
+        aReject();
+      });
+  });
+}
+
+function testStartConnection() {
+  return new Promise(function(aResolve, aReject) {
+    request
+      .start()
+      .then(aConnection => {
+        connection = aConnection;
+        ok(connection, "Sender: Connection should be available.");
+        ok(connection.id, "Sender: Connection ID should be set.");
+        is(
+          connection.state,
+          "connecting",
+          "Sender: The initial state should be connecting."
+        );
+        connection.onconnect = function() {
+          connection.onconnect = null;
+          is(connection.state, "connected", "Connection should be connected.");
+          aResolve();
+        };
+      })
+      .catch(aError => {
+        ok(
+          false,
+          "Sender: Error occurred when establishing a connection: " + aError
+        );
+        teardown();
+        aReject();
+      });
+  });
+}
+
+function testConnectionWentaway() {
+  return new Promise(function(aResolve, aReject) {
+    info("Sender: --- testConnectionWentaway ---");
+    connection.onclose = function() {
+      connection.onclose = null;
+      is(connection.state, "closed", "Sender: Connection should be closed.");
+      receiverIframe.addEventListener(
+        "mozbrowserclose",
+        function closeHandler() {
+          ok(false, "wentaway should not trigger receiver close");
+          aResolve();
+        }
+      );
+      setTimeout(aResolve, 3000);
+    };
+    gScript.addMessageListener(
+      "ready-to-remove-receiverFrame",
+      function onReadyToRemove() {
+        gScript.removeMessageListener(
+          "ready-to-remove-receiverFrame",
+          onReadyToRemove
+        );
+        receiverIframe.src = "http://example.com";
+      }
+    );
+  });
+}
+
+function teardown() {
+  gScript.addMessageListener(
+    "teardown-complete",
+    function teardownCompleteHandler() {
+      debug("Got message: teardown-complete");
+      gScript.removeMessageListener(
+        "teardown-complete",
+        teardownCompleteHandler
+      );
+      gScript.destroy();
+      SimpleTest.finish();
+    }
+  );
+
+  gScript.sendAsyncMessage("teardown");
+}
+
+function runTests() {
+  setup()
+    .then(testCreateRequest)
+    .then(testStartConnection)
+    .then(testConnectionWentaway)
+    .then(teardown);
+}
+
+SpecialPowers.pushPermissions(
+  [
+    { type: "presentation-device-manage", allow: false, context: document },
+    { type: "browser", allow: true, context: document },
+  ],
+  () => {
+    SpecialPowers.pushPrefEnv(
+      {
+        set: [
+          ["dom.presentation.enabled", true],
+          ["dom.presentation.controller.enabled", true],
+          ["dom.presentation.receiver.enabled", true],
+          ["dom.presentation.test.enabled", true],
+          ["dom.ipc.tabs.disabled", false],
+          ["dom.presentation.test.stage", 0],
+        ],
+      },
+      runTests
+    );
+  }
+);
diff --git a/dom/presentation/tests/mochitest/test_presentation_1ua_connection_wentaway_inproc.html b/dom/presentation/tests/mochitest/test_presentation_1ua_connection_wentaway_inproc.html
new file mode 100644
index 0000000000..a75507e6d5
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_1ua_connection_wentaway_inproc.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<!-- vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: -->
+<html>
+  <!-- Any copyright is dedicated to the Public Domain.
+    - http://creativecommons.org/publicdomain/zero/1.0/ -->
+  <head>
+    <meta charset="utf-8">
+    <title>Test for B2G Presentation API when sender and receiver at the same side</title>
+    <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+    <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  </head>
+  <body>
+    <a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1258600">
+      Test for PresentationConnectionCloseEvent with wentaway reason</a>
+    <script type="application/javascript" src="test_presentation_1ua_connection_wentaway.js">
+    </script>
+  </body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_1ua_connection_wentaway_oop.html b/dom/presentation/tests/mochitest/test_presentation_1ua_connection_wentaway_oop.html
new file mode 100644
index 0000000000..a75507e6d5
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_1ua_connection_wentaway_oop.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<!-- vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: -->
+<html>
+  <!-- Any copyright is dedicated to the Public Domain.
+    - http://creativecommons.org/publicdomain/zero/1.0/ -->
+  <head>
+    <meta charset="utf-8">
+    <title>Test for B2G Presentation API when sender and receiver at the same side</title>
+    <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+    <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  </head>
+  <body>
+    <a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1258600">
+      Test for PresentationConnectionCloseEvent with wentaway reason</a>
+    <script type="application/javascript" src="test_presentation_1ua_connection_wentaway.js">
+    </script>
+  </body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_1ua_sender_and_receiver.js b/dom/presentation/tests/mochitest/test_presentation_1ua_sender_and_receiver.js
new file mode 100644
index 0000000000..73764e597b
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_1ua_sender_and_receiver.js
@@ -0,0 +1,522 @@
+/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */
+/* 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/. */
+
+"use strict";
+
+function debug(str) {
+  // info(str);
+}
+
+var gScript = SpecialPowers.loadChromeScript(
+  SimpleTest.getTestFileURL("PresentationSessionChromeScript1UA.js")
+);
+var receiverUrl = SimpleTest.getTestFileURL(
+  "file_presentation_1ua_receiver.html"
+);
+var request;
+var connection;
+var receiverIframe;
+var presentationId;
+const DATA_ARRAY = [0, 255, 254, 0, 1, 2, 3, 0, 255, 255, 254, 0];
+const DATA_ARRAY_BUFFER = new ArrayBuffer(DATA_ARRAY.length);
+const TYPED_DATA_ARRAY = new Uint8Array(DATA_ARRAY_BUFFER);
+TYPED_DATA_ARRAY.set(DATA_ARRAY);
+
+function postMessageToIframe(aType) {
+  receiverIframe.src =
+    receiverUrl + "#" + encodeURIComponent(JSON.stringify({ type: aType }));
+}
+
+function setup() {
+  gScript.addMessageListener("device-prompt", function devicePromptHandler() {
+    debug("Got message: device-prompt");
+    gScript.removeMessageListener("device-prompt", devicePromptHandler);
+    gScript.sendAsyncMessage("trigger-device-prompt-select");
+  });
+
+  gScript.addMessageListener(
+    "control-channel-established",
+    function controlChannelEstablishedHandler() {
+      gScript.removeMessageListener(
+        "control-channel-established",
+        controlChannelEstablishedHandler
+      );
+      gScript.sendAsyncMessage("trigger-control-channel-open");
+    }
+  );
+
+  gScript.addMessageListener("sender-launch", function senderLaunchHandler(
+    url
+  ) {
+    debug("Got message: sender-launch");
+    gScript.removeMessageListener("sender-launch", senderLaunchHandler);
+    is(url, receiverUrl, "Receiver: should receive the same url");
+    receiverIframe = document.createElement("iframe");
+    receiverIframe.setAttribute("src", receiverUrl);
+    receiverIframe.setAttribute("mozbrowser", "true");
+    receiverIframe.setAttribute("mozpresentation", receiverUrl);
+    var oop = !location.pathname.includes("_inproc");
+    receiverIframe.setAttribute("remote", oop);
+
+    // This event is triggered when the iframe calls "alert".
+    receiverIframe.addEventListener(
+      "mozbrowsershowmodalprompt",
+      function receiverListener(evt) {
+        var message = evt.detail.message;
+        debug("Got iframe message: " + message);
+        if (/^OK /.exec(message)) {
+          ok(true, message.replace(/^OK /, ""));
+        } else if (/^KO /.exec(message)) {
+          ok(false, message.replace(/^KO /, ""));
+        } else if (/^INFO /.exec(message)) {
+          info(message.replace(/^INFO /, ""));
+        } else if (/^COMMAND /.exec(message)) {
+          var command = JSON.parse(message.replace(/^COMMAND /, ""));
+          gScript.sendAsyncMessage(command.name, command.data);
+        } else if (/^DONE$/.exec(message)) {
+          receiverIframe.removeEventListener(
+            "mozbrowsershowmodalprompt",
+            receiverListener
+          );
+        }
+      }
+    );
+
+    var promise = new Promise(function(aResolve, aReject) {
+      document.body.appendChild(receiverIframe);
+      aResolve(receiverIframe);
+    });
+
+    var obs = SpecialPowers.Services.obs;
+    obs.notifyObservers(promise, "setup-request-promise");
+  });
+
+  gScript.addMessageListener(
+    "promise-setup-ready",
+    function promiseSetupReadyHandler() {
+      debug("Got message: promise-setup-ready");
+      gScript.removeMessageListener(
+        "promise-setup-ready",
+        promiseSetupReadyHandler
+      );
+      gScript.sendAsyncMessage("trigger-on-session-request", receiverUrl);
+    }
+  );
+
+  return Promise.resolve();
+}
+
+function testCreateRequest() {
+  return new Promise(function(aResolve, aReject) {
+    info("Sender: --- testCreateRequest ---");
+    request = new PresentationRequest("file_presentation_1ua_receiver.html");
+    request
+      .getAvailability()
+      .then(aAvailability => {
+        is(
+          aAvailability.value,
+          false,
+          "Sender: should have no available device after setup"
+        );
+        aAvailability.onchange = function() {
+          aAvailability.onchange = null;
+          ok(aAvailability.value, "Sender: Device should be available.");
+          aResolve();
+        };
+
+        gScript.sendAsyncMessage("trigger-device-add");
+      })
+      .catch(aError => {
+        ok(
+          false,
+          "Sender: Error occurred when getting availability: " + aError
+        );
+        teardown();
+        aReject();
+      });
+  });
+}
+
+function testStartConnection() {
+  return new Promise(function(aResolve, aReject) {
+    request
+      .start()
+      .then(aConnection => {
+        connection = aConnection;
+        ok(connection, "Sender: Connection should be available.");
+        ok(connection.id, "Sender: Connection ID should be set.");
+        is(
+          connection.state,
+          "connecting",
+          "The initial state should be connecting."
+        );
+        is(
+          connection.url,
+          receiverUrl,
+          "request URL should be expanded to absolute URL"
+        );
+        connection.onconnect = function() {
+          connection.onconnect = null;
+          is(connection.state, "connected", "Connection should be connected.");
+          presentationId = connection.id;
+          aResolve();
+        };
+      })
+      .catch(aError => {
+        ok(
+          false,
+          "Sender: Error occurred when establishing a connection: " + aError
+        );
+        teardown();
+        aReject();
+      });
+
+    let request2 = new PresentationRequest("/");
+    request2
+      .start()
+      .then(() => {
+        ok(
+          false,
+          "Sender: session start should fail while there is an unsettled promise."
+        );
+      })
+      .catch(aError => {
+        is(aError.name, "OperationError", "Expect to get OperationError.");
+      });
+  });
+}
+
+function testSendMessage() {
+  return new Promise(function(aResolve, aReject) {
+    info("Sender: --- testSendMessage ---");
+    gScript.addMessageListener(
+      "trigger-message-from-sender",
+      function triggerMessageFromSenderHandler() {
+        debug("Got message: trigger-message-from-sender");
+        gScript.removeMessageListener(
+          "trigger-message-from-sender",
+          triggerMessageFromSenderHandler
+        );
+        info("Send message to receiver");
+        connection.send("msg-sender-to-receiver");
+      }
+    );
+
+    gScript.addMessageListener(
+      "message-from-sender-received",
+      function messageFromSenderReceivedHandler() {
+        debug("Got message: message-from-sender-received");
+        gScript.removeMessageListener(
+          "message-from-sender-received",
+          messageFromSenderReceivedHandler
+        );
+        aResolve();
+      }
+    );
+  });
+}
+
+function testIncomingMessage() {
+  return new Promise(function(aResolve, aReject) {
+    info("Sender: --- testIncomingMessage ---");
+    connection.addEventListener(
+      "message",
+      function(evt) {
+        let msg = evt.data;
+        is(
+          msg,
+          "msg-receiver-to-sender",
+          "Sender: Sender should receive message from Receiver"
+        );
+        postMessageToIframe("message-from-receiver-received");
+        aResolve();
+      },
+      { once: true }
+    );
+    postMessageToIframe("trigger-message-from-receiver");
+  });
+}
+
+function testSendBlobMessage() {
+  return new Promise(function(aResolve, aReject) {
+    info("Sender: --- testSendBlobMessage ---");
+    connection.addEventListener(
+      "message",
+      function(evt) {
+        let msg = evt.data;
+        is(
+          msg,
+          "testIncomingBlobMessage",
+          "Sender: Sender should receive message from Receiver"
+        );
+        let blob = new Blob(["Hello World"], { type: "text/plain" });
+        connection.send(blob);
+        aResolve();
+      },
+      { once: true }
+    );
+  });
+}
+
+function testSendArrayBuffer() {
+  return new Promise(function(aResolve, aReject) {
+    info("Sender: --- testSendArrayBuffer ---");
+    connection.addEventListener(
+      "message",
+      function(evt) {
+        let msg = evt.data;
+        is(
+          msg,
+          "testIncomingArrayBuffer",
+          "Sender: Sender should receive message from Receiver"
+        );
+        connection.send(DATA_ARRAY_BUFFER);
+        aResolve();
+      },
+      { once: true }
+    );
+  });
+}
+
+function testSendArrayBufferView() {
+  return new Promise(function(aResolve, aReject) {
+    info("Sender: --- testSendArrayBufferView ---");
+    connection.addEventListener(
+      "message",
+      function(evt) {
+        let msg = evt.data;
+        is(
+          msg,
+          "testIncomingArrayBufferView",
+          "Sender: Sender should receive message from Receiver"
+        );
+        connection.send(TYPED_DATA_ARRAY);
+        aResolve();
+      },
+      { once: true }
+    );
+  });
+}
+
+function testCloseConnection() {
+  info("Sender: --- testCloseConnection ---");
+  // Test terminate immediate after close.
+  function controlChannelEstablishedHandler() {
+    gScript.removeMessageListener(
+      "control-channel-established",
+      controlChannelEstablishedHandler
+    );
+    ok(false, "terminate after close should do nothing");
+  }
+  gScript.addMessageListener("ready-to-close", function onReadyToClose() {
+    gScript.removeMessageListener("ready-to-close", onReadyToClose);
+    connection.close();
+
+    gScript.addMessageListener(
+      "control-channel-established",
+      controlChannelEstablishedHandler
+    );
+    connection.terminate();
+  });
+
+  return Promise.all([
+    new Promise(function(aResolve, aReject) {
+      connection.onclose = function() {
+        connection.onclose = null;
+        is(connection.state, "closed", "Sender: Connection should be closed.");
+        gScript.removeMessageListener(
+          "control-channel-established",
+          controlChannelEstablishedHandler
+        );
+        aResolve();
+      };
+    }),
+    new Promise(function(aResolve, aReject) {
+      let timeout = setTimeout(function() {
+        gScript.removeMessageListener(
+          "device-disconnected",
+          deviceDisconnectedHandler
+        );
+        ok(true, "terminate after close should not trigger device.disconnect");
+        aResolve();
+      }, 3000);
+
+      function deviceDisconnectedHandler() {
+        gScript.removeMessageListener(
+          "device-disconnected",
+          deviceDisconnectedHandler
+        );
+        ok(false, "terminate after close should not trigger device.disconnect");
+        clearTimeout(timeout);
+        aResolve();
+      }
+
+      gScript.addMessageListener(
+        "device-disconnected",
+        deviceDisconnectedHandler
+      );
+    }),
+    new Promise(function(aResolve, aReject) {
+      gScript.addMessageListener(
+        "receiver-closed",
+        function onReceiverClosed() {
+          gScript.removeMessageListener("receiver-closed", onReceiverClosed);
+          gScript.removeMessageListener(
+            "control-channel-established",
+            controlChannelEstablishedHandler
+          );
+          aResolve();
+        }
+      );
+    }),
+  ]);
+}
+
+function testTerminateAfterClose() {
+  info("Sender: --- testTerminateAfterClose ---");
+  return Promise.race([
+    new Promise(function(aResolve, aReject) {
+      connection.onterminate = function() {
+        connection.onterminate = null;
+        ok(false, "terminate after close should do nothing");
+        aResolve();
+      };
+      connection.terminate();
+    }),
+    new Promise(function(aResolve, aReject) {
+      setTimeout(function() {
+        is(connection.state, "closed", "Sender: Connection should be closed.");
+        aResolve();
+      }, 3000);
+    }),
+  ]);
+}
+
+function testReconnect() {
+  return new Promise(function(aResolve, aReject) {
+    info("Sender: --- testReconnect ---");
+    gScript.addMessageListener(
+      "control-channel-established",
+      function controlChannelEstablished() {
+        gScript.removeMessageListener(
+          "control-channel-established",
+          controlChannelEstablished
+        );
+        gScript.sendAsyncMessage("trigger-control-channel-open");
+      }
+    );
+
+    gScript.addMessageListener(
+      "start-reconnect",
+      function startReconnectHandler(url) {
+        debug("Got message: start-reconnect");
+        gScript.removeMessageListener("start-reconnect", startReconnectHandler);
+        is(url, receiverUrl, "URLs should be the same.");
+        gScript.sendAsyncMessage("trigger-reconnected-acked", url);
+      }
+    );
+
+    gScript.addMessageListener(
+      "ready-to-reconnect",
+      function onReadyToReconnect() {
+        gScript.removeMessageListener("ready-to-reconnect", onReadyToReconnect);
+        request
+          .reconnect(presentationId)
+          .then(aConnection => {
+            connection = aConnection;
+            ok(connection, "Sender: Connection should be available.");
+            is(
+              connection.id,
+              presentationId,
+              "The presentationId should be the same."
+            );
+            is(
+              connection.state,
+              "connecting",
+              "The initial state should be connecting."
+            );
+            connection.onconnect = function() {
+              connection.onconnect = null;
+              is(
+                connection.state,
+                "connected",
+                "Connection should be connected."
+              );
+              aResolve();
+            };
+          })
+          .catch(aError => {
+            ok(
+              false,
+              "Sender: Error occurred when establishing a connection: " + aError
+            );
+            teardown();
+            aReject();
+          });
+      }
+    );
+
+    postMessageToIframe("prepare-for-reconnect");
+  });
+}
+
+function teardown() {
+  gScript.addMessageListener(
+    "teardown-complete",
+    function teardownCompleteHandler() {
+      debug("Got message: teardown-complete");
+      gScript.removeMessageListener(
+        "teardown-complete",
+        teardownCompleteHandler
+      );
+      gScript.destroy();
+      SimpleTest.finish();
+    }
+  );
+
+  gScript.sendAsyncMessage("teardown");
+}
+
+function runTests() {
+  setup()
+    .then(testCreateRequest)
+    .then(testStartConnection)
+    .then(testSendMessage)
+    .then(testIncomingMessage)
+    .then(testSendBlobMessage)
+    .then(testCloseConnection)
+    .then(testReconnect)
+    .then(testSendArrayBuffer)
+    .then(testSendArrayBufferView)
+    .then(testCloseConnection)
+    .then(testTerminateAfterClose)
+    .then(teardown);
+}
+
+SimpleTest.waitForExplicitFinish();
+SimpleTest.requestFlakyTimeout("Test for guarantee not firing async event");
+SpecialPowers.pushPermissions(
+  [
+    { type: "presentation-device-manage", allow: false, context: document },
+    { type: "browser", allow: true, context: document },
+  ],
+  () => {
+    SpecialPowers.pushPrefEnv(
+      {
+        set: [
+          ["dom.presentation.enabled", true],
+          /* Mocked TCP session transport builder in the test */
+          ["dom.presentation.session_transport.data_channel.enable", true],
+          ["dom.presentation.controller.enabled", true],
+          ["dom.presentation.receiver.enabled", true],
+          ["dom.presentation.test.enabled", true],
+          ["dom.presentation.test.stage", 0],
+          ["media.navigator.permission.disabled", true],
+        ],
+      },
+      runTests
+    );
+  }
+);
diff --git a/dom/presentation/tests/mochitest/test_presentation_1ua_sender_and_receiver_inproc.html b/dom/presentation/tests/mochitest/test_presentation_1ua_sender_and_receiver_inproc.html
new file mode 100644
index 0000000000..b57573fdd6
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_1ua_sender_and_receiver_inproc.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<!-- vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: -->
+<html>
+  <!-- Any copyright is dedicated to the Public Domain.
+    - http://creativecommons.org/publicdomain/zero/1.0/ -->
+  <head>
+    <meta charset="utf-8">
+    <title>Test for B2G Presentation API when sender and receiver at the same side</title>
+    <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+    <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  </head>
+  <body>
+    <a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1234492">
+      Test for B2G Presentation API when sender and receiver at the same side</a>
+    <script type="application/javascript" src="test_presentation_1ua_sender_and_receiver.js">
+    </script>
+  </body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_1ua_sender_and_receiver_oop.html b/dom/presentation/tests/mochitest/test_presentation_1ua_sender_and_receiver_oop.html
new file mode 100644
index 0000000000..28004487d5
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_1ua_sender_and_receiver_oop.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<!-- vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: -->
+<html>
+<!-- Any copyright is dedicated to the Public Domain.
+   - http://creativecommons.org/publicdomain/zero/1.0/ -->
+  <head>
+    <meta charset="utf-8">
+    <title>Test for B2G Presentation API when sender and receiver at the same side (OOP ver.)</title>
+    <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+    <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  </head>
+  <body>
+    <a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1234492">
+    Test for B2G Presentation API when sender and receiver at the same side (OOP ver.)</a>
+    <script type="application/javascript" src="test_presentation_1ua_sender_and_receiver.js">
+    </script>
+  </body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_availability.html b/dom/presentation/tests/mochitest/test_presentation_availability.html
new file mode 100644
index 0000000000..7d7a348353
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_availability.html
@@ -0,0 +1,35 @@
+<!DOCTYPE HTML>
+<html>
+<!-- Any copyright is dedicated to the Public Domain.
+   - http://creativecommons.org/publicdomain/zero/1.0/ -->
+<head>
+  <meta charset="utf-8">
+  <title>Test for PresentationAvailability</title>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1228508">Test PresentationAvailability</a>
+<script type="application/javascript">
+// This test loads in an iframe, to ensure that the navigator instance is
+// loaded with the correct value of the preference.
+SimpleTest.waitForExplicitFinish();
+SimpleTest.requestFlakyTimeout("Test for guarantee not firing async event");
+SpecialPowers.pushPermissions([
+  {type: "presentation-device-manage", allow: false, context: document},
+], function() {
+  SpecialPowers.pushPrefEnv({
+    "set": [["dom.presentation.enabled", true],
+            ["dom.presentation.controller.enabled", true],
+            ["dom.presentation.session_transport.data_channel.enable", false]]},
+    () => {
+      let iframe = document.createElement("iframe");
+      iframe.src = "test_presentation_availability_iframe.html";
+      document.body.appendChild(iframe);
+    }
+  );
+});
+
+</script>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_availability_iframe.html b/dom/presentation/tests/mochitest/test_presentation_availability_iframe.html
new file mode 100644
index 0000000000..135b3b92bc
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_availability_iframe.html
@@ -0,0 +1,227 @@
+<!DOCTYPE HTML>
+<html>
+<!-- Any copyright is dedicated to the Public Domain.
+   - http://creativecommons.org/publicdomain/zero/1.0/ -->
+<head>
+  <meta charset="utf-8">
+  <title>Test for PresentationAvailability</title>
+  <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=1228508">Test PresentationAvailability</a>
+<script type="application/javascript">
+let ok = window.parent.ok;
+let is = window.parent.is;
+let isnot = window.parent.isnot;
+let SimpleTest = window.parent.SimpleTest;
+let SpecialPowers = window.parent.SpecialPowers;
+
+"use strict";
+
+var testDevice = {
+  id: "id",
+  name: "name",
+  type: "type",
+};
+
+var gScript = SpecialPowers.loadChromeScript(SimpleTest.getTestFileURL("PresentationDeviceInfoChromeScript.js"));
+var request;
+var availability;
+
+function testSetup() {
+  return new Promise(function(aResolve, aReject) {
+    gScript.addMessageListener("setup-complete", function() {
+      aResolve();
+    });
+    gScript.sendAsyncMessage("setup");
+  });
+}
+
+function testInitialUnavailable() {
+  request = new PresentationRequest("https://example.com");
+
+  return request.getAvailability().then(async function(aAvailability) {
+    is(aAvailability.value, false, "Should have no available device after setup");
+    aAvailability.onchange = function() {
+      aAvailability.onchange = null;
+      ok(aAvailability.value, "Device should be available.");
+    };
+    availability = aAvailability;
+    await gScript.sendQuery("trigger-device-add", testDevice);
+  }).catch(function(aError) {
+    ok(false, "Error occurred when getting availability: " + aError);
+    teardown();
+  });
+}
+
+function testInitialAvailable() {
+  let anotherRequest = new PresentationRequest("https://example.net");
+  return anotherRequest.getAvailability().then(function(aAvailability) {
+    is(aAvailability.value, true, "Should have available device initially");
+    isnot(aAvailability, availability, "Should get different availability object for different request URL");
+  }).catch(function(aError) {
+    ok(false, "Error occurred when getting availability: " + aError);
+    teardown();
+  });
+}
+
+function testSameObject() {
+  let sameUrlRequest = new PresentationRequest("https://example.com");
+  return sameUrlRequest.getAvailability().then(function(aAvailability) {
+    is(aAvailability, availability, "Should get same availability object for same request URL");
+  }).catch(function(aError) {
+    ok(false, "Error occurred when getting availability: " + aError);
+    teardown();
+  });
+}
+
+function testOnChangeEvent() {
+  return new Promise(function(aResolve, aReject) {
+    availability.onchange = function() {
+      availability.onchange = null;
+      is(availability.value, false, "Should have no available device after device removed");
+      aResolve();
+    };
+    gScript.sendAsyncMessage("trigger-device-remove");
+  });
+}
+
+function testConsecutiveGetAvailability() {
+  let presRequest = new PresentationRequest("https://example.org");
+  let firstAvailabilityResolved = false;
+  return Promise.all([
+    presRequest.getAvailability().then(function() {
+      firstAvailabilityResolved = true;
+    }),
+    presRequest.getAvailability().then(function() {
+      ok(firstAvailabilityResolved, "getAvailability() should be resolved in sequence");
+    }),
+  ]).catch(function(aError) {
+    ok(false, "Error occurred when getting availability: " + aError);
+    teardown();
+  });
+}
+
+function testUnsupportedDeviceAvailability() {
+  return Promise.race([
+    new Promise(function(aResolve, aReject) {
+      let presRequest = new PresentationRequest("https://test.com");
+      presRequest.getAvailability().then(function(aAvailability) {
+        availability = aAvailability;
+        aAvailability.onchange = function() {
+          availability.onchange = null;
+          ok(false, "Should not get onchange event.");
+          teardown();
+        };
+      });
+      gScript.sendAsyncMessage("trigger-add-unsupport-url-device");
+    }),
+    new Promise(function(aResolve, aReject) {
+      setTimeout(function() {
+        ok(true, "Should not get onchange event.");
+        availability.onchange = null;
+        gScript.sendAsyncMessage("trigger-remove-unsupported-device");
+        aResolve();
+      }, 3000);
+    }),
+  ]);
+}
+
+function testMultipleAvailabilityURLs() {
+  let request1 = new PresentationRequest(["https://example.com",
+                                         "https://example1.com"]);
+  let request2 = new PresentationRequest(["https://example1.com",
+                                         "https://example2.com"]);
+  return Promise.all([
+    request1.getAvailability().then(function(aAvailability) {
+      return new Promise(function(aResolve) {
+        aAvailability.onchange = function() {
+          aAvailability.onchange = null;
+          ok(true, "Should get onchange event.");
+          aResolve();
+        };
+      });
+    }),
+    request2.getAvailability().then(function(aAvailability) {
+      return new Promise(function(aResolve) {
+        aAvailability.onchange = function() {
+          aAvailability.onchange = null;
+          ok(true, "Should get onchange event.");
+          aResolve();
+        };
+      });
+    }),
+    new Promise(function(aResolve) {
+      gScript.sendAsyncMessage("trigger-add-multiple-devices");
+      aResolve();
+    }),
+  ]).then(new Promise(function(aResolve) {
+    gScript.sendAsyncMessage("trigger-remove-multiple-devices");
+    aResolve();
+  }));
+}
+
+function testPartialSupportedDeviceAvailability() {
+  let request1 = new PresentationRequest(["https://supportedUrl.com"]);
+  let request2 = new PresentationRequest(["http://notSupportedUrl.com"]);
+
+  return Promise.all([
+    request1.getAvailability().then(function(aAvailability) {
+      return new Promise(function(aResolve) {
+        aAvailability.onchange = function() {
+          aAvailability.onchange = null;
+          ok(true, "Should get onchange event.");
+          aResolve();
+        };
+      });
+    }),
+    Promise.race([
+      request2.getAvailability().then(function(aAvailability) {
+        return new Promise(function(aResolve) {
+          aAvailability.onchange = function() {
+            aAvailability.onchange = null;
+            ok(false, "Should get onchange event.");
+            aResolve();
+          };
+        });
+      }),
+      new Promise(function(aResolve) {
+        setTimeout(function() {
+          ok(true, "Should not get onchange event.");
+          availability.onchange = null;
+          aResolve();
+        }, 3000);
+      }),
+    ]),
+    new Promise(function(aResolve) {
+      gScript.sendAsyncMessage("trigger-add-https-devices");
+      aResolve();
+    }),
+  ]).then(new Promise(function(aResolve) {
+    gScript.sendAsyncMessage("trigger-remove-https-devices");
+    aResolve();
+  }));
+}
+
+function teardown() {
+  request = null;
+  availability = null;
+  gScript.sendAsyncMessage("teardown");
+  gScript.destroy();
+  SimpleTest.finish();
+}
+
+ok(navigator.presentation, "navigator.presentation should be available.");
+testSetup().then(testInitialUnavailable)
+           .then(testInitialAvailable)
+           .then(testSameObject)
+           .then(testOnChangeEvent)
+           .then(testConsecutiveGetAvailability)
+           .then(testMultipleAvailabilityURLs)
+           .then(testUnsupportedDeviceAvailability)
+           .then(testPartialSupportedDeviceAvailability)
+           .then(teardown);
+
+</script>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_datachannel_sessiontransport.html b/dom/presentation/tests/mochitest/test_presentation_datachannel_sessiontransport.html
new file mode 100644
index 0000000000..6c0fa8f4c7
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_datachannel_sessiontransport.html
@@ -0,0 +1,243 @@
+<!DOCTYPE HTML>
+<html>
+<!-- Any copyright is dedicated to the Public Domain.
+   - http://creativecommons.org/publicdomain/zero/1.0/ -->
+<head>
+  <meta charset="utf-8">
+  <title>Test for data channel as session transport in Presentation API</title>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1148307">Test for data channel as session transport in Presentation API</a>
+<div id="content" style="display: none">
+
+</div>
+<pre id="test">
+<script class="testbody" type="text/javascript">
+
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+
+const loadingTimeoutPref = "presentation.receiver.loading.timeout";
+
+var clientBuilder;
+var serverBuilder;
+var clientTransport;
+var serverTransport;
+
+const clientMessage = "Client Message";
+const serverMessage = "Server Message";
+
+const { XPCOMUtils } = ChromeUtils.import("resource://gre/modules/XPCOMUtils.jsm");
+const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+
+var isClientReady = false;
+var isServerReady = false;
+var isClientClosed = false;
+var isServerClosed = false;
+
+var gResolve;
+var gReject;
+
+const clientCallback = {
+  QueryInterface: ChromeUtils.generateQI(["nsIPresentationSessionTransportCallback"]),
+  notifyTransportReady() {
+    info("Client transport ready.");
+
+    isClientReady = true;
+    if (isClientReady && isServerReady) {
+      gResolve();
+    }
+  },
+  notifyTransportClosed(aReason) {
+    info("Client transport is closed.");
+
+    isClientClosed = true;
+    if (isClientClosed && isServerClosed) {
+      gResolve();
+    }
+  },
+  notifyData(aData) {
+    is(aData, serverMessage, "Client transport receives data.");
+    gResolve();
+  },
+};
+
+const serverCallback = {
+  QueryInterface: ChromeUtils.generateQI(["nsIPresentationSessionTransportCallback"]),
+  notifyTransportReady() {
+    info("Server transport ready.");
+
+    isServerReady = true;
+    if (isClientReady && isServerReady) {
+      gResolve();
+    }
+  },
+  notifyTransportClosed(aReason) {
+    info("Server transport is closed.");
+
+    isServerClosed = true;
+    if (isClientClosed && isServerClosed) {
+      gResolve();
+    }
+  },
+  notifyData(aData) {
+    is(aData, clientMessage, "Server transport receives data.");
+    gResolve();
+  },
+};
+
+const clientListener = {
+  QueryInterface: ChromeUtils.generateQI(["nsIPresentationSessionTransportBuilderListener"]),
+  onSessionTransport(aTransport) {
+    info("Client Transport is built.");
+    clientTransport = aTransport;
+    clientTransport.callback = clientCallback;
+  },
+  onError(aError) {
+    ok(false, "client's builder reports error " + aError);
+  },
+  sendOffer(aOffer) {
+    setTimeout(() => this._remoteBuilder.onOffer(aOffer), 0);
+  },
+  sendAnswer(aAnswer) {
+    setTimeout(() => this._remoteBuilder.onAnswer(aAnswer), 0);
+  },
+  sendIceCandidate(aCandidate) {
+    setTimeout(() => this._remoteBuilder.onIceCandidate(aCandidate), 0);
+  },
+  disconnect(aReason) {
+    setTimeout(() => this._localBuilder.notifyDisconnected(aReason), 0);
+    setTimeout(() => this._remoteBuilder.notifyDisconnected(aReason), 0);
+  },
+  set remoteBuilder(aRemoteBuilder) {
+    this._remoteBuilder = aRemoteBuilder;
+  },
+  set localBuilder(aLocalBuilder) {
+    this._localBuilder = aLocalBuilder;
+  },
+};
+
+const serverListener = {
+  QueryInterface: ChromeUtils.generateQI(["nsIPresentationSessionTransportBuilderListener"]),
+  onSessionTransport(aTransport) {
+    info("Server Transport is built.");
+    serverTransport = aTransport;
+    serverTransport.callback = serverCallback;
+    serverTransport.enableDataNotification();
+  },
+  onError(aError) {
+    ok(false, "server's builder reports error " + aError);
+  },
+  sendOffer(aOffer) {
+    setTimeout(() => this._remoteBuilder.onOffer(aOffer), 0);
+  },
+  sendAnswer(aAnswer) {
+    setTimeout(() => this._remoteBuilder.onAnswer(aAnswer), 0);
+  },
+  sendIceCandidate(aCandidate) {
+    setTimeout(() => this._remoteBuilder.onIceCandidate(aCandidate), 0);
+  },
+  disconnect(aReason) {
+    setTimeout(() => this._localBuilder.notifyDisconnected(aReason), 0);
+    setTimeout(() => this._remoteBuilder.notifyDisconnected(aReason), 0);
+  },
+  set remoteBuilder(aRemoteBuilder) {
+    this._remoteBuilder = aRemoteBuilder;
+  },
+  set localBuilder(aLocalBuilder) {
+    this._localBuilder = aLocalBuilder;
+  },
+};
+
+function testBuilder() {
+  return new Promise(function(aResolve, aReject) {
+    gResolve = aResolve;
+    gReject = aReject;
+
+    clientBuilder = Cc["@mozilla.org/presentation/datachanneltransportbuilder;1"]
+                      .createInstance(Ci.nsIPresentationDataChannelSessionTransportBuilder);
+    serverBuilder = Cc["@mozilla.org/presentation/datachanneltransportbuilder;1"]
+                      .createInstance(Ci.nsIPresentationDataChannelSessionTransportBuilder);
+
+    clientListener.localBuilder = clientBuilder;
+    clientListener.remoteBuilder = serverBuilder;
+    serverListener.localBuilder = serverBuilder;
+    serverListener.remoteBuilder = clientBuilder;
+
+    clientBuilder
+      .buildDataChannelTransport(Ci.nsIPresentationService.ROLE_CONTROLLER,
+                                 window,
+                                 clientListener);
+
+    serverBuilder
+      .buildDataChannelTransport(Ci.nsIPresentationService.ROLE_RECEIVER,
+                                 window,
+                                 serverListener);
+  });
+}
+
+function testClientSendMessage() {
+  return new Promise(function(aResolve, aReject) {
+    info("client sends message");
+    gResolve = aResolve;
+    gReject = aReject;
+
+    clientTransport.send(clientMessage);
+  });
+}
+
+function testServerSendMessage() {
+  return new Promise(function(aResolve, aReject) {
+    info("server sends message");
+    gResolve = aResolve;
+    gReject = aReject;
+
+    serverTransport.send(serverMessage);
+    setTimeout(() => clientTransport.enableDataNotification(), 0);
+  });
+}
+
+function testCloseSessionTransport() {
+  return new Promise(function(aResolve, aReject) {
+    info("close session transport");
+    gResolve = aResolve;
+    gReject = aReject;
+
+    serverTransport.close(Cr.NS_OK);
+  });
+}
+
+function finish() {
+  info("test finished, teardown");
+  Services.prefs.clearUserPref(loadingTimeoutPref);
+
+  SimpleTest.finish();
+}
+
+function error(aError) {
+  ok(false, "report Error " + aError.name + ":" + aError.message);
+  gReject();
+}
+
+function runTests() {
+  Services.prefs.setIntPref(loadingTimeoutPref, 30000);
+
+  testBuilder()
+  .then(testClientSendMessage)
+  .then(testServerSendMessage)
+  .then(testCloseSessionTransport)
+  .then(finish)
+  .catch(error);
+}
+
+window.addEventListener("load", function() {
+  runTests();
+});
+
+</script>
+</pre>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_dc_receiver.html b/dom/presentation/tests/mochitest/test_presentation_dc_receiver.html
new file mode 100644
index 0000000000..6ea64b2843
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_dc_receiver.html
@@ -0,0 +1,138 @@
+<!DOCTYPE HTML>
+<html>
+<!-- Any copyright is dedicated to the Public Domain.
+   - http://creativecommons.org/publicdomain/zero/1.0/ -->
+<head>
+  <meta charset="utf-8">
+  <title>Test for B2G PresentationConnection API at receiver side</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=1148307">Test for B2G PresentationConnection API at receiver side</a>
+<p id="display"></p>
+<div id="content" style="display: none"></div>
+<pre id="test"></pre>
+<script type="application/javascript">
+
+"use strict";
+
+var gScript = SpecialPowers.loadChromeScript(SimpleTest.getTestFileURL("PresentationSessionChromeScript.js"));
+var receiverUrl = SimpleTest.getTestFileURL("file_presentation_receiver.html");
+
+var obs = SpecialPowers.Services.obs;
+
+function setup() {
+  return new Promise(function(aResolve, aReject) {
+    gScript.sendAsyncMessage("trigger-device-add");
+
+    var iframe = document.createElement("iframe");
+    iframe.setAttribute("src", receiverUrl);
+    iframe.setAttribute("mozbrowser", "true");
+    iframe.setAttribute("mozpresentation", receiverUrl);
+
+    // This event is triggered when the iframe calls "alert".
+    iframe.addEventListener("mozbrowsershowmodalprompt", function receiverListener(evt) {
+      var message = evt.detail.message;
+      if (/^OK /.exec(message)) {
+        ok(true, message.replace(/^OK /, ""));
+      } else if (/^KO /.exec(message)) {
+        ok(false, message.replace(/^KO /, ""));
+      } else if (/^INFO /.exec(message)) {
+        info(message.replace(/^INFO /, ""));
+      } else if (/^COMMAND /.exec(message)) {
+        var command = JSON.parse(message.replace(/^COMMAND /, ""));
+        gScript.sendAsyncMessage(command.name, command.data);
+      } else if (/^DONE$/.exec(message)) {
+        iframe.removeEventListener("mozbrowsershowmodalprompt",
+                                   receiverListener);
+        teardown();
+      }
+    });
+
+    var promise = new Promise(function(aInnerResolve, aInnerReject) {
+      document.body.appendChild(iframe);
+
+      aInnerResolve(iframe);
+    });
+    obs.notifyObservers(promise, "setup-request-promise");
+
+    gScript.addMessageListener("offer-received", function offerReceivedHandler() {
+      gScript.removeMessageListener("offer-received", offerReceivedHandler);
+      info("An offer is received.");
+    });
+
+    gScript.addMessageListener("answer-sent", function answerSentHandler(aIsValid) {
+      gScript.removeMessageListener("answer-sent", answerSentHandler);
+      ok(aIsValid, "A valid answer is sent.");
+    });
+
+    gScript.addMessageListener("control-channel-closed", function controlChannelClosedHandler(aReason) {
+      gScript.removeMessageListener("control-channel-closed", controlChannelClosedHandler);
+      is(aReason, SpecialPowers.Cr.NS_OK, "The control channel is closed normally.");
+    });
+
+    gScript.addMessageListener("check-navigator", function checknavigatorHandler(aSuccess) {
+      gScript.removeMessageListener("check-navigator", checknavigatorHandler);
+      ok(aSuccess, "buildDataChannel get correct window object");
+    });
+
+    gScript.addMessageListener("data-transport-notification-enabled", function dataTransportNotificationEnabledHandler() {
+      gScript.removeMessageListener("data-transport-notification-enabled", dataTransportNotificationEnabledHandler);
+      info("Data notification is enabled for data transport channel.");
+    });
+
+    gScript.addMessageListener("data-transport-closed", function dataTransportClosedHandler(aReason) {
+      gScript.removeMessageListener("data-transport-closed", dataTransportClosedHandler);
+      is(aReason, SpecialPowers.Cr.NS_OK, "The data transport should be closed normally.");
+    });
+
+    aResolve();
+  });
+}
+
+function testIncomingSessionRequest() {
+  return new Promise(function(aResolve, aReject) {
+    gScript.addMessageListener("receiver-launching", function launchReceiverHandler(aSessionId) {
+      gScript.removeMessageListener("receiver-launching", launchReceiverHandler);
+      info("Trying to launch receiver page.");
+
+      ok(navigator.presentation, "navigator.presentation should be available in in-process pages.");
+      is(navigator.presentation.receiver, null, "Non-receiving in-process pages shouldn't get a presentation receiver instance.");
+      aResolve();
+    });
+
+    gScript.sendAsyncMessage("trigger-incoming-session-request", receiverUrl);
+  });
+}
+
+function teardown() {
+  gScript.addMessageListener("teardown-complete", function teardownCompleteHandler() {
+    gScript.removeMessageListener("teardown-complete", teardownCompleteHandler);
+    gScript.destroy();
+    SimpleTest.finish();
+  });
+
+  gScript.sendAsyncMessage("teardown");
+}
+
+function runTests() {
+  setup().
+  then(testIncomingSessionRequest);
+}
+
+SimpleTest.waitForExplicitFinish();
+SpecialPowers.pushPermissions([
+  {type: "presentation-device-manage", allow: false, context: document},
+  {type: "browser", allow: true, context: document},
+], function() {
+  SpecialPowers.pushPrefEnv({ "set": [["dom.presentation.enabled", true],
+                                      ["dom.presentation.controller.enabled", false],
+                                      ["dom.presentation.receiver.enabled", true],
+                                      ["dom.presentation.session_transport.data_channel.enable", true]]},
+                            runTests);
+});
+
+</script>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_dc_receiver_oop.html b/dom/presentation/tests/mochitest/test_presentation_dc_receiver_oop.html
new file mode 100644
index 0000000000..f828fc44f3
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_dc_receiver_oop.html
@@ -0,0 +1,209 @@
+<!DOCTYPE HTML>
+<html>
+<!-- Any copyright is dedicated to the Public Domain.
+   - http://creativecommons.org/publicdomain/zero/1.0/ -->
+<head>
+  <meta charset="utf-8">
+  <title>Test for B2G PresentationConnection API at receiver side (OOP)</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="PresentationSessionFrameScript.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=1148307">Test B2G PresentationConnection API at receiver side (OOP)</a>
+<p id="display"></p>
+<div id="content" style="display: none"></div>
+<pre id="test"></pre>
+<script type="application/javascript">
+
+"use strict";
+
+var gScript = SpecialPowers.loadChromeScript(SimpleTest.getTestFileURL("PresentationSessionChromeScript.js"));
+var receiverUrl = SimpleTest.getTestFileURL("file_presentation_receiver.html");
+var nonReceiverUrl = SimpleTest.getTestFileURL("file_presentation_non_receiver.html");
+
+var isReceiverFinished = false;
+var isNonReceiverFinished = false;
+
+var obs = SpecialPowers.Services.obs;
+var receiverIframe;
+
+function setup() {
+  return new Promise(function(aResolve, aReject) {
+    gScript.sendAsyncMessage("trigger-device-add");
+
+    // Create a receiver OOP iframe.
+    receiverIframe = document.createElement("iframe");
+    receiverIframe.setAttribute("remote", "true");
+    receiverIframe.setAttribute("mozbrowser", "true");
+    receiverIframe.setAttribute("mozpresentation", receiverUrl);
+    receiverIframe.setAttribute("src", receiverUrl);
+
+    // This event is triggered when the iframe calls "alert".
+    receiverIframe.addEventListener("mozbrowsershowmodalprompt", function receiverListener(aEvent) {
+      var message = aEvent.detail.message;
+      if (/^OK /.exec(message)) {
+        ok(true, "Message from iframe: " + message);
+      } else if (/^KO /.exec(message)) {
+        ok(false, "Message from iframe: " + message);
+      } else if (/^INFO /.exec(message)) {
+        info("Message from iframe: " + message);
+      } else if (/^COMMAND /.exec(message)) {
+        var command = JSON.parse(message.replace(/^COMMAND /, ""));
+        if (command.name == "trigger-incoming-message") {
+          var mm = SpecialPowers.getBrowserFrameMessageManager(receiverIframe);
+          mm.sendAsyncMessage("trigger-incoming-message", {"data": command.data});
+        } else {
+          gScript.sendAsyncMessage(command.name, command.data);
+        }
+      } else if (/^DONE$/.exec(message)) {
+        ok(true, "Messaging from iframe complete.");
+        receiverIframe.removeEventListener("mozbrowsershowmodalprompt", receiverListener);
+
+        isReceiverFinished = true;
+
+        if (isNonReceiverFinished) {
+          teardown();
+        }
+      }
+    });
+
+    var promise = new Promise(function(aInnerResolve, aInnerReject) {
+      document.body.appendChild(receiverIframe);
+      receiverIframe.addEventListener("mozbrowserloadstart", function() {
+        var mm = SpecialPowers.getBrowserFrameMessageManager(receiverIframe);
+        mm.loadFrameScript("data:,(" + loadPrivilegedScriptTest.toString() + ")();", false);
+      }, {once: true});
+
+      aInnerResolve(receiverIframe);
+    });
+    obs.notifyObservers(promise, "setup-request-promise");
+
+    // Create a non-receiver OOP iframe.
+    var nonReceiverIframe = document.createElement("iframe");
+    nonReceiverIframe.setAttribute("remote", "true");
+    nonReceiverIframe.setAttribute("mozbrowser", "true");
+    nonReceiverIframe.setAttribute("src", nonReceiverUrl);
+
+    // This event is triggered when the iframe calls "alert".
+    nonReceiverIframe.addEventListener("mozbrowsershowmodalprompt", function nonReceiverListener(aEvent) {
+      var message = aEvent.detail.message;
+      if (/^OK /.exec(message)) {
+        ok(true, "Message from iframe: " + message);
+      } else if (/^KO /.exec(message)) {
+        ok(false, "Message from iframe: " + message);
+      } else if (/^INFO /.exec(message)) {
+        info("Message from iframe: " + message);
+      } else if (/^COMMAND /.exec(message)) {
+        var command = JSON.parse(message.replace(/^COMMAND /, ""));
+        gScript.sendAsyncMessage(command.name, command.data);
+      } else if (/^DONE$/.exec(message)) {
+        ok(true, "Messaging from iframe complete.");
+        nonReceiverIframe.removeEventListener("mozbrowsershowmodalprompt", nonReceiverListener);
+
+        isNonReceiverFinished = true;
+
+        if (isReceiverFinished) {
+          teardown();
+        }
+      }
+    });
+
+    document.body.appendChild(nonReceiverIframe);
+
+    gScript.addMessageListener("offer-received", function offerReceivedHandler() {
+      gScript.removeMessageListener("offer-received", offerReceivedHandler);
+      info("An offer is received.");
+    });
+
+    gScript.addMessageListener("answer-sent", function answerSentHandler(aIsValid) {
+      gScript.removeMessageListener("answer-sent", answerSentHandler);
+      ok(aIsValid, "A valid answer is sent.");
+    });
+
+    gScript.addMessageListener("control-channel-closed", function controlChannelClosedHandler(aReason) {
+      gScript.removeMessageListener("control-channel-closed", controlChannelClosedHandler);
+      is(aReason, SpecialPowers.Cr.NS_OK, "The control channel is closed normally.");
+    });
+
+    var mm = SpecialPowers.getBrowserFrameMessageManager(receiverIframe);
+    mm.addMessageListener("check-navigator", function checknavigatorHandler(aSuccess) {
+      mm.removeMessageListener("check-navigator", checknavigatorHandler);
+      ok(SpecialPowers.wrap(aSuccess).data.data, "buildDataChannel get correct window object");
+    });
+
+    mm.addMessageListener("data-transport-notification-enabled", function dataTransportNotificationEnabledHandler() {
+      mm.removeMessageListener("data-transport-notification-enabled", dataTransportNotificationEnabledHandler);
+      info("Data notification is enabled for data transport channel.");
+    });
+
+    mm.addMessageListener("data-transport-closed", function dataTransportClosedHandler(aReason) {
+      mm.removeMessageListener("data-transport-closed", dataTransportClosedHandler);
+      is(SpecialPowers.wrap(aReason).data.data, SpecialPowers.Cr.NS_OK, "The data transport should be closed normally.");
+    });
+
+    aResolve();
+  });
+}
+
+function testIncomingSessionRequest() {
+  return new Promise(function(aResolve, aReject) {
+    gScript.addMessageListener("receiver-launching", function launchReceiverHandler(aSessionId) {
+      gScript.removeMessageListener("receiver-launching", launchReceiverHandler);
+      info("Trying to launch receiver page.");
+
+      aResolve();
+    });
+
+    gScript.sendAsyncMessage("trigger-incoming-session-request", receiverUrl);
+  });
+}
+
+var mmTeardownComplete = false;
+var gScriptTeardownComplete = false;
+function teardown() {
+  var mm = SpecialPowers.getBrowserFrameMessageManager(receiverIframe);
+  mm.addMessageListener("teardown-complete", function teardownCompleteHandler() {
+    mm.removeMessageListener("teardown-complete", teardownCompleteHandler);
+    mmTeardownComplete = true;
+    if (gScriptTeardownComplete) {
+      SimpleTest.finish();
+    }
+  });
+
+  mm.sendAsyncMessage("teardown");
+
+  gScript.addMessageListener("teardown-complete", function teardownCompleteHandler() {
+    gScript.removeMessageListener("teardown-complete", teardownCompleteHandler);
+    gScript.destroy();
+    gScriptTeardownComplete = true;
+    if (mmTeardownComplete) {
+      SimpleTest.finish();
+    }
+  });
+
+  gScript.sendAsyncMessage("teardown");
+}
+
+function runTests() {
+  setup().
+  then(testIncomingSessionRequest);
+}
+
+SimpleTest.waitForExplicitFinish();
+SpecialPowers.pushPermissions([
+  {type: "presentation-device-manage", allow: false, context: document},
+  {type: "browser", allow: true, context: document},
+], function() {
+  SpecialPowers.pushPrefEnv({ "set": [["dom.presentation.enabled", true],
+                                      ["dom.presentation.controller.enabled", false],
+                                      ["dom.presentation.receiver.enabled", true],
+                                      ["dom.presentation.session_transport.data_channel.enable", true],
+                                      ["dom.ipc.browser_frames.oop_by_default", true],
+                                      ["presentation.receiver.loading.timeout", 5000000]]},
+                            runTests);
+});
+
+</script>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_dc_sender.html b/dom/presentation/tests/mochitest/test_presentation_dc_sender.html
new file mode 100644
index 0000000000..40f8b337df
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_dc_sender.html
@@ -0,0 +1,289 @@
+<!DOCTYPE HTML>
+<html>
+<!-- Any copyright is dedicated to the Public Domain.
+   - http://creativecommons.org/publicdomain/zero/1.0/ -->
+<head>
+  <meta charset="utf-8">
+  <title>Test for B2G Presentation API at sender side</title>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="PresentationSessionFrameScript.js"></script>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1148307">Test for B2G Presentation API at sender side</a>
+<script type="application/javascript">
+
+"use strict";
+
+var gScript = SpecialPowers.loadChromeScript(SimpleTest.getTestFileURL("PresentationSessionChromeScript.js"));
+var frameScript = SpecialPowers.isMainProcess() ? gScript : contentScript;
+var request;
+var connection;
+
+function testSetup() {
+  return new Promise(function(aResolve, aReject) {
+    request = new PresentationRequest("http://example.com/");
+
+    request.getAvailability().then(
+      function(aAvailability) {
+        is(aAvailability.value, false, "Sender: should have no available device after setup");
+        aAvailability.onchange = function() {
+          aAvailability.onchange = null;
+          ok(aAvailability.value, "Device should be available.");
+          aResolve();
+        };
+
+        gScript.sendAsyncMessage("trigger-device-add");
+      },
+      function(aError) {
+        ok(false, "Error occurred when getting availability: " + aError);
+        teardown();
+        aReject();
+      }
+    );
+  });
+}
+
+function testStartConnection() {
+  return new Promise(function(aResolve, aReject) {
+    gScript.addMessageListener("device-prompt", function devicePromptHandler() {
+      gScript.removeMessageListener("device-prompt", devicePromptHandler);
+      info("Device prompt is triggered.");
+      gScript.sendAsyncMessage("trigger-device-prompt-select");
+    });
+
+    gScript.addMessageListener("control-channel-established", function controlChannelEstablishedHandler() {
+      gScript.removeMessageListener("control-channel-established", controlChannelEstablishedHandler);
+      info("A control channel is established.");
+      gScript.sendAsyncMessage("trigger-control-channel-open");
+    });
+
+    gScript.addMessageListener("control-channel-opened", function controlChannelOpenedHandler(aReason) {
+      gScript.removeMessageListener("control-channel-opened", controlChannelOpenedHandler);
+      info("The control channel is opened.");
+    });
+
+    gScript.addMessageListener("control-channel-closed", function controlChannelClosedHandler(aReason) {
+      gScript.removeMessageListener("control-channel-closed", controlChannelClosedHandler);
+      info("The control channel is closed. " + aReason);
+    });
+
+    frameScript.addMessageListener("check-navigator", function checknavigatorHandler(aSuccess) {
+      frameScript.removeMessageListener("check-navigator", checknavigatorHandler);
+      ok(aSuccess, "buildDataChannel get correct window object");
+    });
+
+    gScript.addMessageListener("offer-sent", function offerSentHandler(aIsValid) {
+      gScript.removeMessageListener("offer-sent", offerSentHandler);
+      ok(aIsValid, "A valid offer is sent out.");
+      gScript.sendAsyncMessage("trigger-incoming-answer");
+    });
+
+    gScript.addMessageListener("answer-received", function answerReceivedHandler() {
+      gScript.removeMessageListener("answer-received", answerReceivedHandler);
+      info("An answer is received.");
+    });
+
+    frameScript.addMessageListener("data-transport-initialized", function dataTransportInitializedHandler() {
+      frameScript.removeMessageListener("data-transport-initialized", dataTransportInitializedHandler);
+      info("Data transport channel is initialized.");
+    });
+
+    frameScript.addMessageListener("data-transport-notification-enabled", function dataTransportNotificationEnabledHandler() {
+      frameScript.removeMessageListener("data-transport-notification-enabled", dataTransportNotificationEnabledHandler);
+      info("Data notification is enabled for data transport channel.");
+    });
+
+    var connectionFromEvent;
+    request.onconnectionavailable = function(aEvent) {
+      request.onconnectionavailable = null;
+      connectionFromEvent = aEvent.connection;
+      ok(connectionFromEvent, "|connectionavailable| event is fired with a connection.");
+
+      if (connection) {
+        is(connection, connectionFromEvent, "The connection from promise and the one from |connectionavailable| event should be the same.");
+      }
+    };
+
+    request.start().then(
+      function(aConnection) {
+        connection = aConnection;
+        ok(connection, "Connection should be available.");
+        ok(connection.id, "Connection ID should be set.");
+        is(connection.state, "connecting", "The initial state should be connecting.");
+
+        if (connectionFromEvent) {
+          is(connection, connectionFromEvent, "The connection from promise and the one from |connectionavailable| event should be the same.");
+        }
+        connection.onconnect = function() {
+          connection.onconnect = null;
+          is(connection.state, "connected", "Connection should be connected.");
+          aResolve();
+        };
+      },
+      function(aError) {
+        ok(false, "Error occurred when establishing a connection: " + aError);
+        teardown();
+        aReject();
+      }
+    );
+  });
+}
+
+function testSend() {
+  return new Promise(function(aResolve, aReject) {
+    const outgoingMessage = "test outgoing message";
+
+    frameScript.addMessageListener("message-sent", function messageSentHandler(aMessage) {
+      frameScript.removeMessageListener("message-sent", messageSentHandler);
+      is(aMessage, outgoingMessage, "The message is sent out.");
+      aResolve();
+    });
+
+    connection.send(outgoingMessage);
+  });
+}
+
+function testIncomingMessage() {
+  return new Promise(function(aResolve, aReject) {
+    const incomingMessage = "test incoming message";
+
+    connection.addEventListener("message", function(aEvent) {
+      is(aEvent.data, incomingMessage, "An incoming message should be received.");
+      aResolve();
+    }, {once: true});
+
+    frameScript.sendAsyncMessage("trigger-incoming-message", incomingMessage);
+  });
+}
+
+function testCloseConnection() {
+  return new Promise(function(aResolve, aReject) {
+    frameScript.addMessageListener("data-transport-closed", function dataTransportClosedHandler(aReason) {
+      frameScript.removeMessageListener("data-transport-closed", dataTransportClosedHandler);
+      info("The data transport is closed. " + aReason);
+    });
+
+    connection.onclose = function() {
+      connection.onclose = null;
+      is(connection.state, "closed", "Connection should be closed.");
+      aResolve();
+    };
+
+    connection.close();
+  });
+}
+
+function testReconnect() {
+  return new Promise(function(aResolve, aReject) {
+    info("--- testReconnect ---");
+    gScript.addMessageListener("control-channel-established", function controlChannelEstablished() {
+      gScript.removeMessageListener("control-channel-established", controlChannelEstablished);
+      gScript.sendAsyncMessage("trigger-control-channel-open");
+    });
+
+    gScript.addMessageListener("start-reconnect", function startReconnectHandler(url) {
+      gScript.removeMessageListener("start-reconnect", startReconnectHandler);
+      is(url, "http://example.com/", "URLs should be the same.");
+      gScript.sendAsyncMessage("trigger-reconnected-acked", url);
+    });
+
+    gScript.addMessageListener("offer-sent", function offerSentHandler(aIsValid) {
+      gScript.removeMessageListener("offer-sent", offerSentHandler);
+      ok(aIsValid, "A valid offer is sent out.");
+      gScript.sendAsyncMessage("trigger-incoming-answer");
+    });
+
+    gScript.addMessageListener("answer-received", function answerReceivedHandler() {
+      gScript.removeMessageListener("answer-received", answerReceivedHandler);
+      info("An answer is received.");
+    });
+
+    frameScript.addMessageListener("check-navigator", function checknavigatorHandler(aSuccess) {
+      frameScript.removeMessageListener("check-navigator", checknavigatorHandler);
+      ok(aSuccess, "buildDataChannel get correct window object");
+    });
+
+    request.reconnect(connection.id).then(
+      function(aConnection) {
+        ok(aConnection, "Connection should be available.");
+        ok(aConnection.id, "Connection ID should be set.");
+        is(aConnection.state, "connecting", "The initial state should be connecting.");
+        is(aConnection, connection, "The reconnected connection should be the same.");
+
+        aConnection.onconnect = function() {
+          aConnection.onconnect = null;
+          is(aConnection.state, "connected", "Connection should be connected.");
+          aResolve();
+        };
+      },
+      function(aError) {
+        ok(false, "Error occurred when establishing a connection: " + aError);
+        teardown();
+        aReject();
+      }
+    );
+  });
+}
+
+function teardown() {
+  gScript.addMessageListener("teardown-complete", function teardownCompleteHandler() {
+    gScript.removeMessageListener("teardown-complete", teardownCompleteHandler);
+    gScript.destroy();
+    info("teardown-complete");
+    SimpleTest.finish();
+  });
+
+  gScript.sendAsyncMessage("teardown");
+}
+
+function testConstructRequestError() {
+  return Promise.all([
+    // XXX: Bug 1305204 - uncomment when bug 1275746 is fixed again.
+    // new Promise(function(aResolve, aReject) {
+    //   try {
+    //     request = new PresentationRequest("\\\\\\");
+    //   }
+    //   catch(e) {
+    //     is(e.name, "SyntaxError", "Expect to get SyntaxError.");
+    //     aResolve();
+    //   }
+    // }),
+    new Promise(function(aResolve, aReject) {
+      try {
+        request = new PresentationRequest([]);
+      } catch (e) {
+        is(e.name, "NotSupportedError", "Expect to get NotSupportedError.");
+        aResolve();
+      }
+    }),
+  ]);
+}
+
+function runTests() {
+  ok(window.PresentationRequest, "PresentationRequest should be available.");
+
+  testSetup().
+  then(testStartConnection).
+  then(testSend).
+  then(testIncomingMessage).
+  then(testCloseConnection).
+  then(testReconnect).
+  then(testCloseConnection).
+  then(testConstructRequestError).
+  then(teardown);
+}
+
+SimpleTest.waitForExplicitFinish();
+SpecialPowers.pushPermissions([
+  {type: "presentation-device-manage", allow: false, context: document},
+], function() {
+  SpecialPowers.pushPrefEnv({ "set": [["dom.presentation.enabled", true],
+                                      ["dom.presentation.controller.enabled", true],
+                                      ["dom.presentation.session_transport.data_channel.enable", true]]},
+                            runTests);
+});
+
+</script>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_fingerprinting_resistance.html b/dom/presentation/tests/mochitest/test_presentation_fingerprinting_resistance.html
new file mode 100644
index 0000000000..28788b1252
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_fingerprinting_resistance.html
@@ -0,0 +1,143 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<script src="/tests/SimpleTest/SimpleTest.js"></script>
+<script>
+/* global SimpleTest SpecialPowers */
+
+const gScript = SpecialPowers.loadChromeScript(SimpleTest.getTestFileURL("PresentationSessionChromeScript1UA.js"));
+const kReceiverFile = "file_presentation_fingerprinting_resistance_receiver.html";
+const kReceiverUrl = SimpleTest.getTestFileURL(kReceiverFile);
+
+let runTests = async () => {
+  await setup();
+  let request = await createRequest();
+  let iframe = await testRequestAndReceiver(request);
+  await enableResistFingerprinting();
+  await testRequestResistFingerprinting(request);
+  await testReceiverResistFingerprinting(iframe);
+  teardown();
+};
+
+let setup = async () => {
+  await SpecialPowers.pushPrefEnv({
+    set: [
+      ["dom.presentation.enabled", true],
+      ["dom.presentation.controller.enabled", true],
+      ["dom.presentation.receiver.enabled", true],
+      ["dom.presentation.test.enabled", true],
+      ["dom.presentation.test.stage", 0],
+    ],
+  });
+
+  gScript.addMessageListener("device-prompt", function devicePromptHandler() {
+    gScript.removeMessageListener("device-prompt", devicePromptHandler);
+    gScript.sendAsyncMessage("trigger-device-prompt-select");
+  });
+
+  gScript.addMessageListener("control-channel-established", function controlChannelEstablishedHandler() {
+    gScript.removeMessageListener("control-channel-established", controlChannelEstablishedHandler);
+    gScript.sendAsyncMessage("trigger-control-channel-open");
+  });
+
+  gScript.addMessageListener("promise-setup-ready", function promiseSetupReadyHandler() {
+    gScript.removeMessageListener("promise-setup-ready", promiseSetupReadyHandler);
+    gScript.sendAsyncMessage("trigger-on-session-request", kReceiverUrl);
+  });
+};
+
+let createRequest = () => new Promise((resolve, reject) => {
+  let request = new PresentationRequest(kReceiverFile);
+  request.getAvailability().then((availability) => {
+    SimpleTest.ok(availability, "PresentationRequest.getAvailability");
+    availability.onchange = () => {
+      availability.onchange = null;
+      resolve(request);
+    };
+    gScript.sendAsyncMessage("trigger-device-add");
+  }).catch((error) => {
+    SimpleTest.ok(false, "PresentationRequest.getAvailability: " + error);
+    teardown();
+    reject(error);
+  });
+});
+
+let testRequestAndReceiver = (request) => new Promise((resolve, reject) => {
+  gScript.addMessageListener("sender-launch", function senderLaunchHandler(url) {
+    // SimpleTest.is(url, kReceiverUrl, 'sender-launch');
+    gScript.removeMessageListener("sender-launch", senderLaunchHandler);
+
+    let iframe = document.createElement("iframe");
+    iframe.setAttribute("src", kReceiverUrl);
+    iframe.setAttribute("mozbrowser", "true");
+    iframe.setAttribute("mozpresentation", kReceiverUrl);
+    iframe.setAttribute("remote", "false");
+    iframe.addEventListener("mozbrowsershowmodalprompt", (event) => {
+      SimpleTest.is(event.detail.message, "true", "navigator.presentation.receiver");
+      resolve(iframe);
+    }, {once: true});
+
+    let promise = new Promise((aInnerResolve) => {
+      document.body.appendChild(iframe);
+      aInnerResolve(iframe);
+    });
+
+    let obs = SpecialPowers.Services.obs;
+    obs.notifyObservers(promise, "setup-request-promise");
+  });
+
+  request.start().then((connection) => {
+    SimpleTest.ok(connection, "PresentationRequest.start");
+  }).catch((error) => {
+    SimpleTest.ok(false, "PresentationRequest.start: " + error);
+    teardown();
+    reject(error);
+  });
+});
+
+let enableResistFingerprinting = () => {
+  const kPref = "privacy.resistFingerprinting";
+  SimpleTest.info(kPref + " = true");
+  return SpecialPowers.pushPrefEnv({
+    set: [
+      [kPref, true],
+    ],
+  });
+};
+
+let testRequestResistFingerprinting = (request) => {
+  return request.getAvailability()
+      .then(() => SimpleTest.ok(false, "PresentationRequest.getAvailability"))
+      .catch((error) => SimpleTest.is(error.name, "SecurityError", "PresentationRequest.getAvailability"))
+      .then(() => request.start())
+      .then(() => SimpleTest.ok(false, "PresentationRequest.start"))
+      .catch((error) => SimpleTest.is(error.name, "SecurityError", "PresentationRequest.start"))
+      .then(() => request.reconnect(kReceiverUrl))
+      .then(() => SimpleTest.ok(false, "PresentationRequest.reconnect"))
+      .catch((error) => SimpleTest.is(error.name, "SecurityError", "PresentationRequest.reconnect"));
+};
+
+let testReceiverResistFingerprinting = (iframe) => new Promise((resolve) => {
+  iframe.addEventListener("mozbrowsershowmodalprompt", (event) => {
+    SimpleTest.is(event.detail.message, "false", "navigator.presentation.receiver");
+    resolve();
+  }, {once: true});
+  iframe.setAttribute("src", kReceiverUrl + "#privacy.resistFingerprinting");
+});
+
+let teardown = () => {
+  gScript.addMessageListener("teardown-complete", function teardownCompleteHandler() {
+    gScript.destroy();
+    SimpleTest.finish();
+  });
+
+  gScript.sendAsyncMessage("teardown");
+};
+
+SimpleTest.waitForExplicitFinish();
+document.addEventListener("DOMContentLoaded", () => {
+  SpecialPowers.pushPermissions([
+    {type: "presentation-device-manage", allow: false, context: document},
+    {type: "browser", allow: true, context: document},
+  ], runTests);
+});
+</script>
diff --git a/dom/presentation/tests/mochitest/test_presentation_mixed_security_contexts.html b/dom/presentation/tests/mochitest/test_presentation_mixed_security_contexts.html
new file mode 100644
index 0000000000..4ad4aa99ad
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_mixed_security_contexts.html
@@ -0,0 +1,80 @@
+<!DOCTYPE HTML>
+<html>
+<!-- Any copyright is dedicated to the Public Domain.
+   - http://creativecommons.org/publicdomain/zero/1.0/ -->
+<head>
+  <meta charset="utf-8">
+  <title>Test default request for B2G Presentation API at sender side</title>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1268758">Test allow-presentation sandboxing flag</a>
+<iframe id="iframe" src="https://example.com/tests/dom/presentation/tests/mochitest/file_presentation_mixed_security_contexts.html"></iframe>
+<script type="application/javascript">
+
+"use strict";
+
+var iframe = document.getElementById("iframe");
+var readyToStart = false;
+var testSetuped = false;
+
+function setup() {
+  SpecialPowers.addPermission("presentation",
+                              true, { url: "https://example.com/tests/dom/presentation/tests/mochitest/file_presentation_mixed_security_contexts.html",
+                                      originAttributes: {
+                                        inIsolatedMozBrowser: false }});
+
+  return new Promise(function(aResolve, aReject) {
+    addEventListener("message", function listener(event) {
+      var message = event.data;
+      if (/^OK /.exec(message)) {
+        ok(true, message.replace(/^OK /, ""));
+      } else if (/^KO /.exec(message)) {
+        ok(false, message.replace(/^KO /, ""));
+      } else if (/^INFO /.exec(message)) {
+        info(message.replace(/^INFO /, ""));
+      } else if (/^COMMAND /.exec(message)) {
+        var command = JSON.parse(message.replace(/^COMMAND /, ""));
+        if (command === "ready-to-start") {
+          readyToStart = true;
+          startTest();
+        }
+      } else if (/^DONE$/.exec(message)) {
+        window.removeEventListener("message", listener);
+        SimpleTest.finish();
+      }
+    }, false);
+
+    testSetuped = true;
+    aResolve();
+  });
+}
+
+iframe.onload = startTest();
+
+function startTest() {
+  if (!(testSetuped && readyToStart)) {
+    return;
+  }
+  iframe.contentWindow.postMessage("start", "*");
+}
+
+function runTests() {
+  ok(navigator.presentation, "navigator.presentation should be available.");
+  setup().then(startTest);
+}
+
+SimpleTest.waitForExplicitFinish();
+SpecialPowers.pushPermissions([
+  {type: "presentation-device-manage", allow: false, context: document},
+], function() {
+  SpecialPowers.pushPrefEnv({ "set": [["dom.presentation.enabled", true],
+                                      ["dom.presentation.controller.enabled", true],
+                                      ["dom.presentation.session_transport.data_channel.enable", false]]},
+                            runTests);
+});
+
+</script>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_receiver_auxiliary_navigation.js b/dom/presentation/tests/mochitest/test_presentation_receiver_auxiliary_navigation.js
new file mode 100644
index 0000000000..c6a23881e2
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_receiver_auxiliary_navigation.js
@@ -0,0 +1,91 @@
+"use strict";
+
+var gScript = SpecialPowers.loadChromeScript(
+  SimpleTest.getTestFileURL("PresentationSessionChromeScript.js")
+);
+var receiverUrl = SimpleTest.getTestFileURL(
+  "file_presentation_receiver_auxiliary_navigation.html"
+);
+
+var obs = SpecialPowers.Services.obs;
+
+function setup() {
+  gScript.sendAsyncMessage("trigger-device-add");
+
+  var iframe = document.createElement("iframe");
+  iframe.setAttribute("mozbrowser", "true");
+  iframe.setAttribute("mozpresentation", receiverUrl);
+  var oop = !location.pathname.includes("_inproc");
+  iframe.setAttribute("remote", oop);
+  iframe.setAttribute("src", receiverUrl);
+
+  // This event is triggered when the iframe calls "postMessage".
+  iframe.addEventListener("mozbrowsershowmodalprompt", function listener(
+    aEvent
+  ) {
+    var message = aEvent.detail.message;
+    if (/^OK /.exec(message)) {
+      ok(true, "Message from iframe: " + message);
+    } else if (/^KO /.exec(message)) {
+      ok(false, "Message from iframe: " + message);
+    } else if (/^INFO /.exec(message)) {
+      info("Message from iframe: " + message);
+    } else if (/^COMMAND /.exec(message)) {
+      var command = JSON.parse(message.replace(/^COMMAND /, ""));
+      gScript.sendAsyncMessage(command.name, command.data);
+    } else if (/^DONE$/.exec(message)) {
+      ok(true, "Messaging from iframe complete.");
+      iframe.removeEventListener("mozbrowsershowmodalprompt", listener);
+
+      teardown();
+    }
+  });
+
+  var promise = new Promise(function(aResolve, aReject) {
+    document.body.appendChild(iframe);
+
+    aResolve(iframe);
+  });
+  obs.notifyObservers(promise, "setup-request-promise");
+}
+
+function teardown() {
+  gScript.addMessageListener(
+    "teardown-complete",
+    function teardownCompleteHandler() {
+      gScript.removeMessageListener(
+        "teardown-complete",
+        teardownCompleteHandler
+      );
+      gScript.destroy();
+      SimpleTest.finish();
+    }
+  );
+
+  gScript.sendAsyncMessage("teardown");
+}
+
+function runTests() {
+  setup();
+}
+
+SimpleTest.waitForExplicitFinish();
+SpecialPowers.pushPermissions(
+  [
+    { type: "presentation-device-manage", allow: false, context: document },
+    { type: "browser", allow: true, context: document },
+  ],
+  function() {
+    SpecialPowers.pushPrefEnv(
+      {
+        set: [
+          ["dom.presentation.enabled", true],
+          ["dom.presentation.controller.enabled", true],
+          ["dom.presentation.receiver.enabled", true],
+          ["dom.presentation.session_transport.data_channel.enable", false],
+        ],
+      },
+      runTests
+    );
+  }
+);
diff --git a/dom/presentation/tests/mochitest/test_presentation_receiver_auxiliary_navigation_inproc.html b/dom/presentation/tests/mochitest/test_presentation_receiver_auxiliary_navigation_inproc.html
new file mode 100644
index 0000000000..31be5be5ee
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_receiver_auxiliary_navigation_inproc.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<!-- vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: -->
+<html>
+  <!-- Any copyright is dedicated to the Public Domain.
+    - http://creativecommons.org/publicdomain/zero/1.0/ -->
+  <head>
+    <meta charset="utf-8">
+    <title>Test for B2G Presentation API when sender and receiver at the same side</title>
+    <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+    <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  </head>
+  <body>
+    <a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1268810">
+      Test for receiver page with sandboxed auxiliary navigation browsing context flag.</a>
+    <script type="application/javascript" src="test_presentation_receiver_auxiliary_navigation.js">
+    </script>
+  </body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_receiver_auxiliary_navigation_oop.html b/dom/presentation/tests/mochitest/test_presentation_receiver_auxiliary_navigation_oop.html
new file mode 100644
index 0000000000..31be5be5ee
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_receiver_auxiliary_navigation_oop.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<!-- vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: -->
+<html>
+  <!-- Any copyright is dedicated to the Public Domain.
+    - http://creativecommons.org/publicdomain/zero/1.0/ -->
+  <head>
+    <meta charset="utf-8">
+    <title>Test for B2G Presentation API when sender and receiver at the same side</title>
+    <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+    <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  </head>
+  <body>
+    <a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1268810">
+      Test for receiver page with sandboxed auxiliary navigation browsing context flag.</a>
+    <script type="application/javascript" src="test_presentation_receiver_auxiliary_navigation.js">
+    </script>
+  </body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_reconnect.html b/dom/presentation/tests/mochitest/test_presentation_reconnect.html
new file mode 100644
index 0000000000..6febdce57b
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_reconnect.html
@@ -0,0 +1,378 @@
+<!DOCTYPE HTML>
+<html>
+<!-- Any copyright is dedicated to the Public Domain.
+   - http://creativecommons.org/publicdomain/zero/1.0/ -->
+<head>
+  <meta charset="utf-8">
+  <title>Test for B2G Presentation API at sender side</title>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script type="application/javascript" src="PresentationSessionFrameScript.js"></script>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1197690">Test for Presentation API at sender side</a>
+<iframe id="iframe" src="file_presentation_reconnect.html"></iframe>
+<script type="application/javascript">
+
+"use strict";
+
+var iframe = document.getElementById("iframe");
+var gScript = SpecialPowers.loadChromeScript(SimpleTest.getTestFileURL("PresentationSessionChromeScript.js"));
+var frameScript = SpecialPowers.isMainProcess() ? gScript : contentScript;
+var request;
+var connection;
+var commandHandler = {};
+
+function testSetup() {
+  return new Promise(function(aResolve, aReject) {
+    addEventListener("message", function listener(event) {
+      var message = event.data;
+      if (/^OK /.exec(message)) {
+        ok(true, message.replace(/^OK /, ""));
+      } else if (/^KO /.exec(message)) {
+        ok(false, message.replace(/^KO /, ""));
+      } else if (/^INFO /.exec(message)) {
+        info(message.replace(/^INFO /, ""));
+      } else if (/^COMMAND /.exec(message)) {
+        var command = JSON.parse(message.replace(/^COMMAND /, ""));
+        if (command.name in commandHandler) {
+          commandHandler[command.name](command);
+        }
+      } else if (/^DONE$/.exec(message)) {
+        window.removeEventListener("message", listener);
+        SimpleTest.finish();
+      }
+    }, false);
+
+    request = new PresentationRequest("http://example.com/");
+
+    request.getAvailability().then(
+      function(aAvailability) {
+        is(aAvailability.value, false, "Sender: should have no available device after setup");
+        aAvailability.onchange = function() {
+          aAvailability.onchange = null;
+          ok(aAvailability.value, "Device should be available.");
+          aResolve();
+        };
+
+        gScript.sendAsyncMessage("trigger-device-add");
+      },
+      function(aError) {
+        ok(false, "Error occurred when getting availability: " + aError);
+        teardown();
+        aReject();
+      }
+    );
+  });
+}
+
+function testStartConnection() {
+  return new Promise(function(aResolve, aReject) {
+    gScript.addMessageListener("device-prompt", function devicePromptHandler() {
+      info("Device prompt is triggered.");
+      gScript.sendAsyncMessage("trigger-device-prompt-select");
+    });
+
+    gScript.addMessageListener("control-channel-established", function controlChannelEstablishedHandler() {
+      info("A control channel is established.");
+      gScript.sendAsyncMessage("trigger-control-channel-open");
+    });
+
+    gScript.addMessageListener("control-channel-opened", function controlChannelOpenedHandler(aReason) {
+      info("The control channel is opened.");
+    });
+
+    gScript.addMessageListener("control-channel-closed", function controlChannelClosedHandler(aReason) {
+      info("The control channel is closed. " + aReason);
+    });
+
+    frameScript.addMessageListener("check-navigator", function checknavigatorHandler(aSuccess) {
+      ok(aSuccess, "buildDataChannel get correct window object");
+    });
+
+    gScript.addMessageListener("offer-sent", function offerSentHandler(aIsValid) {
+      ok(aIsValid, "A valid offer is sent out.");
+      gScript.sendAsyncMessage("trigger-incoming-answer");
+    });
+
+    gScript.addMessageListener("answer-received", function answerReceivedHandler() {
+      info("An answer is received.");
+    });
+
+    frameScript.addMessageListener("data-transport-initialized", function dataTransportInitializedHandler() {
+      info("Data transport channel is initialized.");
+    });
+
+    frameScript.addMessageListener("data-transport-notification-enabled", function dataTransportNotificationEnabledHandler() {
+      info("Data notification is enabled for data transport channel.");
+    });
+
+    var connectionFromEvent;
+    request.onconnectionavailable = function(aEvent) {
+      request.onconnectionavailable = null;
+      connectionFromEvent = aEvent.connection;
+      ok(connectionFromEvent, "|connectionavailable| event is fired with a connection.");
+
+      if (connection) {
+        is(connection, connectionFromEvent, "The connection from promise and the one from |connectionavailable| event should be the same.");
+      }
+    };
+
+    request.start().then(
+      function(aConnection) {
+        connection = aConnection;
+        ok(connection, "Connection should be available.");
+        ok(connection.id, "Connection ID should be set.");
+        is(connection.state, "connecting", "The initial state should be connecting.");
+
+        if (connectionFromEvent) {
+          is(connection, connectionFromEvent, "The connection from promise and the one from |connectionavailable| event should be the same.");
+        }
+        connection.onconnect = function() {
+          connection.onconnect = null;
+          is(connection.state, "connected", "Connection should be connected.");
+          aResolve();
+        };
+      },
+      function(aError) {
+        ok(false, "Error occurred when establishing a connection: " + aError);
+        teardown();
+        aReject();
+      }
+    );
+  });
+}
+
+function testCloseConnection() {
+  return new Promise(function(aResolve, aReject) {
+    frameScript.addMessageListener("data-transport-closed", function dataTransportClosedHandler(aReason) {
+      frameScript.removeMessageListener("data-transport-closed", dataTransportClosedHandler);
+      info("The data transport is closed. " + aReason);
+    });
+
+    connection.onclose = function() {
+      connection.onclose = null;
+      is(connection.state, "closed", "Connection should be closed.");
+      aResolve();
+    };
+
+    connection.close();
+  });
+}
+
+function testReconnectAConnectedConnection() {
+  return new Promise(function(aResolve, aReject) {
+    info("--- testReconnectAConnectedConnection ---");
+    is(connection.state, "connected", "Make sure the state is connected.");
+
+    request.reconnect(connection.id).then(
+      function(aConnection) {
+        ok(aConnection, "Connection should be available.");
+        is(aConnection.id, connection.id, "Connection ID should be the same.");
+        is(aConnection.state, "connected", "The state should be connected.");
+        is(aConnection, connection, "The connection should be the same.");
+
+        aResolve();
+      },
+      function(aError) {
+        ok(false, "Error occurred when establishing a connection: " + aError);
+        teardown();
+        aReject();
+      }
+    );
+  });
+}
+
+function testReconnectInvalidID() {
+  return new Promise(function(aResolve, aReject) {
+    info("--- testReconnectInvalidID ---");
+
+    request.reconnect("dummyID").then(
+      function(aConnection) {
+        ok(false, "Unexpected success.");
+        teardown();
+        aReject();
+      },
+      function(aError) {
+        is(aError.name, "NotFoundError", "Should get NotFoundError.");
+        aResolve();
+      }
+    );
+  });
+}
+
+function testReconnectInvalidURL() {
+  return new Promise(function(aResolve, aReject) {
+    info("--- testReconnectInvalidURL ---");
+
+    var request1 = new PresentationRequest("http://invalidURL");
+    request1.reconnect(connection.id).then(
+      function(aConnection) {
+        ok(false, "Unexpected success.");
+        teardown();
+        aReject();
+      },
+      function(aError) {
+        is(aError.name, "NotFoundError", "Should get NotFoundError.");
+        aResolve();
+      }
+    );
+  });
+}
+
+function testReconnectIframeConnectedConnection() {
+  info("--- testReconnectIframeConnectedConnection ---");
+  gScript.sendAsyncMessage("save-control-channel-listener");
+  return Promise.all([
+    new Promise(function(aResolve, aReject) {
+      commandHandler["connection-connected"] = function(command) {
+      gScript.addMessageListener("start-reconnect", function startReconnectHandler(url) {
+        gScript.removeMessageListener("start-reconnect", startReconnectHandler);
+        gScript.sendAsyncMessage("trigger-reconnected-acked", url);
+      });
+
+      var request1 = new PresentationRequest("http://example1.com");
+        request1.reconnect(command.id).then(
+          function(aConnection) {
+            is(aConnection.state, "connecting", "The state should be connecting.");
+            aConnection.onclose = function() {
+              delete commandHandler["connection-connected"];
+              gScript.sendAsyncMessage("restore-control-channel-listener");
+              aResolve();
+            };
+            aConnection.close();
+          },
+          function(aError) {
+            ok(false, "Error occurred when establishing a connection: " + aError);
+            teardown();
+            aReject();
+          }
+        );
+      };
+      iframe.contentWindow.postMessage("startConnection", "*");
+    }),
+    new Promise(function(aResolve, aReject) {
+      commandHandler["notify-connection-closed"] = function(command) {
+        delete commandHandler["notify-connection-closed"];
+        aResolve();
+      };
+    }),
+  ]);
+}
+
+function testReconnectIframeClosedConnection() {
+  return new Promise(function(aResolve, aReject) {
+    info("--- testReconnectIframeClosedConnection ---");
+    gScript.sendAsyncMessage("save-control-channel-listener");
+    commandHandler["connection-closed"] = function(command) {
+      gScript.addMessageListener("start-reconnect", function startReconnectHandler(url) {
+        gScript.removeMessageListener("start-reconnect", startReconnectHandler);
+        gScript.sendAsyncMessage("trigger-reconnected-acked", url);
+      });
+
+      var request1 = new PresentationRequest("http://example1.com");
+      request1.reconnect(command.id).then(
+        function(aConnection) {
+          aConnection.onconnect = function() {
+            aConnection.onconnect = null;
+            is(aConnection.state, "connected", "The connection should be connected.");
+            aConnection.onclose = function() {
+              aConnection.onclose = null;
+              ok(true, "The connection is closed.");
+              delete commandHandler["connection-closed"];
+              aResolve();
+            };
+            aConnection.close();
+            gScript.sendAsyncMessage("restore-control-channel-listener");
+          };
+        },
+        function(aError) {
+          ok(false, "Error occurred when establishing a connection: " + aError);
+          teardown();
+          aReject();
+        }
+      );
+    };
+    iframe.contentWindow.postMessage("closeConnection", "*");
+  });
+}
+
+function testReconnect() {
+  return new Promise(function(aResolve, aReject) {
+    info("--- testReconnect ---");
+    gScript.addMessageListener("start-reconnect", function startReconnectHandler(url) {
+      gScript.removeMessageListener("start-reconnect", startReconnectHandler);
+      is(url, "http://example.com/", "URLs should be the same.");
+      gScript.sendAsyncMessage("trigger-reconnected-acked", url);
+    });
+
+    request.reconnect(connection.id).then(
+      function(aConnection) {
+        ok(aConnection, "Connection should be available.");
+        ok(aConnection.id, "Connection ID should be set.");
+        is(aConnection.state, "connecting", "The initial state should be connecting.");
+        is(aConnection, connection, "The reconnected connection should be the same.");
+
+        aConnection.onconnect = function() {
+          aConnection.onconnect = null;
+          is(aConnection.state, "connected", "Connection should be connected.");
+
+          const incomingMessage = "test incoming message";
+          aConnection.addEventListener("message", function(aEvent) {
+            is(aEvent.data, incomingMessage, "An incoming message should be received.");
+            aResolve();
+          }, {once: true});
+
+          frameScript.sendAsyncMessage("trigger-incoming-message", incomingMessage);
+        };
+      },
+      function(aError) {
+        ok(false, "Error occurred when establishing a connection: " + aError);
+        teardown();
+        aReject();
+      }
+    );
+  });
+}
+
+function teardown() {
+  gScript.addMessageListener("teardown-complete", function teardownCompleteHandler() {
+    gScript.removeMessageListener("teardown-complete", teardownCompleteHandler);
+    gScript.destroy();
+    info("teardown-complete");
+    SimpleTest.finish();
+  });
+
+  gScript.sendAsyncMessage("teardown");
+}
+
+function runTests() {
+  ok(window.PresentationRequest, "PresentationRequest should be available.");
+
+  testSetup().
+  then(testStartConnection).
+  then(testReconnectInvalidID).
+  then(testReconnectInvalidURL).
+  then(testReconnectAConnectedConnection).
+  then(testReconnectIframeConnectedConnection).
+  then(testReconnectIframeClosedConnection).
+  then(testCloseConnection).
+  then(testReconnect).
+  then(testCloseConnection).
+  then(teardown);
+}
+
+SimpleTest.waitForExplicitFinish();
+SpecialPowers.pushPermissions([
+  {type: "presentation-device-manage", allow: false, context: document},
+], function() {
+  SpecialPowers.pushPrefEnv({ "set": [["dom.presentation.enabled", true],
+                                      ["dom.presentation.controller.enabled", true],
+                                      ["dom.presentation.receiver.enabled", true],
+                                      ["dom.presentation.session_transport.data_channel.enable", true]]},
+                            runTests);
+});
+
+</script>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_sandboxed_presentation.html b/dom/presentation/tests/mochitest/test_presentation_sandboxed_presentation.html
new file mode 100644
index 0000000000..d5902d6223
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_sandboxed_presentation.html
@@ -0,0 +1,75 @@
+<!DOCTYPE HTML>
+<html>
+<!-- Any copyright is dedicated to the Public Domain.
+   - http://creativecommons.org/publicdomain/zero/1.0/ -->
+<head>
+  <meta charset="utf-8">
+  <title>Test default request for B2G Presentation API at sender side</title>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1268758">Test allow-presentation sandboxing flag</a>
+<iframe sandbox="allow-popups allow-scripts allow-same-origin" id="iframe" src="file_presentation_sandboxed_presentation.html"></iframe>
+<script type="application/javascript">
+
+"use strict";
+
+var iframe = document.getElementById("iframe");
+var readyToStart = false;
+var testSetuped = false;
+function setup() {
+  return new Promise(function(aResolve, aReject) {
+    addEventListener("message", function listener(event) {
+      var message = event.data;
+      if (/^OK /.exec(message)) {
+        ok(true, message.replace(/^OK /, ""));
+      } else if (/^KO /.exec(message)) {
+        ok(false, message.replace(/^KO /, ""));
+      } else if (/^INFO /.exec(message)) {
+        info(message.replace(/^INFO /, ""));
+      } else if (/^COMMAND /.exec(message)) {
+        var command = JSON.parse(message.replace(/^COMMAND /, ""));
+        if (command === "ready-to-start") {
+          readyToStart = true;
+          startTest();
+        }
+      } else if (/^DONE$/.exec(message)) {
+        window.removeEventListener("message", listener);
+        SimpleTest.finish();
+      }
+    }, false);
+
+    testSetuped = true;
+    aResolve();
+  });
+}
+
+iframe.onload = startTest();
+
+function startTest() {
+  if (!(testSetuped && readyToStart)) {
+    return;
+  }
+  iframe.contentWindow.postMessage("start", "*");
+}
+
+function runTests() {
+  ok(navigator.presentation, "navigator.presentation should be available.");
+  setup().then(startTest);
+}
+
+SimpleTest.waitForExplicitFinish();
+SpecialPowers.pushPermissions([
+  {type: "presentation-device-manage", allow: false, context: document},
+], function() {
+  SpecialPowers.pushPrefEnv({ "set": [["dom.presentation.enabled", true],
+                                      ["dom.presentation.controller.enabled", true],
+                                      ["dom.presentation.receiver.enabled", false],
+                                      ["dom.presentation.session_transport.data_channel.enable", false]]},
+                            runTests);
+});
+
+</script>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_sender_on_terminate_request.html b/dom/presentation/tests/mochitest/test_presentation_sender_on_terminate_request.html
new file mode 100644
index 0000000000..7da672a080
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_sender_on_terminate_request.html
@@ -0,0 +1,187 @@
+<!DOCTYPE HTML>
+<html>
+<!-- Any copyright is dedicated to the Public Domain.
+   - http://creativecommons.org/publicdomain/zero/1.0/ -->
+<head>
+  <meta charset="utf-8">
+  <title>Test onTerminateRequest at sender side</title>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1276378">Test onTerminateRequest at sender side</a>
+<script type="application/javascript">
+
+"use strict";
+
+var gScript = SpecialPowers.loadChromeScript(SimpleTest.getTestFileURL("PresentationSessionChromeScript.js"));
+var request;
+var connection;
+
+function testSetup() {
+  return new Promise(function(aResolve, aReject) {
+    request = new PresentationRequest("http://example.com");
+
+    request.getAvailability().then(
+      function(aAvailability) {
+        is(aAvailability.value, false, "Sender: should have no available device after setup");
+        aAvailability.onchange = function() {
+          aAvailability.onchange = null;
+          ok(aAvailability.value, "Device should be available.");
+          aResolve();
+        };
+
+        gScript.sendAsyncMessage("trigger-device-add");
+      },
+      function(aError) {
+        ok(false, "Error occurred when getting availability: " + aError);
+        teardown();
+        aReject();
+      }
+    );
+  });
+}
+
+function testStartConnection() {
+  return new Promise(function(aResolve, aReject) {
+    gScript.addMessageListener("device-prompt", function devicePromptHandler() {
+      gScript.removeMessageListener("device-prompt", devicePromptHandler);
+      info("Device prompt is triggered.");
+      gScript.sendAsyncMessage("trigger-device-prompt-select");
+    });
+
+    gScript.addMessageListener("control-channel-established", function controlChannelEstablishedHandler() {
+      gScript.removeMessageListener("control-channel-established", controlChannelEstablishedHandler);
+      info("A control channel is established.");
+      gScript.sendAsyncMessage("trigger-control-channel-open");
+    });
+
+    gScript.addMessageListener("control-channel-opened", function controlChannelOpenedHandler(aReason) {
+      gScript.removeMessageListener("control-channel-opened", controlChannelOpenedHandler);
+      info("The control channel is opened.");
+    });
+
+    gScript.addMessageListener("control-channel-closed", function controlChannelClosedHandler(aReason) {
+      gScript.removeMessageListener("control-channel-closed", controlChannelClosedHandler);
+      info("The control channel is closed. " + aReason);
+    });
+
+    gScript.addMessageListener("offer-sent", function offerSentHandler(aIsValid) {
+      gScript.removeMessageListener("offer-sent", offerSentHandler);
+      ok(aIsValid, "A valid offer is sent out.");
+      gScript.sendAsyncMessage("trigger-incoming-transport");
+    });
+
+    gScript.addMessageListener("answer-received", function answerReceivedHandler() {
+      gScript.removeMessageListener("answer-received", answerReceivedHandler);
+      info("An answer is received.");
+    });
+
+    gScript.addMessageListener("data-transport-initialized", function dataTransportInitializedHandler() {
+      gScript.removeMessageListener("data-transport-initialized", dataTransportInitializedHandler);
+      info("Data transport channel is initialized.");
+      gScript.sendAsyncMessage("trigger-incoming-answer");
+    });
+
+    gScript.addMessageListener("data-transport-notification-enabled", function dataTransportNotificationEnabledHandler() {
+      gScript.removeMessageListener("data-transport-notification-enabled", dataTransportNotificationEnabledHandler);
+      info("Data notification is enabled for data transport channel.");
+    });
+
+    var connectionFromEvent;
+    request.onconnectionavailable = function(aEvent) {
+      request.onconnectionavailable = null;
+      connectionFromEvent = aEvent.connection;
+      ok(connectionFromEvent, "|connectionavailable| event is fired with a connection.");
+
+      if (connection) {
+        is(connection, connectionFromEvent, "The connection from promise and the one from |connectionavailable| event should be the same.");
+      }
+    };
+
+    request.start().then(
+      function(aConnection) {
+        connection = aConnection;
+        ok(connection, "Connection should be available.");
+        ok(connection.id, "Connection ID should be set.");
+        is(connection.state, "connecting", "The initial state should be connecting.");
+
+        if (connectionFromEvent) {
+          is(connection, connectionFromEvent, "The connection from promise and the one from |connectionavailable| event should be the same.");
+        }
+        connection.onconnect = function() {
+          connection.onconnect = null;
+          is(connection.state, "connected", "Connection should be connected.");
+          aResolve();
+        };
+      },
+      function(aError) {
+        ok(false, "Error occurred when establishing a connection: " + aError);
+        teardown();
+        aReject();
+      }
+    );
+  });
+}
+
+function testOnTerminateRequest() {
+  return new Promise(function(aResolve, aReject) {
+    gScript.addMessageListener("control-channel-opened", function controlChannelOpenedHandler(aReason) {
+      gScript.removeMessageListener("control-channel-opened", controlChannelOpenedHandler);
+      info("The control channel is opened.");
+    });
+
+    gScript.addMessageListener("control-channel-closed", function controlChannelClosedHandler(aReason) {
+      gScript.removeMessageListener("control-channel-closed", controlChannelClosedHandler);
+      info("The control channel is closed. " + aReason);
+    });
+
+    gScript.addMessageListener("data-transport-closed", function dataTransportClosedHandler(aReason) {
+      gScript.removeMessageListener("data-transport-closed", dataTransportClosedHandler);
+      info("The data transport is closed. " + aReason);
+    });
+
+    connection.onterminate = function() {
+      connection.onterminate = null;
+      is(connection.state, "terminated", "Connection should be closed.");
+      aResolve();
+    };
+
+    gScript.sendAsyncMessage("trigger-incoming-terminate-request");
+    gScript.sendAsyncMessage("trigger-control-channel-open");
+  });
+}
+
+function teardown() {
+  gScript.addMessageListener("teardown-complete", function teardownCompleteHandler() {
+    gScript.removeMessageListener("teardown-complete", teardownCompleteHandler);
+    gScript.destroy();
+    SimpleTest.finish();
+  });
+
+  gScript.sendAsyncMessage("teardown");
+}
+
+function runTests() {
+  ok(window.PresentationRequest, "PresentationRequest should be available.");
+
+  testSetup().
+  then(testStartConnection).
+  then(testOnTerminateRequest).
+  then(teardown);
+}
+
+SimpleTest.waitForExplicitFinish();
+SpecialPowers.pushPermissions([
+  {type: "presentation-device-manage", allow: false, context: document},
+], function() {
+  SpecialPowers.pushPrefEnv({ "set": [["dom.presentation.enabled", true],
+                                      ["dom.presentation.controller.enabled", true],
+                                      ["dom.presentation.receiver.enabled", false],
+                                      ["dom.presentation.session_transport.data_channel.enable", false]]},
+                            runTests);
+});
+
+</script>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_sender_startWithDevice.html b/dom/presentation/tests/mochitest/test_presentation_sender_startWithDevice.html
new file mode 100644
index 0000000000..6bcf379058
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_sender_startWithDevice.html
@@ -0,0 +1,173 @@
+<!DOCTYPE HTML>
+<html>
+<!-- Any copyright is dedicated to the Public Domain.
+   - http://creativecommons.org/publicdomain/zero/1.0/ -->
+<head>
+  <meta charset="utf-8">
+  <title>Test startWithDevice for B2G Presentation API at sender side</title>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1239242">Test startWithDevice for B2G Presentation API at sender side</a>
+<script type="application/javascript">
+
+"use strict";
+
+var gScript = SpecialPowers.loadChromeScript(SimpleTest.getTestFileURL("PresentationSessionChromeScript.js"));
+var request;
+var connection;
+
+function testSetup() {
+  return new Promise(function(aResolve, aReject) {
+    request = new PresentationRequest("https://example.com");
+
+    request.getAvailability().then(
+      function(aAvailability) {
+        is(aAvailability.value, false, "Sender: should have no available device after setup");
+        aAvailability.onchange = function() {
+          aAvailability.onchange = null;
+          ok(aAvailability.value, "Device should be available.");
+          aResolve();
+        };
+
+        gScript.sendAsyncMessage("trigger-device-add");
+      },
+      function(aError) {
+        ok(false, "Error occurred when getting availability: " + aError);
+        teardown();
+        aReject();
+      }
+    );
+  });
+}
+
+function testStartConnectionWithDevice() {
+  return new Promise(function(aResolve, aReject) {
+    gScript.addMessageListener("device-prompt", function devicePromptHandler() {
+      gScript.removeMessageListener("device-prompt", devicePromptHandler);
+      ok(false, "Device prompt should not be triggered.");
+      teardown();
+      aReject();
+    });
+
+    gScript.addMessageListener("control-channel-established", function controlChannelEstablishedHandler() {
+      gScript.removeMessageListener("control-channel-established", controlChannelEstablishedHandler);
+      info("A control channel is established.");
+      gScript.sendAsyncMessage("trigger-control-channel-open");
+    });
+
+    gScript.addMessageListener("control-channel-opened", function controlChannelOpenedHandler(aReason) {
+      gScript.removeMessageListener("control-channel-opened", controlChannelOpenedHandler);
+      info("The control channel is opened.");
+    });
+
+    gScript.addMessageListener("control-channel-closed", function controlChannelClosedHandler(aReason) {
+      gScript.removeMessageListener("control-channel-closed", controlChannelClosedHandler);
+      info("The control channel is closed. " + aReason);
+    });
+
+    gScript.addMessageListener("offer-sent", function offerSentHandler(aIsValid) {
+      gScript.removeMessageListener("offer-sent", offerSentHandler);
+      ok(aIsValid, "A valid offer is sent out.");
+      gScript.sendAsyncMessage("trigger-incoming-transport");
+    });
+
+    gScript.addMessageListener("answer-received", function answerReceivedHandler() {
+      gScript.removeMessageListener("answer-received", answerReceivedHandler);
+      info("An answer is received.");
+    });
+
+    gScript.addMessageListener("data-transport-initialized", function dataTransportInitializedHandler() {
+      gScript.removeMessageListener("data-transport-initialized", dataTransportInitializedHandler);
+      info("Data transport channel is initialized.");
+      gScript.sendAsyncMessage("trigger-incoming-answer");
+    });
+
+    gScript.addMessageListener("data-transport-notification-enabled", function dataTransportNotificationEnabledHandler() {
+      gScript.removeMessageListener("data-transport-notification-enabled", dataTransportNotificationEnabledHandler);
+      info("Data notification is enabled for data transport channel.");
+    });
+
+    var connectionFromEvent;
+    request.onconnectionavailable = function(aEvent) {
+      request.onconnectionavailable = null;
+      connectionFromEvent = aEvent.connection;
+      ok(connectionFromEvent, "|connectionavailable| event is fired with a connection.");
+
+      if (connection) {
+        is(connection, connectionFromEvent, "The connection from promise and the one from |connectionavailable| event should be the same.");
+      }
+    };
+
+    request.startWithDevice("id").then(
+      function(aConnection) {
+        connection = aConnection;
+        ok(connection, "Connection should be available.");
+        ok(connection.id, "Connection ID should be set.");
+        is(connection.state, "connecting", "The initial state should be connecting.");
+
+        if (connectionFromEvent) {
+          is(connection, connectionFromEvent, "The connection from promise and the one from |connectionavailable| event should be the same.");
+        }
+        connection.onconnect = function() {
+          connection.onconnect = null;
+          is(connection.state, "connected", "Connection should be connected.");
+          aResolve();
+        };
+      },
+      function(aError) {
+        ok(false, "Error occurred when establishing a connection: " + aError);
+        teardown();
+        aReject();
+      }
+    );
+  });
+}
+
+function testStartConnectionWithDeviceNotFoundError() {
+  return new Promise(function(aResolve, aReject) {
+    request.startWithDevice("").then(
+      function(aConnection) {
+        ok(false, "Should not establish connection to an unknown device");
+        teardown();
+        aReject();
+      },
+      function(aError) {
+        is(aError.name, "NotFoundError", "Expect NotFoundError occurred when establishing a connection");
+        aResolve();
+      }
+    );
+  });
+}
+
+function teardown() {
+  gScript.addMessageListener("teardown-complete", function teardownCompleteHandler() {
+    gScript.removeMessageListener("teardown-complete", teardownCompleteHandler);
+    gScript.destroy();
+    SimpleTest.finish();
+  });
+
+  gScript.sendAsyncMessage("teardown");
+}
+
+function runTests() {
+  ok(window.PresentationRequest, "PresentationRequest should be available.");
+
+  testSetup().
+  then(testStartConnectionWithDevice).
+  then(testStartConnectionWithDeviceNotFoundError).
+  then(teardown);
+}
+
+SimpleTest.waitForExplicitFinish();
+SpecialPowers.pushPrefEnv({ "set": [["dom.presentation.enabled", true],
+                                    ["dom.presentation.session_transport.data_channel.enable", false],
+                                    ["dom.presentation.controller.enabled", true],
+                                    ["dom.presentation.test.enabled", true],
+                                    ["dom.presentation.test.stage", 0]]},
+                          runTests);
+
+</script>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_tcp_receiver.html b/dom/presentation/tests/mochitest/test_presentation_tcp_receiver.html
new file mode 100644
index 0000000000..52196d9913
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_tcp_receiver.html
@@ -0,0 +1,130 @@
+<!DOCTYPE HTML>
+<html>
+<!-- Any copyright is dedicated to the Public Domain.
+   - http://creativecommons.org/publicdomain/zero/1.0/ -->
+<head>
+  <meta charset="utf-8">
+  <title>Test for B2G PresentationConnection API at receiver side</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=1069230">Test for B2G PresentationConnection API at receiver side</a>
+<p id="display"></p>
+<div id="content" style="display: none"></div>
+<pre id="test"></pre>
+<script type="application/javascript">
+
+"use strict";
+
+var gScript = SpecialPowers.loadChromeScript(SimpleTest.getTestFileURL("PresentationSessionChromeScript.js"));
+var receiverUrl = SimpleTest.getTestFileURL("file_presentation_receiver.html");
+
+var obs = SpecialPowers.Services.obs;
+
+function setup() {
+  gScript.sendAsyncMessage("trigger-device-add");
+
+  var iframe = document.createElement("iframe");
+  iframe.setAttribute("mozbrowser", "true");
+  iframe.setAttribute("mozpresentation", receiverUrl);
+  iframe.setAttribute("src", receiverUrl);
+
+  // This event is triggered when the iframe calls "postMessage".
+  iframe.addEventListener("mozbrowsershowmodalprompt", function listener(aEvent) {
+    var message = aEvent.detail.message;
+    if (/^OK /.exec(message)) {
+      ok(true, "Message from iframe: " + message);
+    } else if (/^KO /.exec(message)) {
+      ok(false, "Message from iframe: " + message);
+    } else if (/^INFO /.exec(message)) {
+      info("Message from iframe: " + message);
+    } else if (/^COMMAND /.exec(message)) {
+      var command = JSON.parse(message.replace(/^COMMAND /, ""));
+      gScript.sendAsyncMessage(command.name, command.data);
+    } else if (/^DONE$/.exec(message)) {
+      ok(true, "Messaging from iframe complete.");
+      iframe.removeEventListener("mozbrowsershowmodalprompt", listener);
+
+      teardown();
+    }
+  });
+
+  var promise = new Promise(function(aResolve, aReject) {
+    document.body.appendChild(iframe);
+
+    aResolve(iframe);
+  });
+  obs.notifyObservers(promise, "setup-request-promise");
+
+  gScript.addMessageListener("offer-received", function offerReceivedHandler() {
+    gScript.removeMessageListener("offer-received", offerReceivedHandler);
+    info("An offer is received.");
+  });
+
+  gScript.addMessageListener("answer-sent", function answerSentHandler(aIsValid) {
+    gScript.removeMessageListener("answer-sent", answerSentHandler);
+    ok(aIsValid, "A valid answer is sent.");
+  });
+
+  gScript.addMessageListener("control-channel-closed", function controlChannelClosedHandler(aReason) {
+    gScript.removeMessageListener("control-channel-closed", controlChannelClosedHandler);
+    is(aReason, SpecialPowers.Cr.NS_OK, "The control channel is closed normally.");
+  });
+
+  gScript.addMessageListener("data-transport-notification-enabled", function dataTransportNotificationEnabledHandler() {
+    gScript.removeMessageListener("data-transport-notification-enabled", dataTransportNotificationEnabledHandler);
+    info("Data notification is enabled for data transport channel.");
+  });
+
+  gScript.addMessageListener("data-transport-closed", function dataTransportClosedHandler(aReason) {
+    gScript.removeMessageListener("data-transport-closed", dataTransportClosedHandler);
+    is(aReason, SpecialPowers.Cr.NS_OK, "The data transport should be closed normally.");
+  });
+}
+
+function testIncomingSessionRequest() {
+  return new Promise(function(aResolve, aReject) {
+    gScript.addMessageListener("receiver-launching", function launchReceiverHandler(aSessionId) {
+      gScript.removeMessageListener("receiver-launching", launchReceiverHandler);
+      info("Trying to launch receiver page.");
+
+      ok(navigator.presentation, "navigator.presentation should be available in in-process pages.");
+      is(navigator.presentation.receiver, null, "Non-receiving in-process pages shouldn't get a presentation receiver instance.");
+      aResolve();
+    });
+
+    gScript.sendAsyncMessage("trigger-incoming-session-request", receiverUrl);
+  });
+}
+
+function teardown() {
+  gScript.addMessageListener("teardown-complete", function teardownCompleteHandler() {
+    gScript.removeMessageListener("teardown-complete", teardownCompleteHandler);
+    gScript.destroy();
+    SimpleTest.finish();
+  });
+
+  gScript.sendAsyncMessage("teardown");
+}
+
+function runTests() {
+  setup();
+  testIncomingSessionRequest();
+}
+
+SimpleTest.waitForExplicitFinish();
+SpecialPowers.pushPermissions([
+  {type: "presentation-device-manage", allow: false, context: document},
+  {type: "browser", allow: true, context: document},
+], function() {
+  SpecialPowers.pushPrefEnv({ "set": [["dom.presentation.enabled", true],
+                                      ["dom.presentation.controller.enabled", false],
+                                      ["dom.presentation.receiver.enabled", true],
+                                      ["dom.presentation.session_transport.data_channel.enable", false]]},
+                            runTests);
+});
+
+</script>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_tcp_receiver_establish_connection_error.html b/dom/presentation/tests/mochitest/test_presentation_tcp_receiver_establish_connection_error.html
new file mode 100644
index 0000000000..1c553f2fa9
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_tcp_receiver_establish_connection_error.html
@@ -0,0 +1,103 @@
+<!DOCTYPE HTML>
+<html>
+<!-- Any copyright is dedicated to the Public Domain.
+   - http://creativecommons.org/publicdomain/zero/1.0/ -->
+<head>
+  <meta charset="utf-8">
+  <title>Test for connection establishing errors of B2G Presentation API at receiver side</title>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1069230">Test for connection establishing errors of B2G Presentation API at receiver side</a>
+<script type="application/javascript">
+
+"use strict";
+
+var gScript = SpecialPowers.loadChromeScript(SimpleTest.getTestFileURL("PresentationSessionChromeScript.js"));
+var receiverUrl = SimpleTest.getTestFileURL("file_presentation_receiver_establish_connection_error.html");
+
+var obs = SpecialPowers.Services.obs;
+
+function setup() {
+  gScript.sendAsyncMessage("trigger-device-add");
+
+  var iframe = document.createElement("iframe");
+  iframe.setAttribute("src", receiverUrl);
+  iframe.setAttribute("mozbrowser", "true");
+  iframe.setAttribute("mozpresentation", receiverUrl);
+
+  // This event is triggered when the iframe calls "alert".
+  iframe.addEventListener("mozbrowsershowmodalprompt", function receiverListener(evt) {
+    var message = evt.detail.message;
+    if (/^OK /.exec(message)) {
+      ok(true, message.replace(/^OK /, ""));
+    } else if (/^KO /.exec(message)) {
+      ok(false, message.replace(/^KO /, ""));
+    } else if (/^INFO /.exec(message)) {
+      info(message.replace(/^INFO /, ""));
+    } else if (/^COMMAND /.exec(message)) {
+      var command = JSON.parse(message.replace(/^COMMAND /, ""));
+      gScript.sendAsyncMessage(command.name, command.data);
+    } else if (/^DONE$/.exec(message)) {
+      iframe.removeEventListener("mozbrowsershowmodalprompt",
+                                 receiverListener);
+      teardown();
+    }
+  });
+
+  var promise = new Promise(function(aResolve, aReject) {
+    document.body.appendChild(iframe);
+
+    aResolve(iframe);
+  });
+  obs.notifyObservers(promise, "setup-request-promise");
+
+  gScript.addMessageListener("control-channel-closed", function controlChannelClosedHandler(aReason) {
+    gScript.removeMessageListener("control-channel-closed", controlChannelClosedHandler);
+    is(aReason, 0x80004004 /* NS_ERROR_ABORT */, "The control channel is closed abnormally.");
+  });
+}
+
+function testIncomingSessionRequest() {
+  return new Promise(function(aResolve, aReject) {
+    gScript.addMessageListener("receiver-launching", function launchReceiverHandler(aSessionId) {
+      gScript.removeMessageListener("receiver-launching", launchReceiverHandler);
+      info("Trying to launch receiver page.");
+
+      aResolve();
+    });
+
+    gScript.sendAsyncMessage("trigger-incoming-session-request", receiverUrl);
+  });
+}
+
+function teardown() {
+  gScript.addMessageListener("teardown-complete", function teardownCompleteHandler() {
+    gScript.removeMessageListener("teardown-complete", teardownCompleteHandler);
+    gScript.destroy();
+    SimpleTest.finish();
+  });
+
+  gScript.sendAsyncMessage("teardown");
+}
+
+function runTests() {
+  setup();
+  testIncomingSessionRequest();
+}
+
+SimpleTest.waitForExplicitFinish();
+SpecialPowers.pushPermissions([
+  {type: "presentation-device-manage", allow: false, context: document},
+  {type: "browser", allow: true, context: document},
+], function() {
+  SpecialPowers.pushPrefEnv({ "set": [["dom.presentation.enabled", true],
+                                      ["dom.presentation.receiver.enabled", true],
+                                      ["dom.presentation.session_transport.data_channel.enable", false]]},
+                            runTests);
+});
+
+</script>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_tcp_receiver_establish_connection_timeout.html b/dom/presentation/tests/mochitest/test_presentation_tcp_receiver_establish_connection_timeout.html
new file mode 100644
index 0000000000..067f9691d1
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_tcp_receiver_establish_connection_timeout.html
@@ -0,0 +1,76 @@
+<!DOCTYPE HTML>
+<html>
+<!-- Any copyright is dedicated to the Public Domain.
+   - http://creativecommons.org/publicdomain/zero/1.0/ -->
+<head>
+  <meta charset="utf-8">
+  <title>Test for connection establishing timeout of B2G Presentation API at receiver side</title>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1069230">Test for connection establishing timeout of B2G Presentation API at receiver side</a>
+<script type="application/javascript">
+
+"use strict";
+
+var gScript = SpecialPowers.loadChromeScript(SimpleTest.getTestFileURL("PresentationSessionChromeScript.js"));
+
+var obs = SpecialPowers.Services.obs;
+
+function setup() {
+  gScript.sendAsyncMessage("trigger-device-add");
+
+  var promise = new Promise(function(aResolve, aReject) {
+    // In order to trigger timeout, do not resolve the promise.
+  });
+  obs.notifyObservers(promise, "setup-request-promise");
+}
+
+function testIncomingSessionRequestReceiverLaunchTimeout() {
+  return new Promise(function(aResolve, aReject) {
+    gScript.addMessageListener("receiver-launching", function launchReceiverHandler(aSessionId) {
+      gScript.removeMessageListener("receiver-launching", launchReceiverHandler);
+      info("Trying to launch receiver page.");
+    });
+
+    gScript.addMessageListener("control-channel-closed", function controlChannelClosedHandler(aReason) {
+      gScript.removeMessageListener("control-channel-closed", controlChannelClosedHandler);
+      is(aReason, 0x80530017 /* NS_ERROR_DOM_TIMEOUT_ERR */, "The control channel is closed due to timeout.");
+      aResolve();
+    });
+
+    gScript.sendAsyncMessage("trigger-incoming-session-request", "http://example.com");
+  });
+}
+
+function teardown() {
+  gScript.addMessageListener("teardown-complete", function teardownCompleteHandler() {
+    gScript.removeMessageListener("teardown-complete", teardownCompleteHandler);
+    gScript.destroy();
+    SimpleTest.finish();
+  });
+
+  gScript.sendAsyncMessage("teardown");
+}
+
+function runTests() {
+  setup();
+  testIncomingSessionRequestReceiverLaunchTimeout().
+  then(teardown);
+}
+
+SimpleTest.waitForExplicitFinish();
+SpecialPowers.pushPermissions([
+  {type: "presentation-device-manage", allow: false, context: document},
+], function() {
+  SpecialPowers.pushPrefEnv({ "set": [["dom.presentation.enabled", true],
+                                      ["dom.presentation.receiver.enabled", true],
+                                      ["dom.presentation.session_transport.data_channel.enable", false],
+                                      ["presentation.receiver.loading.timeout", 10]]},
+                            runTests);
+});
+
+</script>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_tcp_receiver_establish_connection_unknown_content_type.js b/dom/presentation/tests/mochitest/test_presentation_tcp_receiver_establish_connection_unknown_content_type.js
new file mode 100644
index 0000000000..6521846a10
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_tcp_receiver_establish_connection_unknown_content_type.js
@@ -0,0 +1,116 @@
+"use strict";
+
+var gScript = SpecialPowers.loadChromeScript(
+  SimpleTest.getTestFileURL("PresentationSessionChromeScript.js")
+);
+var receiverUrl = SimpleTest.getTestFileURL(
+  "file_presentation_unknown_content_type.test"
+);
+
+var obs = SpecialPowers.Services.obs;
+
+var receiverIframe;
+
+function setup() {
+  gScript.sendAsyncMessage("trigger-device-add");
+
+  receiverIframe = document.createElement("iframe");
+  receiverIframe.setAttribute("mozbrowser", "true");
+  receiverIframe.setAttribute("mozpresentation", receiverUrl);
+  receiverIframe.setAttribute("src", receiverUrl);
+  var oop = !location.pathname.includes("_inproc");
+  receiverIframe.setAttribute("remote", oop);
+
+  var promise = new Promise(function(aResolve, aReject) {
+    document.body.appendChild(receiverIframe);
+
+    aResolve(receiverIframe);
+  });
+  obs.notifyObservers(promise, "setup-request-promise");
+}
+
+function testIncomingSessionRequestReceiverLaunchUnknownContentType() {
+  let promise = Promise.all([
+    new Promise(function(aResolve, aReject) {
+      gScript.addMessageListener(
+        "receiver-launching",
+        function launchReceiverHandler(aSessionId) {
+          gScript.removeMessageListener(
+            "receiver-launching",
+            launchReceiverHandler
+          );
+          info("Trying to launch receiver page.");
+
+          receiverIframe.addEventListener("mozbrowserclose", function() {
+            ok(true, "observe receiver window closed");
+            aResolve();
+          });
+        }
+      );
+    }),
+    new Promise(function(aResolve, aReject) {
+      gScript.addMessageListener(
+        "control-channel-closed",
+        function controlChannelClosedHandler(aReason) {
+          gScript.removeMessageListener(
+            "control-channel-closed",
+            controlChannelClosedHandler
+          );
+          is(
+            aReason,
+            0x80530020 /* NS_ERROR_DOM_OPERATION_ERR */,
+            "The control channel is closed due to load failure."
+          );
+          aResolve();
+        }
+      );
+    }),
+  ]);
+
+  gScript.sendAsyncMessage("trigger-incoming-session-request", receiverUrl);
+  return promise;
+}
+
+function teardown() {
+  gScript.addMessageListener(
+    "teardown-complete",
+    function teardownCompleteHandler() {
+      gScript.removeMessageListener(
+        "teardown-complete",
+        teardownCompleteHandler
+      );
+      gScript.destroy();
+      SimpleTest.finish();
+    }
+  );
+
+  gScript.sendAsyncMessage("teardown");
+}
+
+function runTests() {
+  setup();
+
+  testIncomingSessionRequestReceiverLaunchUnknownContentType().then(teardown);
+}
+
+SimpleTest.waitForExplicitFinish();
+SpecialPowers.pushPermissions(
+  [
+    { type: "presentation-device-manage", allow: false, context: document },
+    { type: "browser", allow: true, context: document },
+  ],
+  function() {
+    SpecialPowers.pushPrefEnv(
+      {
+        set: [
+          ["dom.presentation.enabled", true],
+          ["dom.presentation.controller.enabled", true],
+          ["dom.presentation.receiver.enabled", true],
+          ["dom.presentation.session_transport.data_channel.enable", false],
+          ["dom.ipc.tabs.disabled", false],
+        ],
+      },
+      runTests
+    );
+  }
+);
diff --git a/dom/presentation/tests/mochitest/test_presentation_tcp_receiver_establish_connection_unknown_content_type_inproc.html b/dom/presentation/tests/mochitest/test_presentation_tcp_receiver_establish_connection_unknown_content_type_inproc.html
new file mode 100644
index 0000000000..acf800e609
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_tcp_receiver_establish_connection_unknown_content_type_inproc.html
@@ -0,0 +1,16 @@
+<!DOCTYPE HTML>
+<html>
+<!-- Any copyright is dedicated to the Public Domain.
+   - http://creativecommons.org/publicdomain/zero/1.0/ -->
+<head>
+  <meta charset="utf-8">
+  <title>Test for unknown content type of B2G Presentation API at receiver side</title>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1287717">Test for unknown content type of B2G Presentation API at receiver side</a>
+    <script type="application/javascript" src="test_presentation_tcp_receiver_establish_connection_unknown_content_type.js">
+    </script>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_tcp_receiver_establish_connection_unknown_content_type_oop.html b/dom/presentation/tests/mochitest/test_presentation_tcp_receiver_establish_connection_unknown_content_type_oop.html
new file mode 100644
index 0000000000..c78b48b39d
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_tcp_receiver_establish_connection_unknown_content_type_oop.html
@@ -0,0 +1,16 @@
+<!DOCTYPE HTML>
+<html>
+<!-- Any copyright is dedicated to the Public Domain.
+   - http://creativecommons.org/publicdomain/zero/1.0/ -->
+<head>
+  <meta charset="utf-8">
+  <title>Test for unknown content type of B2G Presentation API at receiver side (OOP)</title>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1287717">Test for unknown content type of B2G Presentation API at receiver side (OOP)</a>
+    <script type="application/javascript" src="test_presentation_tcp_receiver_establish_connection_unknown_content_type.js">
+    </script>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_tcp_receiver_oop.html b/dom/presentation/tests/mochitest/test_presentation_tcp_receiver_oop.html
new file mode 100644
index 0000000000..cc6d73745b
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_tcp_receiver_oop.html
@@ -0,0 +1,171 @@
+<!DOCTYPE HTML>
+<html>
+<!-- Any copyright is dedicated to the Public Domain.
+   - http://creativecommons.org/publicdomain/zero/1.0/ -->
+<head>
+  <meta charset="utf-8">
+  <title>Test for B2G PresentationConnection API at receiver side (OOP)</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=1069230">Test B2G PresentationConnection API at receiver side (OOP)</a>
+<p id="display"></p>
+<div id="content" style="display: none"></div>
+<pre id="test"></pre>
+<script type="application/javascript">
+
+"use strict";
+
+var gScript = SpecialPowers.loadChromeScript(SimpleTest.getTestFileURL("PresentationSessionChromeScript.js"));
+var receiverUrl = SimpleTest.getTestFileURL("file_presentation_receiver.html");
+var nonReceiverUrl = SimpleTest.getTestFileURL("file_presentation_non_receiver.html");
+
+var isReceiverFinished = false;
+var isNonReceiverFinished = false;
+
+var obs = SpecialPowers.Services.obs;
+
+function setup() {
+  gScript.sendAsyncMessage("trigger-device-add");
+
+  // Create a receiver OOP iframe.
+  var receiverIframe = document.createElement("iframe");
+  receiverIframe.setAttribute("remote", "true");
+  receiverIframe.setAttribute("mozbrowser", "true");
+  receiverIframe.setAttribute("mozpresentation", receiverUrl);
+  receiverIframe.setAttribute("src", receiverUrl);
+
+  // This event is triggered when the iframe calls "alert".
+  receiverIframe.addEventListener("mozbrowsershowmodalprompt", function receiverListener(aEvent) {
+    var message = aEvent.detail.message;
+    if (/^OK /.exec(message)) {
+      ok(true, "Message from iframe: " + message);
+    } else if (/^KO /.exec(message)) {
+      ok(false, "Message from iframe: " + message);
+    } else if (/^INFO /.exec(message)) {
+      info("Message from iframe: " + message);
+    } else if (/^COMMAND /.exec(message)) {
+      var command = JSON.parse(message.replace(/^COMMAND /, ""));
+      gScript.sendAsyncMessage(command.name, command.data);
+    } else if (/^DONE$/.exec(message)) {
+      ok(true, "Messaging from iframe complete.");
+      receiverIframe.removeEventListener("mozbrowsershowmodalprompt", receiverListener);
+
+      isReceiverFinished = true;
+
+      if (isNonReceiverFinished) {
+        teardown();
+      }
+    }
+  });
+
+  var promise = new Promise(function(aResolve, aReject) {
+    document.body.appendChild(receiverIframe);
+
+    aResolve(receiverIframe);
+  });
+  obs.notifyObservers(promise, "setup-request-promise");
+
+  // Create a non-receiver OOP iframe.
+  var nonReceiverIframe = document.createElement("iframe");
+  nonReceiverIframe.setAttribute("remote", "true");
+  nonReceiverIframe.setAttribute("mozbrowser", "true");
+  nonReceiverIframe.setAttribute("src", nonReceiverUrl);
+
+  // This event is triggered when the iframe calls "alert".
+  nonReceiverIframe.addEventListener("mozbrowsershowmodalprompt", function nonReceiverListener(aEvent) {
+    var message = aEvent.detail.message;
+    if (/^OK /.exec(message)) {
+      ok(true, "Message from iframe: " + message);
+    } else if (/^KO /.exec(message)) {
+      ok(false, "Message from iframe: " + message);
+    } else if (/^INFO /.exec(message)) {
+      info("Message from iframe: " + message);
+    } else if (/^COMMAND /.exec(message)) {
+      var command = JSON.parse(message.replace(/^COMMAND /, ""));
+      gScript.sendAsyncMessage(command.name, command.data);
+    } else if (/^DONE$/.exec(message)) {
+      ok(true, "Messaging from iframe complete.");
+      nonReceiverIframe.removeEventListener("mozbrowsershowmodalprompt", nonReceiverListener);
+
+      isNonReceiverFinished = true;
+
+      if (isReceiverFinished) {
+        teardown();
+      }
+    }
+  });
+
+  document.body.appendChild(nonReceiverIframe);
+
+  gScript.addMessageListener("offer-received", function offerReceivedHandler() {
+    gScript.removeMessageListener("offer-received", offerReceivedHandler);
+    info("An offer is received.");
+  });
+
+  gScript.addMessageListener("answer-sent", function answerSentHandler(aIsValid) {
+    gScript.removeMessageListener("answer-sent", answerSentHandler);
+    ok(aIsValid, "A valid answer is sent.");
+  });
+
+  gScript.addMessageListener("control-channel-closed", function controlChannelClosedHandler(aReason) {
+    gScript.removeMessageListener("control-channel-closed", controlChannelClosedHandler);
+    is(aReason, SpecialPowers.Cr.NS_OK, "The control channel is closed normally.");
+  });
+
+  gScript.addMessageListener("data-transport-notification-enabled", function dataTransportNotificationEnabledHandler() {
+    gScript.removeMessageListener("data-transport-notification-enabled", dataTransportNotificationEnabledHandler);
+    info("Data notification is enabled for data transport channel.");
+  });
+
+  gScript.addMessageListener("data-transport-closed", function dataTransportClosedHandler(aReason) {
+    gScript.removeMessageListener("data-transport-closed", dataTransportClosedHandler);
+    is(aReason, SpecialPowers.Cr.NS_OK, "The data transport should be closed normally.");
+  });
+}
+
+function testIncomingSessionRequest() {
+  return new Promise(function(aResolve, aReject) {
+    gScript.addMessageListener("receiver-launching", function launchReceiverHandler(aSessionId) {
+      gScript.removeMessageListener("receiver-launching", launchReceiverHandler);
+      info("Trying to launch receiver page.");
+
+      aResolve();
+    });
+
+    gScript.sendAsyncMessage("trigger-incoming-session-request", receiverUrl);
+  });
+}
+
+function teardown() {
+  gScript.addMessageListener("teardown-complete", function teardownCompleteHandler() {
+    gScript.removeMessageListener("teardown-complete", teardownCompleteHandler);
+    gScript.destroy();
+    SimpleTest.finish();
+  });
+
+  gScript.sendAsyncMessage("teardown");
+}
+
+function runTests() {
+  setup();
+  testIncomingSessionRequest();
+}
+
+SimpleTest.waitForExplicitFinish();
+SpecialPowers.pushPermissions([
+  {type: "presentation-device-manage", allow: false, context: document},
+  {type: "browser", allow: true, context: document},
+], function() {
+  SpecialPowers.pushPrefEnv({ "set": [["dom.presentation.enabled", true],
+                                      ["dom.presentation.controller.enabled", false],
+                                      ["dom.presentation.receiver.enabled", true],
+                                      ["dom.presentation.session_transport.data_channel.enable", false],
+                                      ["dom.ipc.browser_frames.oop_by_default", true]]},
+                            runTests);
+});
+
+</script>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_tcp_sender.html b/dom/presentation/tests/mochitest/test_presentation_tcp_sender.html
new file mode 100644
index 0000000000..e03c43c54c
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_tcp_sender.html
@@ -0,0 +1,258 @@
+<!DOCTYPE HTML>
+<html>
+<!-- Any copyright is dedicated to the Public Domain.
+   - http://creativecommons.org/publicdomain/zero/1.0/ -->
+<head>
+  <meta charset="utf-8">
+  <title>Test for B2G Presentation API at sender side</title>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1069230">Test for B2G Presentation API at sender side</a>
+<script type="application/javascript">
+
+"use strict";
+
+var gScript = SpecialPowers.loadChromeScript(SimpleTest.getTestFileURL("PresentationSessionChromeScript.js"));
+var request;
+var connection;
+
+function testSetup() {
+  return new Promise(function(aResolve, aReject) {
+    request = new PresentationRequest("https://example.com");
+
+    request.getAvailability().then(
+      function(aAvailability) {
+        is(aAvailability.value, false, "Sender: should have no available device after setup");
+        aAvailability.onchange = function() {
+          aAvailability.onchange = null;
+          ok(aAvailability.value, "Device should be available.");
+          aResolve();
+        };
+        gScript.sendAsyncMessage("trigger-device-add");
+      },
+      function(aError) {
+        ok(false, "Error occurred when getting availability: " + aError);
+        teardown();
+        aReject();
+      }
+    );
+  });
+}
+
+function testStartConnection() {
+  return new Promise(function(aResolve, aReject) {
+    gScript.addMessageListener("device-prompt", function devicePromptHandler() {
+      gScript.removeMessageListener("device-prompt", devicePromptHandler);
+      info("Device prompt is triggered.");
+      gScript.sendAsyncMessage("trigger-device-prompt-select");
+    });
+
+    gScript.addMessageListener("control-channel-established", function controlChannelEstablishedHandler() {
+      gScript.removeMessageListener("control-channel-established", controlChannelEstablishedHandler);
+      info("A control channel is established.");
+      gScript.sendAsyncMessage("trigger-control-channel-open");
+    });
+
+    gScript.addMessageListener("control-channel-opened", function controlChannelOpenedHandler(aReason) {
+      gScript.removeMessageListener("control-channel-opened", controlChannelOpenedHandler);
+      info("The control channel is opened.");
+    });
+
+    gScript.addMessageListener("control-channel-closed", function controlChannelClosedHandler(aReason) {
+      gScript.removeMessageListener("control-channel-closed", controlChannelClosedHandler);
+      info("The control channel is closed. " + aReason);
+    });
+
+    gScript.addMessageListener("offer-sent", function offerSentHandler(aIsValid) {
+      gScript.removeMessageListener("offer-sent", offerSentHandler);
+      ok(aIsValid, "A valid offer is sent out.");
+      gScript.sendAsyncMessage("trigger-incoming-transport");
+    });
+
+    gScript.addMessageListener("answer-received", function answerReceivedHandler() {
+      gScript.removeMessageListener("answer-received", answerReceivedHandler);
+      info("An answer is received.");
+    });
+
+    gScript.addMessageListener("data-transport-initialized", function dataTransportInitializedHandler() {
+      gScript.removeMessageListener("data-transport-initialized", dataTransportInitializedHandler);
+      info("Data transport channel is initialized.");
+      gScript.sendAsyncMessage("trigger-incoming-answer");
+    });
+
+    gScript.addMessageListener("data-transport-notification-enabled", function dataTransportNotificationEnabledHandler() {
+      gScript.removeMessageListener("data-transport-notification-enabled", dataTransportNotificationEnabledHandler);
+      info("Data notification is enabled for data transport channel.");
+    });
+
+    var connectionFromEvent;
+    request.onconnectionavailable = function(aEvent) {
+      request.onconnectionavailable = null;
+      connectionFromEvent = aEvent.connection;
+      ok(connectionFromEvent, "|connectionavailable| event is fired with a connection.");
+
+      if (connection) {
+        is(connection, connectionFromEvent, "The connection from promise and the one from |connectionavailable| event should be the same.");
+      }
+    };
+
+    request.start().then(
+      function(aConnection) {
+        connection = aConnection;
+        ok(connection, "Connection should be available.");
+        ok(connection.id, "Connection ID should be set.");
+        is(connection.state, "connecting", "The initial state should be connecting.");
+
+        if (connectionFromEvent) {
+          is(connection, connectionFromEvent, "The connection from promise and the one from |connectionavailable| event should be the same.");
+        }
+        connection.onconnect = function() {
+          connection.onconnect = null;
+          is(connection.state, "connected", "Connection should be connected.");
+          aResolve();
+        };
+      },
+      function(aError) {
+        ok(false, "Error occurred when establishing a connection: " + aError);
+        teardown();
+        aReject();
+      }
+    );
+  });
+}
+
+function testSend() {
+  return new Promise(function(aResolve, aReject) {
+    const outgoingMessage = "test outgoing message";
+
+    gScript.addMessageListener("message-sent", function messageSentHandler(aMessage) {
+      gScript.removeMessageListener("message-sent", messageSentHandler);
+      is(aMessage, outgoingMessage, "The message is sent out.");
+      aResolve();
+    });
+
+    connection.send(outgoingMessage);
+  });
+}
+
+function testIncomingMessage() {
+  return new Promise(function(aResolve, aReject) {
+    const incomingMessage = "test incoming message";
+
+    connection.addEventListener("message", function(aEvent) {
+      is(aEvent.data, incomingMessage, "An incoming message should be received.");
+      aResolve();
+    }, {once: true});
+
+    gScript.sendAsyncMessage("trigger-incoming-message", incomingMessage);
+  });
+}
+
+function testCloseConnection() {
+  return new Promise(function(aResolve, aReject) {
+    gScript.addMessageListener("data-transport-closed", function dataTransportClosedHandler(aReason) {
+      gScript.removeMessageListener("data-transport-closed", dataTransportClosedHandler);
+      info("The data transport is closed. " + aReason);
+    });
+
+    connection.onclose = function() {
+      connection.onclose = null;
+      is(connection.state, "closed", "Connection should be closed.");
+      aResolve();
+    };
+
+    connection.close();
+  });
+}
+
+function testReconnect() {
+  return new Promise(function(aResolve, aReject) {
+    info("--- testReconnect ---");
+    gScript.addMessageListener("control-channel-established", function controlChannelEstablished() {
+      gScript.removeMessageListener("control-channel-established", controlChannelEstablished);
+      gScript.sendAsyncMessage("trigger-control-channel-open");
+    });
+
+    gScript.addMessageListener("start-reconnect", function startReconnectHandler(url) {
+      gScript.removeMessageListener("start-reconnect", startReconnectHandler);
+      is(url, "https://example.com/", "URLs should be the same.");
+      gScript.sendAsyncMessage("trigger-reconnected-acked", url);
+    });
+
+    gScript.addMessageListener("offer-sent", function offerSentHandler() {
+      gScript.removeMessageListener("offer-sent", offerSentHandler);
+      gScript.sendAsyncMessage("trigger-incoming-transport");
+    });
+
+    gScript.addMessageListener("answer-received", function answerReceivedHandler() {
+      gScript.removeMessageListener("answer-received", answerReceivedHandler);
+      info("An answer is received.");
+    });
+
+    gScript.addMessageListener("data-transport-initialized", function dataTransportInitializedHandler() {
+      gScript.removeMessageListener("data-transport-initialized", dataTransportInitializedHandler);
+      info("Data transport channel is initialized.");
+      gScript.sendAsyncMessage("trigger-incoming-answer");
+    });
+
+    gScript.addMessageListener("data-transport-notification-enabled", function dataTransportNotificationEnabledHandler() {
+      gScript.removeMessageListener("data-transport-notification-enabled", dataTransportNotificationEnabledHandler);
+      info("Data notification is enabled for data transport channel.");
+    });
+
+    request.reconnect(connection.id).then(
+      function(aConnection) {
+        ok(aConnection, "Connection should be available.");
+        ok(aConnection.id, "Connection ID should be set.");
+        is(aConnection.state, "connecting", "The initial state should be connecting.");
+        is(aConnection, connection, "The reconnected connection should be the same.");
+
+        aConnection.onconnect = function() {
+          aConnection.onconnect = null;
+          is(aConnection.state, "connected", "Connection should be connected.");
+          aResolve();
+        };
+      },
+      function(aError) {
+        ok(false, "Error occurred when establishing a connection: " + aError);
+        teardown();
+        aReject();
+      }
+    );
+  });
+}
+
+function teardown() {
+  gScript.addMessageListener("teardown-complete", function teardownCompleteHandler() {
+    gScript.removeMessageListener("teardown-complete", teardownCompleteHandler);
+    gScript.destroy();
+    SimpleTest.finish();
+  });
+
+  gScript.sendAsyncMessage("teardown");
+}
+
+function runTests() {
+  ok(window.PresentationRequest, "PresentationRequest should be available.");
+
+  testSetup().
+  then(testStartConnection).
+  then(testSend).
+  then(testIncomingMessage).
+  then(testCloseConnection).
+  then(testReconnect).
+  then(testCloseConnection).
+  then(teardown);
+}
+
+SimpleTest.waitForExplicitFinish();
+SpecialPowers.pushPrefEnv({ "set": [["dom.presentation.enabled", true],
+                                    ["dom.presentation.controller.enabled", true],
+                                    ["dom.presentation.session_transport.data_channel.enable", false]]},
+                          runTests);
+
+</script>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_tcp_sender_default_request.html b/dom/presentation/tests/mochitest/test_presentation_tcp_sender_default_request.html
new file mode 100644
index 0000000000..a4b4b1ffc7
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_tcp_sender_default_request.html
@@ -0,0 +1,151 @@
+<!DOCTYPE HTML>
+<html>
+<!-- Any copyright is dedicated to the Public Domain.
+   - http://creativecommons.org/publicdomain/zero/1.0/ -->
+<head>
+  <meta charset="utf-8">
+  <title>Test default request for B2G Presentation API at sender side</title>
+  <link rel="stylesheet" type="text/css" href="chrome://mochikit/content/tests/SimpleTest/test.css"/>
+  <script src="chrome://mochikit/content/tests/SimpleTest/SimpleTest.js"></script>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1069230">Test default request for B2G Presentation API at sender side</a>
+<script type="application/javascript">
+
+"use strict";
+
+var gScript = SpecialPowers.loadChromeScript(SimpleTest.getTestFileURL("PresentationSessionChromeScript.js"));
+var connection;
+
+function testSetup() {
+  return new Promise(function(aResolve, aReject) {
+    navigator.presentation.defaultRequest = new PresentationRequest("https://example.com");
+
+    navigator.presentation.defaultRequest.getAvailability().then(
+      function(aAvailability) {
+        is(aAvailability.value, false, "Sender: should have no available device after setup");
+        aAvailability.onchange = function() {
+          aAvailability.onchange = null;
+          ok(aAvailability.value, "Device should be available.");
+          aResolve();
+        };
+
+        gScript.sendAsyncMessage("trigger-device-add");
+      },
+      function(aError) {
+        ok(false, "Error occurred when getting availability: " + aError);
+        teardown();
+        aReject();
+      }
+    );
+  });
+}
+
+function testStartConnection() {
+  return new Promise(function(aResolve, aReject) {
+    gScript.addMessageListener("device-prompt", function devicePromptHandler() {
+      gScript.removeMessageListener("device-prompt", devicePromptHandler);
+      info("Device prompt is triggered.");
+      gScript.sendAsyncMessage("trigger-device-prompt-select");
+    });
+
+    gScript.addMessageListener("control-channel-established", function controlChannelEstablishedHandler() {
+      gScript.removeMessageListener("control-channel-established", controlChannelEstablishedHandler);
+      info("A control channel is established.");
+      gScript.sendAsyncMessage("trigger-control-channel-open");
+    });
+
+    gScript.addMessageListener("control-channel-opened", function controlChannelOpenedHandler(aReason) {
+      gScript.removeMessageListener("control-channel-opened", controlChannelOpenedHandler);
+      info("The control channel is opened.");
+    });
+
+    gScript.addMessageListener("control-channel-closed", function controlChannelClosedHandler(aReason) {
+      gScript.removeMessageListener("control-channel-closed", controlChannelClosedHandler);
+      info("The control channel is closed. " + aReason);
+    });
+
+    gScript.addMessageListener("offer-sent", function offerSentHandler() {
+      gScript.removeMessageListener("offer-sent", offerSentHandler);
+      info("An offer is sent out.");
+      gScript.sendAsyncMessage("trigger-incoming-transport");
+    });
+
+    gScript.addMessageListener("answer-received", function answerReceivedHandler() {
+      gScript.removeMessageListener("answer-received", answerReceivedHandler);
+      info("An answer is received.");
+    });
+
+    gScript.addMessageListener("data-transport-initialized", function dataTransportInitializedHandler() {
+      gScript.removeMessageListener("data-transport-initialized", dataTransportInitializedHandler);
+      info("Data transport channel is initialized.");
+      gScript.sendAsyncMessage("trigger-incoming-answer");
+    });
+
+    is(navigator.presentation.receiver, undefined, "Sender shouldn't get a presentation receiver instance.");
+
+    navigator.presentation.defaultRequest.onconnectionavailable = function(aEvent) {
+      navigator.presentation.defaultRequest.onconnectionavailable = null;
+      connection = aEvent.connection;
+      ok(connection, "|connectionavailable| event is fired with a connection.");
+      ok(connection.id, "Connection ID should be set.");
+      is(connection.state, "connecting", "The initial state should be connecting.");
+      connection.onconnect = function() {
+        connection.onconnect = null;
+        is(connection.state, "connected", "Connection should be connected.");
+        aResolve();
+      };
+    };
+
+    // Simulate the UA triggers |start()| of the default request.
+    navigator.presentation.defaultRequest.start();
+  });
+}
+
+function testCloseConnection() {
+  return new Promise(function(aResolve, aReject) {
+    gScript.addMessageListener("data-transport-closed", function dataTransportClosedHandler(aReason) {
+      gScript.removeMessageListener("data-transport-closed", dataTransportClosedHandler);
+      info("The data transport is closed. " + aReason);
+    });
+
+    connection.onclose = function() {
+      connection.onclose = null;
+      is(connection.state, "closed", "Connection should be closed.");
+      aResolve();
+    };
+
+    connection.close();
+  });
+}
+
+function teardown() {
+  gScript.addMessageListener("teardown-complete", function teardownCompleteHandler() {
+    gScript.removeMessageListener("teardown-complete", teardownCompleteHandler);
+    gScript.destroy();
+    SimpleTest.finish();
+  });
+
+  gScript.sendAsyncMessage("teardown");
+}
+
+function runTests() {
+  ok(window.PresentationRequest, "PresentationRequest should be available.");
+  ok(navigator.presentation, "navigator.presentation should be available.");
+
+  testSetup().
+  then(testStartConnection).
+  then(testCloseConnection).
+  then(teardown);
+}
+
+SimpleTest.waitForExplicitFinish();
+SpecialPowers.pushPrefEnv({ "set": [["dom.presentation.enabled", true],
+                                    ["dom.presentation.controller.enabled", true],
+                                    ["dom.presentation.receiver.enabled", false],
+                                    ["dom.presentation.session_transport.data_channel.enable", false]]},
+                          runTests);
+
+</script>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_tcp_sender_disconnect.html b/dom/presentation/tests/mochitest/test_presentation_tcp_sender_disconnect.html
new file mode 100644
index 0000000000..d08e376999
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_tcp_sender_disconnect.html
@@ -0,0 +1,160 @@
+<!DOCTYPE HTML>
+<html>
+<!-- Any copyright is dedicated to the Public Domain.
+   - http://creativecommons.org/publicdomain/zero/1.0/ -->
+<head>
+  <meta charset="utf-8">
+  <title>Test for disconnection of B2G Presentation API at sender side</title>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1069230">Test for disconnection of B2G Presentation API at sender side</a>
+<script type="application/javascript">
+
+"use strict";
+
+var gScript = SpecialPowers.loadChromeScript(SimpleTest.getTestFileURL("PresentationSessionChromeScript.js"));
+var request;
+var connection;
+
+function testSetup() {
+  return new Promise(function(aResolve, aReject) {
+    request = new PresentationRequest("http://example.com");
+
+    request.getAvailability().then(
+      function(aAvailability) {
+        is(aAvailability.value, false, "Sender: should have no available device after setup");
+        aAvailability.onchange = function() {
+          aAvailability.onchange = null;
+          ok(aAvailability.value, "Device should be available.");
+          aResolve();
+        };
+
+        gScript.sendAsyncMessage("trigger-device-add");
+      },
+      function(aError) {
+        ok(false, "Error occurred when getting availability: " + aError);
+        teardown();
+        aReject();
+      }
+    );
+  });
+}
+
+function testStartConnection() {
+  return new Promise(function(aResolve, aReject) {
+    gScript.addMessageListener("device-prompt", function devicePromptHandler() {
+      gScript.removeMessageListener("device-prompt", devicePromptHandler);
+      info("Device prompt is triggered.");
+      gScript.sendAsyncMessage("trigger-device-prompt-select");
+    });
+
+    gScript.addMessageListener("control-channel-established", function controlChannelEstablishedHandler() {
+      gScript.removeMessageListener("control-channel-established", controlChannelEstablishedHandler);
+      info("A control channel is established.");
+      gScript.sendAsyncMessage("trigger-control-channel-open");
+    });
+
+    gScript.addMessageListener("control-channel-opened", function controlChannelOpenedHandler(aReason) {
+      gScript.removeMessageListener("control-channel-opened", controlChannelOpenedHandler);
+      info("The control channel is opened.");
+    });
+
+    gScript.addMessageListener("control-channel-closed", function controlChannelClosedHandler(aReason) {
+      gScript.removeMessageListener("control-channel-closed", controlChannelClosedHandler);
+      info("The control channel is closed. " + aReason);
+    });
+
+    gScript.addMessageListener("offer-sent", function offerSentHandler(aIsValid) {
+      gScript.removeMessageListener("offer-sent", offerSentHandler);
+      ok(aIsValid, "A valid offer is sent out.");
+      gScript.sendAsyncMessage("trigger-incoming-answer");
+    });
+
+    gScript.addMessageListener("answer-received", function answerReceivedHandler() {
+      gScript.removeMessageListener("answer-received", answerReceivedHandler);
+      info("An answer is received.");
+      gScript.sendAsyncMessage("trigger-incoming-transport");
+    });
+
+    gScript.addMessageListener("data-transport-initialized", function dataTransportInitializedHandler() {
+      gScript.removeMessageListener("data-transport-initialized", dataTransportInitializedHandler);
+      info("Data transport channel is initialized.");
+    });
+
+    gScript.addMessageListener("data-transport-notification-enabled", function dataTransportNotificationEnabledHandler() {
+      gScript.removeMessageListener("data-transport-notification-enabled", dataTransportNotificationEnabledHandler);
+      info("Data notification is enabled for data transport channel.");
+    });
+
+    request.start().then(
+      function(aConnection) {
+        connection = aConnection;
+        ok(connection, "Connection should be available.");
+        ok(connection.id, "Connection ID should be set.");
+        is(connection.state, "connecting", "The initial state should be connecting.");
+        connection.onconnect = function() {
+          connection.onconnect = null;
+          is(connection.state, "connected", "Connection should be connected.");
+          aResolve();
+        };
+      },
+      function(aError) {
+        ok(false, "Error occurred when establishing a connection: " + aError);
+        teardown();
+        aReject();
+      }
+    );
+  });
+}
+
+function testDisconnection() {
+  return new Promise(function(aResolve, aReject) {
+    gScript.addMessageListener("data-transport-closed", function dataTransportClosedHandler(aReason) {
+      gScript.removeMessageListener("data-transport-closed", dataTransportClosedHandler);
+      info("The data transport is closed. " + aReason);
+    });
+
+    connection.onclose = function() {
+      connection.onclose = null;
+      is(connection.state, "closed", "Connection should be closed.");
+      aResolve();
+    };
+
+    gScript.sendAsyncMessage("trigger-data-transport-close", SpecialPowers.Cr.NS_ERROR_FAILURE);
+  });
+}
+
+function teardown() {
+  gScript.addMessageListener("teardown-complete", function teardownCompleteHandler() {
+    gScript.removeMessageListener("teardown-complete", teardownCompleteHandler);
+    gScript.destroy();
+    SimpleTest.finish();
+  });
+
+  gScript.sendAsyncMessage("teardown");
+}
+
+function runTests() {
+  ok(window.PresentationRequest, "PresentationRequest should be available.");
+
+  testSetup().
+  then(testStartConnection).
+  then(testDisconnection).
+  then(teardown);
+}
+
+SimpleTest.waitForExplicitFinish();
+SpecialPowers.pushPermissions([
+  {type: "presentation-device-manage", allow: false, context: document},
+], function() {
+  SpecialPowers.pushPrefEnv({ "set": [["dom.presentation.enabled", true],
+                                      ["dom.presentation.controller.enabled", true],
+                                      ["dom.presentation.session_transport.data_channel.enable", false]]},
+                            runTests);
+});
+
+</script>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_tcp_sender_establish_connection_error.html b/dom/presentation/tests/mochitest/test_presentation_tcp_sender_establish_connection_error.html
new file mode 100644
index 0000000000..af3fa93024
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_tcp_sender_establish_connection_error.html
@@ -0,0 +1,514 @@
+<!DOCTYPE HTML>
+<html>
+<!-- Any copyright is dedicated to the Public Domain.
+   - http://creativecommons.org/publicdomain/zero/1.0/ -->
+<head>
+  <meta charset="utf-8">
+  <title>Test for connection establishing errors of B2G Presentation API at sender side</title>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+</head>
+<body>
+<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=1069230">Test for connection establishing errors of B2G Presentation API at sender side</a>
+<script type="application/javascript">
+
+"use strict";
+
+var gScript = SpecialPowers.loadChromeScript(SimpleTest.getTestFileURL("PresentationSessionChromeScript.js"));
+var request;
+
+function setup() {
+  return new Promise(function(aResolve, aReject) {
+    request = new PresentationRequest("http://example.com");
+
+    request.getAvailability().then(
+      function(aAvailability) {
+        is(aAvailability.value, false, "Sender: should have no available device after setup");
+        aAvailability.onchange = function() {
+          aAvailability.onchange = null;
+          ok(aAvailability.value, "Device should be available.");
+          aResolve();
+        };
+
+        gScript.sendAsyncMessage("trigger-device-add");
+      },
+      function(aError) {
+        ok(false, "Error occurred when getting availability: " + aError);
+        teardown();
+        aReject();
+      }
+    );
+  });
+}
+
+function testStartConnectionCancelPrompt() {
+  info("--- testStartConnectionCancelPrompt ---");
+  return Promise.all([
+    new Promise((resolve) => {
+      gScript.addMessageListener("device-prompt", function devicePromptHandler() {
+        gScript.removeMessageListener("device-prompt", devicePromptHandler);
+        info("Device prompt is triggered.");
+        gScript.sendAsyncMessage("trigger-device-prompt-cancel", SpecialPowers.Cr.NS_ERROR_DOM_NOT_ALLOWED_ERR);
+        resolve();
+      });
+    }),
+    request.start().then(
+      function(aConnection) {
+        ok(false, "|start| shouldn't succeed in this case.");
+      },
+      function(aError) {
+        is(aError.name, "NotAllowedError", "NotAllowedError is expected when the prompt is canceled.");
+      }
+    ),
+  ]);
+}
+
+function testStartConnectionNoDevice() {
+  info("--- testStartConnectionNoDevice ---");
+  return Promise.all([
+    new Promise((resolve) => {
+      gScript.addMessageListener("device-prompt", function devicePromptHandler() {
+        gScript.removeMessageListener("device-prompt", devicePromptHandler);
+        info("Device prompt is triggered.");
+        gScript.sendAsyncMessage("trigger-device-prompt-cancel", SpecialPowers.Cr.NS_ERROR_DOM_NOT_FOUND_ERR);
+        resolve();
+      });
+    }),
+    request.start().then(
+      function(aConnection) {
+        ok(false, "|start| shouldn't succeed in this case.");
+      },
+      function(aError) {
+        is(aError.name, "NotFoundError", "NotFoundError is expected when no available device.");
+      }
+    ),
+  ]);
+}
+
+function testStartConnectionUnexpectedControlChannelCloseBeforeDataTransportInit() {
+  info("--- testStartConnectionUnexpectedControlChannelCloseBeforeDataTransportInit ---");
+  return Promise.all([
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("device-prompt", function devicePromptHandler() {
+        gScript.removeMessageListener("device-prompt", devicePromptHandler);
+        info("Device prompt is triggered.");
+        gScript.sendAsyncMessage("trigger-device-prompt-select");
+        resolve();
+      });
+    }),
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("control-channel-established", function controlChannelEstablishedHandler() {
+        gScript.removeMessageListener("control-channel-established", controlChannelEstablishedHandler);
+        info("A control channel is established.");
+        gScript.sendAsyncMessage("trigger-control-channel-open");
+        resolve();
+      });
+    }),
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("control-channel-opened", function controlChannelOpenedHandler() {
+        gScript.removeMessageListener("control-channel-opened", controlChannelOpenedHandler);
+        info("The control channel is opened.");
+        resolve();
+      });
+    }),
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("control-channel-closed", function controlChannelClosedHandler(aReason) {
+        gScript.removeMessageListener("control-channel-closed", controlChannelClosedHandler);
+        info("The control channel is closed. " + aReason);
+        is(aReason, SpecialPowers.Cr.NS_ERROR_FAILURE, "The control channel is closed with NS_ERROR_FAILURE");
+        resolve();
+      });
+    }),
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("offer-sent", function offerSentHandler(aIsValid) {
+        gScript.removeMessageListener("offer-sent", offerSentHandler);
+        ok(aIsValid, "A valid offer is sent out.");
+        gScript.sendAsyncMessage("trigger-control-channel-close", SpecialPowers.Cr.NS_ERROR_FAILURE);
+        resolve();
+      });
+    }),
+
+    request.start().then(
+      function(aConnection) {
+        is(aConnection.state, "connecting", "The initial state should be connecting.");
+        return new Promise((resolve) => {
+          aConnection.onclose = function() {
+            aConnection.onclose = null;
+            is(aConnection.state, "closed", "Connection should be closed.");
+            resolve();
+          };
+        });
+      },
+      function(aError) {
+        ok(false, "Error occurred when establishing a connection: " + aError);
+        teardown();
+      }
+    ),
+
+  ]);
+}
+
+function testStartConnectionUnexpectedControlChannelCloseNoReasonBeforeDataTransportInit() {
+  info("--- testStartConnectionUnexpectedControlChannelCloseNoReasonBeforeDataTransportInit ---");
+  return Promise.all([
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("device-prompt", function devicePromptHandler() {
+        gScript.removeMessageListener("device-prompt", devicePromptHandler);
+        info("Device prompt is triggered.");
+        gScript.sendAsyncMessage("trigger-device-prompt-select");
+        resolve();
+      });
+    }),
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("control-channel-established", function controlChannelEstablishedHandler() {
+        gScript.removeMessageListener("control-channel-established", controlChannelEstablishedHandler);
+        info("A control channel is established.");
+        gScript.sendAsyncMessage("trigger-control-channel-open");
+        resolve();
+      });
+    }),
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("control-channel-opened", function controlChannelOpenedHandler() {
+        gScript.removeMessageListener("control-channel-opened", controlChannelOpenedHandler);
+        info("The control channel is opened.");
+        resolve();
+      });
+    }),
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("control-channel-closed", function controlChannelClosedHandler(aReason) {
+        gScript.removeMessageListener("control-channel-closed", controlChannelClosedHandler);
+        info("The control channel is closed. " + aReason);
+        is(aReason, SpecialPowers.Cr.NS_OK, "The control channel is closed with NS_OK");
+        resolve();
+      });
+    }),
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("offer-sent", function offerSentHandler(aIsValid) {
+        gScript.removeMessageListener("offer-sent", offerSentHandler);
+        ok(aIsValid, "A valid offer is sent out.");
+        gScript.sendAsyncMessage("trigger-control-channel-close", SpecialPowers.Cr.NS_OK);
+        resolve();
+      });
+    }),
+
+    request.start().then(
+      function(aConnection) {
+        is(aConnection.state, "connecting", "The initial state should be connecting.");
+        return new Promise((resolve) => {
+          aConnection.onclose = function() {
+            aConnection.onclose = null;
+            is(aConnection.state, "closed", "Connection should be closed.");
+            resolve();
+          };
+        });
+      },
+      function(aError) {
+        ok(false, "Error occurred when establishing a connection: " + aError);
+        teardown();
+      }
+    ),
+
+  ]);
+}
+
+function testStartConnectionUnexpectedControlChannelCloseBeforeDataTransportReady() {
+  info("--- testStartConnectionUnexpectedControlChannelCloseBeforeDataTransportReady ---");
+  return Promise.all([
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("device-prompt", function devicePromptHandler() {
+        gScript.removeMessageListener("device-prompt", devicePromptHandler);
+        info("Device prompt is triggered.");
+        gScript.sendAsyncMessage("trigger-device-prompt-select");
+        resolve();
+      });
+    }),
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("control-channel-established", function controlChannelEstablishedHandler() {
+        gScript.removeMessageListener("control-channel-established", controlChannelEstablishedHandler);
+        info("A control channel is established.");
+        gScript.sendAsyncMessage("trigger-control-channel-open");
+        resolve();
+      });
+    }),
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("control-channel-opened", function controlChannelOpenedHandler() {
+        gScript.removeMessageListener("control-channel-opened", controlChannelOpenedHandler);
+        info("The control channel is opened.");
+        resolve();
+      });
+    }),
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("control-channel-closed", function controlChannelClosedHandler(aReason) {
+        gScript.removeMessageListener("control-channel-closed", controlChannelClosedHandler);
+        is(aReason, SpecialPowers.Cr.NS_ERROR_ABORT, "The control channel is closed with NS_ERROR_ABORT");
+        resolve();
+      });
+    }),
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("offer-sent", function offerSentHandler(aIsValid) {
+        gScript.removeMessageListener("offer-sent", offerSentHandler);
+        ok(aIsValid, "A valid offer is sent out.");
+        gScript.sendAsyncMessage("trigger-incoming-transport");
+        resolve();
+      });
+    }),
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("data-transport-initialized", function dataTransportInitializedHandler() {
+        gScript.removeMessageListener("data-transport-initialized", dataTransportInitializedHandler);
+        info("Data transport channel is initialized.");
+        gScript.sendAsyncMessage("trigger-control-channel-close", SpecialPowers.Cr.NS_ERROR_ABORT);
+        resolve();
+      });
+    }),
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("data-transport-closed", function dataTransportClosedHandler(aReason) {
+        gScript.removeMessageListener("data-transport-closed", dataTransportClosedHandler);
+        info("The data transport is closed. " + aReason);
+        resolve();
+      });
+    }),
+
+    request.start().then(
+      function(aConnection) {
+        is(aConnection.state, "connecting", "The initial state should be connecting.");
+        return new Promise((resolve) => {
+          aConnection.onclose = function() {
+            aConnection.onclose = null;
+            is(aConnection.state, "closed", "Connection should be closed.");
+            resolve();
+          };
+        });
+      },
+      function(aError) {
+        ok(false, "Error occurred when establishing a connection: " + aError);
+        teardown();
+      }
+    ),
+
+  ]);
+}
+
+function testStartConnectionUnexpectedControlChannelCloseNoReasonBeforeDataTransportReady() {
+  info("--- testStartConnectionUnexpectedControlChannelCloseNoReasonBeforeDataTransportReady -- ");
+  return Promise.all([
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("device-prompt", function devicePromptHandler() {
+        gScript.removeMessageListener("device-prompt", devicePromptHandler);
+        info("Device prompt is triggered.");
+        gScript.sendAsyncMessage("trigger-device-prompt-select");
+        resolve();
+      });
+    }),
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("control-channel-established", function controlChannelEstablishedHandler() {
+        gScript.removeMessageListener("control-channel-established", controlChannelEstablishedHandler);
+        info("A control channel is established.");
+        gScript.sendAsyncMessage("trigger-control-channel-open");
+        resolve();
+      });
+    }),
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("control-channel-opened", function controlChannelOpenedHandler() {
+        gScript.removeMessageListener("control-channel-opened", controlChannelOpenedHandler);
+        info("The control channel is opened.");
+        resolve();
+      });
+    }),
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("control-channel-closed", function controlChannelClosedHandler(aReason) {
+        gScript.removeMessageListener("control-channel-closed", controlChannelClosedHandler);
+        info("The control channel is closed. " + aReason);
+        is(aReason, SpecialPowers.Cr.NS_OK, "The control channel is closed with NS_OK");
+        resolve();
+      });
+    }),
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("offer-sent", function offerSentHandler(aIsValid) {
+        gScript.removeMessageListener("offer-sent", offerSentHandler);
+        ok(aIsValid, "A valid offer is sent out.");
+        gScript.sendAsyncMessage("trigger-incoming-transport");
+        resolve();
+      });
+    }),
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("data-transport-initialized", function dataTransportInitializedHandler() {
+        gScript.removeMessageListener("data-transport-initialized", dataTransportInitializedHandler);
+        info("Data transport channel is initialized.");
+        gScript.sendAsyncMessage("trigger-control-channel-close", SpecialPowers.Cr.NS_OK);
+        resolve();
+      });
+    }),
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("data-transport-closed", function dataTransportClosedHandler(aReason) {
+        gScript.removeMessageListener("data-transport-closed", dataTransportClosedHandler);
+        info("The data transport is closed. " + aReason);
+        resolve();
+      });
+    }),
+
+    request.start().then(
+      function(aConnection) {
+        is(aConnection.state, "connecting", "The initial state should be connecting.");
+        return new Promise((resolve) => {
+          aConnection.onclose = function() {
+            aConnection.onclose = null;
+            is(aConnection.state, "closed", "Connection should be closed.");
+            resolve();
+          };
+        });
+      },
+      function(aError) {
+        ok(false, "Error occurred when establishing a connection: " + aError);
+        teardown();
+      }
+    ),
+
+  ]);
+}
+
+function testStartConnectionUnexpectedDataTransportClose() {
+  info("--- testStartConnectionUnexpectedDataTransportClose ---");
+  return Promise.all([
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("device-prompt", function devicePromptHandler() {
+        gScript.removeMessageListener("device-prompt", devicePromptHandler);
+        info("Device prompt is triggered.");
+        gScript.sendAsyncMessage("trigger-device-prompt-select");
+        resolve();
+      });
+    }),
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("control-channel-established", function controlChannelEstablishedHandler() {
+        gScript.removeMessageListener("control-channel-established", controlChannelEstablishedHandler);
+        info("A control channel is established.");
+        gScript.sendAsyncMessage("trigger-control-channel-open");
+        resolve();
+      });
+    }),
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("control-channel-opened", function controlChannelOpenedHandler() {
+        gScript.removeMessageListener("control-channel-opened", controlChannelOpenedHandler);
+        info("The control channel is opened.");
+        resolve();
+      });
+    }),
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("control-channel-closed", function controlChannelClosedHandler(aReason) {
+        gScript.removeMessageListener("control-channel-closed", controlChannelClosedHandler);
+        info("The control channel is closed. " + aReason);
+        resolve();
+      });
+    }),
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("offer-sent", function offerSentHandler(aIsValid) {
+        gScript.removeMessageListener("offer-sent", offerSentHandler);
+        ok(aIsValid, "A valid offer is sent out.");
+        info("recv offer-sent.");
+        gScript.sendAsyncMessage("trigger-incoming-transport");
+        resolve();
+      });
+    }),
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("data-transport-initialized", function dataTransportInitializedHandler() {
+        gScript.removeMessageListener("data-transport-initialized", dataTransportInitializedHandler);
+        info("Data transport channel is initialized.");
+        gScript.sendAsyncMessage("trigger-data-transport-close", SpecialPowers.Cr.NS_ERROR_UNEXPECTED);
+        resolve();
+      });
+    }),
+
+    new Promise((resolve) => {
+      gScript.addMessageListener("data-transport-closed", function dataTransportClosedHandler(aReason) {
+        gScript.removeMessageListener("data-transport-closed", dataTransportClosedHandler);
+        info("The data transport is closed. " + aReason);
+        resolve();
+      });
+    }),
+
+    request.start().then(
+      function(aConnection) {
+        is(aConnection.state, "connecting", "The initial state should be connecting.");
+        return new Promise((resolve) => {
+          aConnection.onclose = function() {
+            aConnection.onclose = null;
+            is(aConnection.state, "closed", "Connection should be closed.");
+            resolve();
+          };
+        });
+      },
+      function(aError) {
+        ok(false, "Error occurred when establishing a connection: " + aError);
+        teardown();
+      }
+    ),
+
+  ]);
+}
+
+function teardown() {
+  gScript.addMessageListener("teardown-complete", function teardownCompleteHandler() {
+    gScript.removeMessageListener("teardown-complete", teardownCompleteHandler);
+    gScript.destroy();
+    SimpleTest.finish();
+  });
+
+  gScript.sendAsyncMessage("teardown");
+}
+
+function runTests() {
+  ok(window.PresentationRequest, "PresentationRequest should be available.");
+
+  setup().
+  then(testStartConnectionCancelPrompt).
+  then(testStartConnectionNoDevice).
+  then(testStartConnectionUnexpectedControlChannelCloseBeforeDataTransportInit).
+  then(testStartConnectionUnexpectedControlChannelCloseNoReasonBeforeDataTransportInit).
+  then(testStartConnectionUnexpectedControlChannelCloseBeforeDataTransportReady).
+  then(testStartConnectionUnexpectedControlChannelCloseNoReasonBeforeDataTransportReady).
+  then(testStartConnectionUnexpectedDataTransportClose).
+  then(teardown);
+}
+
+SimpleTest.waitForExplicitFinish();
+SpecialPowers.pushPermissions([
+  {type: "presentation-device-manage", allow: false, context: document},
+], function() {
+  SpecialPowers.pushPrefEnv({ "set": [["dom.presentation.enabled", true],
+                                      ["dom.presentation.controller.enabled", true],
+                                      ["dom.presentation.session_transport.data_channel.enable", false]]},
+                            runTests);
+});
+
+</script>
+</body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_terminate.js b/dom/presentation/tests/mochitest/test_presentation_terminate.js
new file mode 100644
index 0000000000..ed43986534
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_terminate.js
@@ -0,0 +1,325 @@
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+SimpleTest.requestFlakyTimeout("Test for guarantee not firing async event");
+
+function debug(str) {
+  // info(str);
+}
+
+var gScript = SpecialPowers.loadChromeScript(
+  SimpleTest.getTestFileURL("PresentationSessionChromeScript1UA.js")
+);
+var receiverUrl = SimpleTest.getTestFileURL("file_presentation_terminate.html");
+var request;
+var connection;
+var receiverIframe;
+
+function setup() {
+  gScript.addMessageListener("device-prompt", function devicePromptHandler() {
+    debug("Got message: device-prompt");
+    gScript.removeMessageListener("device-prompt", devicePromptHandler);
+    gScript.sendAsyncMessage("trigger-device-prompt-select");
+  });
+
+  gScript.addMessageListener(
+    "control-channel-established",
+    function controlChannelEstablishedHandler() {
+      gScript.removeMessageListener(
+        "control-channel-established",
+        controlChannelEstablishedHandler
+      );
+      gScript.sendAsyncMessage("trigger-control-channel-open");
+    }
+  );
+
+  gScript.addMessageListener("sender-launch", function senderLaunchHandler(
+    url
+  ) {
+    debug("Got message: sender-launch");
+    gScript.removeMessageListener("sender-launch", senderLaunchHandler);
+    is(url, receiverUrl, "Receiver: should receive the same url");
+    receiverIframe = document.createElement("iframe");
+    receiverIframe.setAttribute("mozbrowser", "true");
+    receiverIframe.setAttribute("mozpresentation", receiverUrl);
+    var oop = !location.pathname.includes("_inproc");
+    receiverIframe.setAttribute("remote", oop);
+
+    receiverIframe.setAttribute("src", receiverUrl);
+    receiverIframe.addEventListener(
+      "mozbrowserloadend",
+      function() {
+        info("Receiver loaded.");
+      },
+      { once: true }
+    );
+
+    // This event is triggered when the iframe calls 'alert'.
+    receiverIframe.addEventListener(
+      "mozbrowsershowmodalprompt",
+      function receiverListener(evt) {
+        var message = evt.detail.message;
+        if (/^OK /.exec(message)) {
+          ok(true, message.replace(/^OK /, ""));
+        } else if (/^KO /.exec(message)) {
+          ok(false, message.replace(/^KO /, ""));
+        } else if (/^INFO /.exec(message)) {
+          info(message.replace(/^INFO /, ""));
+        } else if (/^COMMAND /.exec(message)) {
+          var command = JSON.parse(message.replace(/^COMMAND /, ""));
+          gScript.sendAsyncMessage(command.name, command.data);
+        } else if (/^DONE$/.exec(message)) {
+          ok(true, "Messaging from iframe complete.");
+          receiverIframe.removeEventListener(
+            "mozbrowsershowmodalprompt",
+            receiverListener
+          );
+        }
+      }
+    );
+
+    var promise = new Promise(function(aResolve, aReject) {
+      document.body.appendChild(receiverIframe);
+      aResolve(receiverIframe);
+    });
+
+    var obs = SpecialPowers.Services.obs;
+    obs.notifyObservers(promise, "setup-request-promise");
+  });
+
+  gScript.addMessageListener(
+    "promise-setup-ready",
+    function promiseSetupReadyHandler() {
+      debug("Got message: promise-setup-ready");
+      gScript.removeMessageListener(
+        "promise-setup-ready",
+        promiseSetupReadyHandler
+      );
+      gScript.sendAsyncMessage("trigger-on-session-request", receiverUrl);
+    }
+  );
+
+  return Promise.resolve();
+}
+
+function testCreateRequest() {
+  return new Promise(function(aResolve, aReject) {
+    info("Sender: --- testCreateRequest ---");
+    request = new PresentationRequest(receiverUrl);
+    request
+      .getAvailability()
+      .then(aAvailability => {
+        is(
+          aAvailability.value,
+          false,
+          "Sender: should have no available device after setup"
+        );
+        aAvailability.onchange = function() {
+          aAvailability.onchange = null;
+          ok(aAvailability.value, "Sender: Device should be available.");
+          aResolve();
+        };
+
+        gScript.sendAsyncMessage("trigger-device-add");
+      })
+      .catch(aError => {
+        ok(
+          false,
+          "Sender: Error occurred when getting availability: " + aError
+        );
+        teardown();
+        aReject();
+      });
+  });
+}
+
+function testStartConnection() {
+  return new Promise(function(aResolve, aReject) {
+    request
+      .start()
+      .then(aConnection => {
+        connection = aConnection;
+        ok(connection, "Sender: Connection should be available.");
+        ok(connection.id, "Sender: Connection ID should be set.");
+        is(
+          connection.state,
+          "connecting",
+          "Sender: The initial state should be connecting."
+        );
+        connection.onconnect = function() {
+          connection.onconnect = null;
+          is(connection.state, "connected", "Connection should be connected.");
+          aResolve();
+        };
+
+        info("Sender: test terminate at connecting state");
+        connection.onterminate = function() {
+          connection.onterminate = null;
+          ok(false, "Should not be able to terminate at connecting state");
+          aReject();
+        };
+        connection.terminate();
+      })
+      .catch(aError => {
+        ok(
+          false,
+          "Sender: Error occurred when establishing a connection: " + aError
+        );
+        teardown();
+        aReject();
+      });
+  });
+}
+
+function testConnectionTerminate() {
+  return new Promise(function(aResolve, aReject) {
+    info("Sender: --- testConnectionTerminate---");
+    connection.onterminate = function() {
+      connection.onterminate = null;
+      is(
+        connection.state,
+        "terminated",
+        "Sender: Connection should be terminated."
+      );
+    };
+    gScript.addMessageListener(
+      "control-channel-established",
+      function controlChannelEstablishedHandler() {
+        gScript.removeMessageListener(
+          "control-channel-established",
+          controlChannelEstablishedHandler
+        );
+        gScript.sendAsyncMessage("trigger-control-channel-open");
+      }
+    );
+    gScript.addMessageListener(
+      "sender-terminate",
+      function senderTerminateHandler() {
+        gScript.removeMessageListener(
+          "sender-terminate",
+          senderTerminateHandler
+        );
+
+        Promise.all([
+          new Promise(resolve => {
+            gScript.addMessageListener(
+              "device-disconnected",
+              function deviceDisconnectedHandler() {
+                gScript.removeMessageListener(
+                  "device-disconnected",
+                  deviceDisconnectedHandler
+                );
+                ok(true, "observe device disconnect");
+                resolve();
+              }
+            );
+          }),
+          new Promise(resolve => {
+            receiverIframe.addEventListener("mozbrowserclose", function() {
+              ok(true, "observe receiver page closing");
+              resolve();
+            });
+          }),
+        ]).then(aResolve);
+
+        gScript.sendAsyncMessage("trigger-on-terminate-request");
+      }
+    );
+    gScript.addMessageListener(
+      "ready-to-terminate",
+      function onReadyToTerminate() {
+        gScript.removeMessageListener("ready-to-terminate", onReadyToTerminate);
+        connection.terminate();
+
+        // test unexpected close right after terminate
+        connection.onclose = function() {
+          ok(false, "close after terminate should do nothing");
+        };
+        connection.close();
+      }
+    );
+  });
+}
+
+function testSendAfterTerminate() {
+  return new Promise(function(aResolve, aReject) {
+    try {
+      connection.send("something");
+      ok(false, "PresentationConnection.send should be failed");
+    } catch (e) {
+      is(e.name, "InvalidStateError", "Must throw InvalidStateError");
+    }
+    aResolve();
+  });
+}
+
+function testCloseAfterTerminate() {
+  return Promise.race([
+    new Promise(function(aResolve, aReject) {
+      connection.onclose = function() {
+        connection.onclose = null;
+        ok(false, "close at terminated state should do nothing");
+        aResolve();
+      };
+      connection.close();
+    }),
+    new Promise(function(aResolve, aReject) {
+      setTimeout(function() {
+        is(
+          connection.state,
+          "terminated",
+          "Sender: Connection should be terminated."
+        );
+        aResolve();
+      }, 3000);
+    }),
+  ]);
+}
+
+function teardown() {
+  gScript.addMessageListener(
+    "teardown-complete",
+    function teardownCompleteHandler() {
+      debug("Got message: teardown-complete");
+      gScript.removeMessageListener(
+        "teardown-complete",
+        teardownCompleteHandler
+      );
+      gScript.destroy();
+      SimpleTest.finish();
+    }
+  );
+  gScript.sendAsyncMessage("teardown");
+}
+
+function runTests() {
+  setup()
+    .then(testCreateRequest)
+    .then(testStartConnection)
+    .then(testConnectionTerminate)
+    .then(testSendAfterTerminate)
+    .then(testCloseAfterTerminate)
+    .then(teardown);
+}
+
+SpecialPowers.pushPermissions(
+  [
+    { type: "presentation-device-manage", allow: false, context: document },
+    { type: "browser", allow: true, context: document },
+  ],
+  () => {
+    SpecialPowers.pushPrefEnv(
+      {
+        set: [
+          ["dom.presentation.enabled", true],
+          ["dom.presentation.controller.enabled", true],
+          ["dom.presentation.receiver.enabled", true],
+          ["dom.presentation.test.enabled", true],
+          ["dom.ipc.tabs.disabled", false],
+          ["dom.presentation.test.stage", 0],
+        ],
+      },
+      runTests
+    );
+  }
+);
diff --git a/dom/presentation/tests/mochitest/test_presentation_terminate_establish_connection_error.js b/dom/presentation/tests/mochitest/test_presentation_terminate_establish_connection_error.js
new file mode 100644
index 0000000000..7a541911f3
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_terminate_establish_connection_error.js
@@ -0,0 +1,266 @@
+"use strict";
+
+SimpleTest.waitForExplicitFinish();
+SimpleTest.requestFlakyTimeout("Test for guarantee not firing async event");
+
+function debug(str) {
+  // info(str);
+}
+
+var gScript = SpecialPowers.loadChromeScript(
+  SimpleTest.getTestFileURL("PresentationSessionChromeScript1UA.js")
+);
+var receiverUrl = SimpleTest.getTestFileURL(
+  "file_presentation_terminate_establish_connection_error.html"
+);
+var request;
+var connection;
+var receiverIframe;
+
+function postMessageToIframe(aType) {
+  receiverIframe.src =
+    receiverUrl + "#" + encodeURIComponent(JSON.stringify({ type: aType }));
+}
+
+function setup() {
+  gScript.addMessageListener("device-prompt", function devicePromptHandler() {
+    debug("Got message: device-prompt");
+    gScript.removeMessageListener("device-prompt", devicePromptHandler);
+    gScript.sendAsyncMessage("trigger-device-prompt-select");
+  });
+
+  gScript.addMessageListener(
+    "control-channel-established",
+    function controlChannelEstablishedHandler() {
+      gScript.removeMessageListener(
+        "control-channel-established",
+        controlChannelEstablishedHandler
+      );
+      gScript.sendAsyncMessage("trigger-control-channel-open");
+    }
+  );
+
+  gScript.addMessageListener("sender-launch", function senderLaunchHandler(
+    url
+  ) {
+    debug("Got message: sender-launch");
+    gScript.removeMessageListener("sender-launch", senderLaunchHandler);
+    is(url, receiverUrl, "Receiver: should receive the same url");
+    receiverIframe = document.createElement("iframe");
+    receiverIframe.setAttribute("mozbrowser", "true");
+    receiverIframe.setAttribute("mozpresentation", receiverUrl);
+    var oop = !location.pathname.includes("_inproc");
+    receiverIframe.setAttribute("remote", oop);
+
+    receiverIframe.setAttribute("src", receiverUrl);
+    receiverIframe.addEventListener(
+      "mozbrowserloadend",
+      function() {
+        info("Receiver loaded.");
+      },
+      { once: true }
+    );
+
+    // This event is triggered when the iframe calls 'alert'.
+    receiverIframe.addEventListener(
+      "mozbrowsershowmodalprompt",
+      function receiverListener(evt) {
+        var message = evt.detail.message;
+        if (/^OK /.exec(message)) {
+          ok(true, message.replace(/^OK /, ""));
+        } else if (/^KO /.exec(message)) {
+          ok(false, message.replace(/^KO /, ""));
+        } else if (/^INFO /.exec(message)) {
+          info(message.replace(/^INFO /, ""));
+        } else if (/^COMMAND /.exec(message)) {
+          var command = JSON.parse(message.replace(/^COMMAND /, ""));
+          gScript.sendAsyncMessage(command.name, command.data);
+        } else if (/^DONE$/.exec(message)) {
+          ok(true, "Messaging from iframe complete.");
+          receiverIframe.removeEventListener(
+            "mozbrowsershowmodalprompt",
+            receiverListener
+          );
+        }
+      }
+    );
+
+    var promise = new Promise(function(aResolve, aReject) {
+      document.body.appendChild(receiverIframe);
+      aResolve(receiverIframe);
+    });
+
+    var obs = SpecialPowers.Services.obs;
+    obs.notifyObservers(promise, "setup-request-promise");
+  });
+
+  gScript.addMessageListener(
+    "promise-setup-ready",
+    function promiseSetupReadyHandler() {
+      debug("Got message: promise-setup-ready");
+      gScript.removeMessageListener(
+        "promise-setup-ready",
+        promiseSetupReadyHandler
+      );
+      gScript.sendAsyncMessage("trigger-on-session-request", receiverUrl);
+    }
+  );
+
+  return Promise.resolve();
+}
+
+function testCreateRequest() {
+  return new Promise(function(aResolve, aReject) {
+    info("Sender: --- testCreateRequest ---");
+    request = new PresentationRequest(receiverUrl);
+    request
+      .getAvailability()
+      .then(aAvailability => {
+        is(
+          aAvailability.value,
+          false,
+          "Sender: should have no available device after setup"
+        );
+        aAvailability.onchange = function() {
+          aAvailability.onchange = null;
+          ok(aAvailability.value, "Sender: Device should be available.");
+          aResolve();
+        };
+
+        gScript.sendAsyncMessage("trigger-device-add");
+      })
+      .catch(aError => {
+        ok(
+          false,
+          "Sender: Error occurred when getting availability: " + aError
+        );
+        teardown();
+        aReject();
+      });
+  });
+}
+
+function testStartConnection() {
+  return new Promise(function(aResolve, aReject) {
+    request
+      .start()
+      .then(aConnection => {
+        connection = aConnection;
+        ok(connection, "Sender: Connection should be available.");
+        ok(connection.id, "Sender: Connection ID should be set.");
+        is(
+          connection.state,
+          "connecting",
+          "Sender: The initial state should be connecting."
+        );
+        connection.onconnect = function() {
+          connection.onconnect = null;
+          is(connection.state, "connected", "Connection should be connected.");
+          aResolve();
+        };
+      })
+      .catch(aError => {
+        ok(
+          false,
+          "Sender: Error occurred when establishing a connection: " + aError
+        );
+        teardown();
+        aReject();
+      });
+  });
+}
+
+function testConnectionTerminate() {
+  info("Sender: --- testConnectionTerminate---");
+  let promise = Promise.all([
+    new Promise(function(aResolve, aReject) {
+      connection.onclose = function() {
+        connection.onclose = null;
+        is(connection.state, "closed", "Sender: Connection should be closed.");
+        aResolve();
+      };
+    }),
+    new Promise(function(aResolve, aReject) {
+      function deviceDisconnectedHandler() {
+        gScript.removeMessageListener(
+          "device-disconnected",
+          deviceDisconnectedHandler
+        );
+        ok(true, "should not receive device disconnect");
+        aResolve();
+      }
+
+      gScript.addMessageListener(
+        "device-disconnected",
+        deviceDisconnectedHandler
+      );
+    }),
+    new Promise(function(aResolve, aReject) {
+      receiverIframe.addEventListener("mozbrowserclose", function() {
+        ok(true, "observe receiver page closing");
+        aResolve();
+      });
+    }),
+  ]);
+
+  gScript.addMessageListener(
+    "prepare-for-terminate",
+    function prepareForTerminateHandler() {
+      debug("Got message: prepare-for-terminate");
+      gScript.removeMessageListener(
+        "prepare-for-terminate",
+        prepareForTerminateHandler
+      );
+      gScript.sendAsyncMessage("trigger-control-channel-error");
+      postMessageToIframe("ready-to-terminate");
+    }
+  );
+
+  return promise;
+}
+
+function teardown() {
+  gScript.addMessageListener(
+    "teardown-complete",
+    function teardownCompleteHandler() {
+      debug("Got message: teardown-complete");
+      gScript.removeMessageListener(
+        "teardown-complete",
+        teardownCompleteHandler
+      );
+      gScript.destroy();
+      SimpleTest.finish();
+    }
+  );
+  gScript.sendAsyncMessage("teardown");
+}
+
+function runTests() {
+  setup()
+    .then(testCreateRequest)
+    .then(testStartConnection)
+    .then(testConnectionTerminate)
+    .then(teardown);
+}
+
+SpecialPowers.pushPermissions(
+  [
+    { type: "presentation-device-manage", allow: false, context: document },
+    { type: "browser", allow: true, context: document },
+  ],
+  () => {
+    SpecialPowers.pushPrefEnv(
+      {
+        set: [
+          ["dom.presentation.enabled", true],
+          ["dom.presentation.controller.enabled", true],
+          ["dom.presentation.receiver.enabled", true],
+          ["dom.presentation.test.enabled", true],
+          ["dom.ipc.tabs.disabled", false],
+          ["dom.presentation.test.stage", 0],
+        ],
+      },
+      runTests
+    );
+  }
+);
diff --git a/dom/presentation/tests/mochitest/test_presentation_terminate_establish_connection_error_inproc.html b/dom/presentation/tests/mochitest/test_presentation_terminate_establish_connection_error_inproc.html
new file mode 100644
index 0000000000..9d702c2e1e
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_terminate_establish_connection_error_inproc.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<!-- vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: -->
+<html>
+  <!-- Any copyright is dedicated to the Public Domain.
+    - http://creativecommons.org/publicdomain/zero/1.0/ -->
+  <head>
+    <meta charset='utf-8'>
+    <title>Test for control channel establish error during PresentationConnection.terminate()</title>
+    <link rel='stylesheet' type='text/css' href='/tests/SimpleTest/test.css'/>
+    <script type='application/javascript' src='/tests/SimpleTest/SimpleTest.js'></script>
+  </head>
+  <body>
+    <a target='_blank' href='https://bugzilla.mozilla.org/show_bug.cgi?id=1289292'>
+      Test for constrol channel establish error during PresentationConnection.terminate()</a>
+    <script type='application/javascript' src='test_presentation_terminate_establish_connection_error.js'>
+    </script>
+  </body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_terminate_establish_connection_error_oop.html b/dom/presentation/tests/mochitest/test_presentation_terminate_establish_connection_error_oop.html
new file mode 100644
index 0000000000..9d702c2e1e
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_terminate_establish_connection_error_oop.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<!-- vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: -->
+<html>
+  <!-- Any copyright is dedicated to the Public Domain.
+    - http://creativecommons.org/publicdomain/zero/1.0/ -->
+  <head>
+    <meta charset='utf-8'>
+    <title>Test for control channel establish error during PresentationConnection.terminate()</title>
+    <link rel='stylesheet' type='text/css' href='/tests/SimpleTest/test.css'/>
+    <script type='application/javascript' src='/tests/SimpleTest/SimpleTest.js'></script>
+  </head>
+  <body>
+    <a target='_blank' href='https://bugzilla.mozilla.org/show_bug.cgi?id=1289292'>
+      Test for constrol channel establish error during PresentationConnection.terminate()</a>
+    <script type='application/javascript' src='test_presentation_terminate_establish_connection_error.js'>
+    </script>
+  </body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_terminate_inproc.html b/dom/presentation/tests/mochitest/test_presentation_terminate_inproc.html
new file mode 100644
index 0000000000..24e6f1dc99
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_terminate_inproc.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<!-- vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: -->
+<html>
+  <!-- Any copyright is dedicated to the Public Domain.
+    - http://creativecommons.org/publicdomain/zero/1.0/ -->
+  <head>
+    <meta charset='utf-8'>
+    <title>Test for PresentationConnection.terminate()</title>
+    <link rel='stylesheet' type='text/css' href='/tests/SimpleTest/test.css'/>
+    <script type='application/javascript' src='/tests/SimpleTest/SimpleTest.js'></script>
+  </head>
+  <body>
+    <a target='_blank' href='https://bugzilla.mozilla.org/show_bug.cgi?id=1276378'>
+      Test for PresentationConnection.terminate()</a>
+    <script type='application/javascript' src='test_presentation_terminate.js'>
+    </script>
+  </body>
+</html>
diff --git a/dom/presentation/tests/mochitest/test_presentation_terminate_oop.html b/dom/presentation/tests/mochitest/test_presentation_terminate_oop.html
new file mode 100644
index 0000000000..24e6f1dc99
--- /dev/null
+++ b/dom/presentation/tests/mochitest/test_presentation_terminate_oop.html
@@ -0,0 +1,18 @@
+<!DOCTYPE HTML>
+<!-- vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: -->
+<html>
+  <!-- Any copyright is dedicated to the Public Domain.
+    - http://creativecommons.org/publicdomain/zero/1.0/ -->
+  <head>
+    <meta charset='utf-8'>
+    <title>Test for PresentationConnection.terminate()</title>
+    <link rel='stylesheet' type='text/css' href='/tests/SimpleTest/test.css'/>
+    <script type='application/javascript' src='/tests/SimpleTest/SimpleTest.js'></script>
+  </head>
+  <body>
+    <a target='_blank' href='https://bugzilla.mozilla.org/show_bug.cgi?id=1276378'>
+      Test for PresentationConnection.terminate()</a>
+    <script type='application/javascript' src='test_presentation_terminate.js'>
+    </script>
+  </body>
+</html>
diff --git a/dom/presentation/tests/xpcshell/test_multicast_dns_device_provider.js b/dom/presentation/tests/xpcshell/test_multicast_dns_device_provider.js
new file mode 100644
index 0000000000..4ccc0a54ef
--- /dev/null
+++ b/dom/presentation/tests/xpcshell/test_multicast_dns_device_provider.js
@@ -0,0 +1,1465 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const Cm = Components.manager;
+
+const { Promise } = ChromeUtils.import("resource://gre/modules/Promise.jsm");
+const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+
+const INFO_CONTRACT_ID =
+  "@mozilla.org/toolkit/components/mdnsresponder/dns-info;1";
+const PROVIDER_CONTRACT_ID =
+  "@mozilla.org/presentation-device/multicastdns-provider;1";
+const SD_CONTRACT_ID = "@mozilla.org/toolkit/components/mdnsresponder/dns-sd;1";
+const UUID_CONTRACT_ID = "@mozilla.org/uuid-generator;1";
+const SERVER_CONTRACT_ID = "@mozilla.org/presentation/control-service;1";
+
+const PREF_DISCOVERY = "dom.presentation.discovery.enabled";
+const PREF_DISCOVERABLE = "dom.presentation.discoverable";
+const PREF_DEVICENAME = "dom.presentation.device.name";
+
+const LATEST_VERSION = 1;
+const SERVICE_TYPE = "_presentation-ctrl._tcp";
+const versionAttr = Cc["@mozilla.org/hash-property-bag;1"].createInstance(
+  Ci.nsIWritablePropertyBag2
+);
+versionAttr.setPropertyAsUint32("version", LATEST_VERSION);
+
+var registrar = Cm.QueryInterface(Ci.nsIComponentRegistrar);
+
+function sleep(aMs) {
+  return new Promise(resolve => {
+    let timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+
+    timer.initWithCallback(
+      {
+        notify() {
+          resolve();
+        },
+      },
+      aMs,
+      timer.TYPE_ONE_SHOT
+    );
+  });
+}
+
+function MockFactory(aClass) {
+  this._cls = aClass;
+}
+MockFactory.prototype = {
+  createInstance(aOuter, aIID) {
+    if (aOuter) {
+      throw Components.Exception("", Cr.NS_ERROR_NO_AGGREGATION);
+    }
+    switch (typeof this._cls) {
+      case "function":
+        return new this._cls().QueryInterface(aIID);
+      case "object":
+        return this._cls.QueryInterface(aIID);
+      default:
+        return null;
+    }
+  },
+  lockFactory(aLock) {
+    throw Components.Exception("", Cr.NS_ERROR_NOT_IMPLEMENTED);
+  },
+  QueryInterface: ChromeUtils.generateQI(["nsIFactory"]),
+};
+
+function ContractHook(aContractID, aClass) {
+  this._contractID = aContractID;
+  this.classID = Cc[UUID_CONTRACT_ID].getService(
+    Ci.nsIUUIDGenerator
+  ).generateUUID();
+  this._newFactory = new MockFactory(aClass);
+
+  if (!this.hookedMap.has(this._contractID)) {
+    this.hookedMap.set(this._contractID, []);
+  }
+
+  this.init();
+}
+
+ContractHook.prototype = {
+  hookedMap: new Map(), // remember only the most original factory.
+
+  init() {
+    this.reset();
+
+    let oldContract = this.unregister();
+    this.hookedMap.get(this._contractID).push(oldContract);
+    registrar.registerFactory(
+      this.classID,
+      "",
+      this._contractID,
+      this._newFactory
+    );
+
+    registerCleanupFunction(() => {
+      this.cleanup.apply(this);
+    });
+  },
+
+  reset() {},
+
+  cleanup() {
+    this.reset();
+
+    this.unregister();
+    let prevContract = this.hookedMap.get(this._contractID).pop();
+
+    if (prevContract.classID) {
+      registrar.registerFactory(
+        prevContract.classID,
+        "",
+        this._contractID,
+        prevContract.factory
+      );
+    }
+  },
+
+  unregister() {
+    var classID, factory;
+
+    try {
+      classID = registrar.contractIDToCID(this._contractID);
+      factory = Cm.getClassObject(Cc[this._contractID], Ci.nsIFactory);
+    } catch (ex) {
+      classID = "";
+      factory = null;
+    }
+
+    if (factory) {
+      try {
+        registrar.unregisterFactory(classID, factory);
+      } catch (e) {
+        factory = null;
+      }
+    }
+
+    return { classID, factory };
+  },
+};
+
+function MockDNSServiceInfo() {}
+MockDNSServiceInfo.prototype = {
+  QueryInterface: ChromeUtils.generateQI(["nsIDNSServiceInfo"]),
+
+  set host(aHost) {
+    this._host = aHost;
+  },
+
+  get host() {
+    return this._host;
+  },
+
+  set address(aAddress) {
+    this._address = aAddress;
+  },
+
+  get address() {
+    return this._address;
+  },
+
+  set port(aPort) {
+    this._port = aPort;
+  },
+
+  get port() {
+    return this._port;
+  },
+
+  set serviceName(aServiceName) {
+    this._serviceName = aServiceName;
+  },
+
+  get serviceName() {
+    return this._serviceName;
+  },
+
+  set serviceType(aServiceType) {
+    this._serviceType = aServiceType;
+  },
+
+  get serviceType() {
+    return this._serviceType;
+  },
+
+  set domainName(aDomainName) {
+    this._domainName = aDomainName;
+  },
+
+  get domainName() {
+    return this._domainName;
+  },
+
+  set attributes(aAttributes) {
+    this._attributes = aAttributes;
+  },
+
+  get attributes() {
+    return this._attributes;
+  },
+};
+
+function TestPresentationDeviceListener() {
+  this.devices = {};
+}
+TestPresentationDeviceListener.prototype = {
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIPresentationDeviceListener",
+    "nsISupportsWeakReference",
+  ]),
+
+  addDevice(device) {
+    this.devices[device.id] = device;
+  },
+  removeDevice(device) {
+    delete this.devices[device.id];
+  },
+  updateDevice(device) {
+    this.devices[device.id] = device;
+  },
+  onSessionRequest(device, url, presentationId, controlChannel) {},
+
+  count() {
+    var size = 0,
+      key;
+    for (key in this.devices) {
+      if (this.devices.hasOwnProperty(key)) {
+        ++size;
+      }
+    }
+    return size;
+  },
+};
+
+function createDevice(
+  host,
+  port,
+  serviceName,
+  serviceType,
+  domainName,
+  attributes
+) {
+  let device = new MockDNSServiceInfo();
+  device.host = host || "";
+  device.port = port || 0;
+  device.address = host || "";
+  device.serviceName = serviceName || "";
+  device.serviceType = serviceType || "";
+  device.domainName = domainName || "";
+  device.attributes = attributes || versionAttr;
+  return device;
+}
+
+function registerService() {
+  Services.prefs.setBoolPref(PREF_DISCOVERABLE, true);
+
+  let deferred = Promise.defer();
+
+  let mockObj = {
+    QueryInterface: ChromeUtils.generateQI(["nsIDNSServiceDiscovery"]),
+    startDiscovery(serviceType, listener) {},
+    registerService(serviceInfo, listener) {
+      deferred.resolve();
+      this.serviceRegistered++;
+      return {
+        QueryInterface: ChromeUtils.generateQI(["nsICancelable"]),
+        cancel: () => {
+          this.serviceUnregistered++;
+        },
+      };
+    },
+    resolveService(serviceInfo, listener) {},
+    serviceRegistered: 0,
+    serviceUnregistered: 0,
+  };
+  new ContractHook(SD_CONTRACT_ID, mockObj);
+  let provider = Cc[PROVIDER_CONTRACT_ID].createInstance(
+    Ci.nsIPresentationDeviceProvider
+  );
+
+  Assert.equal(mockObj.serviceRegistered, 0);
+  Assert.equal(mockObj.serviceUnregistered, 0);
+
+  // Register
+  provider.listener = {
+    QueryInterface: ChromeUtils.generateQI([
+      "nsIPresentationDeviceListener",
+      "nsISupportsWeakReference",
+    ]),
+    addDevice(device) {},
+    removeDevice(device) {},
+    updateDevice(device) {},
+  };
+
+  deferred.promise.then(function() {
+    Assert.equal(mockObj.serviceRegistered, 1);
+    Assert.equal(mockObj.serviceUnregistered, 0);
+
+    // Unregister
+    provider.listener = null;
+    Assert.equal(mockObj.serviceRegistered, 1);
+    Assert.equal(mockObj.serviceUnregistered, 1);
+
+    run_next_test();
+  });
+}
+
+function noRegisterService() {
+  Services.prefs.setBoolPref(PREF_DISCOVERABLE, false);
+
+  let deferred = Promise.defer();
+
+  let mockObj = {
+    QueryInterface: ChromeUtils.generateQI(["nsIDNSServiceDiscovery"]),
+    startDiscovery(serviceType, listener) {},
+    registerService(serviceInfo, listener) {
+      deferred.resolve();
+      Assert.ok(false, "should not register service if not discoverable");
+    },
+    resolveService(serviceInfo, listener) {},
+  };
+
+  new ContractHook(SD_CONTRACT_ID, mockObj);
+  let provider = Cc[PROVIDER_CONTRACT_ID].createInstance(
+    Ci.nsIPresentationDeviceProvider
+  );
+
+  // Try register
+  provider.listener = {
+    QueryInterface: ChromeUtils.generateQI([
+      "nsIPresentationDeviceListener",
+      "nsISupportsWeakReference",
+    ]),
+    addDevice(device) {},
+    removeDevice(device) {},
+    updateDevice(device) {},
+  };
+
+  let race = Promise.race([deferred.promise, sleep(1000)]);
+
+  race.then(() => {
+    provider.listener = null;
+
+    run_next_test();
+  });
+}
+
+function registerServiceDynamically() {
+  Services.prefs.setBoolPref(PREF_DISCOVERABLE, false);
+
+  let deferred = Promise.defer();
+
+  let mockObj = {
+    QueryInterface: ChromeUtils.generateQI(["nsIDNSServiceDiscovery"]),
+    startDiscovery(serviceType, listener) {},
+    registerService(serviceInfo, listener) {
+      deferred.resolve();
+      this.serviceRegistered++;
+      return {
+        QueryInterface: ChromeUtils.generateQI(["nsICancelable"]),
+        cancel: () => {
+          this.serviceUnregistered++;
+        },
+      };
+    },
+    resolveService(serviceInfo, listener) {},
+    serviceRegistered: 0,
+    serviceUnregistered: 0,
+  };
+  new ContractHook(SD_CONTRACT_ID, mockObj);
+  let provider = Cc[PROVIDER_CONTRACT_ID].createInstance(
+    Ci.nsIPresentationDeviceProvider
+  );
+
+  Assert.equal(mockObj.serviceRegistered, 0);
+  Assert.equal(mockObj.serviceRegistered, 0);
+
+  // Try Register
+  provider.listener = {
+    QueryInterface: ChromeUtils.generateQI([
+      "nsIPresentationDeviceListener",
+      "nsISupportsWeakReference",
+    ]),
+    addDevice(device) {},
+    removeDevice(device) {},
+    updateDevice(device) {},
+  };
+
+  Assert.equal(mockObj.serviceRegistered, 0);
+  Assert.equal(mockObj.serviceUnregistered, 0);
+
+  // Enable registration
+  Services.prefs.setBoolPref(PREF_DISCOVERABLE, true);
+
+  deferred.promise.then(function() {
+    Assert.equal(mockObj.serviceRegistered, 1);
+    Assert.equal(mockObj.serviceUnregistered, 0);
+
+    // Disable registration
+    Services.prefs.setBoolPref(PREF_DISCOVERABLE, false);
+    Assert.equal(mockObj.serviceRegistered, 1);
+    Assert.equal(mockObj.serviceUnregistered, 1);
+
+    // Try unregister
+    provider.listener = null;
+    Assert.equal(mockObj.serviceRegistered, 1);
+    Assert.equal(mockObj.serviceUnregistered, 1);
+
+    run_next_test();
+  });
+}
+
+function addDevice() {
+  Services.prefs.setBoolPref(PREF_DISCOVERY, true);
+
+  let mockDevice = createDevice(
+    "device.local",
+    12345,
+    "service.name",
+    SERVICE_TYPE
+  );
+  let mockObj = {
+    QueryInterface: ChromeUtils.generateQI(["nsIDNSServiceDiscovery"]),
+    startDiscovery(serviceType, listener) {
+      listener.onDiscoveryStarted(serviceType);
+      listener.onServiceFound(
+        createDevice("", 0, mockDevice.serviceName, mockDevice.serviceType)
+      );
+      return {
+        QueryInterface: ChromeUtils.generateQI(["nsICancelable"]),
+        cancel() {},
+      };
+    },
+    registerService(serviceInfo, listener) {},
+    resolveService(serviceInfo, listener) {
+      Assert.equal(serviceInfo.serviceName, mockDevice.serviceName);
+      Assert.equal(serviceInfo.serviceType, mockDevice.serviceType);
+      listener.onServiceResolved(
+        createDevice(
+          mockDevice.host,
+          mockDevice.port,
+          mockDevice.serviceName,
+          mockDevice.serviceType
+        )
+      );
+    },
+  };
+
+  new ContractHook(SD_CONTRACT_ID, mockObj);
+  let provider = Cc[PROVIDER_CONTRACT_ID].createInstance(
+    Ci.nsIPresentationDeviceProvider
+  );
+  let listener = new TestPresentationDeviceListener();
+  Assert.equal(listener.count(), 0);
+
+  // Start discovery
+  provider.listener = listener;
+  Assert.equal(listener.count(), 1);
+
+  // Force discovery again
+  provider.forceDiscovery();
+  Assert.equal(listener.count(), 1);
+
+  provider.listener = null;
+  Assert.equal(listener.count(), 1);
+
+  run_next_test();
+}
+
+function filterDevice() {
+  Services.prefs.setBoolPref(PREF_DISCOVERY, true);
+
+  let mockDevice = createDevice(
+    "device.local",
+    12345,
+    "service.name",
+    SERVICE_TYPE
+  );
+  let mockObj = {
+    QueryInterface: ChromeUtils.generateQI(["nsIDNSServiceDiscovery"]),
+    startDiscovery(serviceType, listener) {
+      listener.onDiscoveryStarted(serviceType);
+      listener.onServiceFound(
+        createDevice("", 0, mockDevice.serviceName, mockDevice.serviceType)
+      );
+      return {
+        QueryInterface: ChromeUtils.generateQI(["nsICancelable"]),
+        cancel() {},
+      };
+    },
+    registerService(serviceInfo, listener) {},
+    resolveService(serviceInfo, listener) {
+      Assert.equal(serviceInfo.serviceName, mockDevice.serviceName);
+      Assert.equal(serviceInfo.serviceType, mockDevice.serviceType);
+      listener.onServiceResolved(
+        createDevice(
+          mockDevice.host,
+          mockDevice.port,
+          mockDevice.serviceName,
+          mockDevice.serviceType
+        )
+      );
+    },
+  };
+
+  new ContractHook(SD_CONTRACT_ID, mockObj);
+  let provider = Cc[PROVIDER_CONTRACT_ID].createInstance(
+    Ci.nsIPresentationDeviceProvider
+  );
+  let listener = {
+    QueryInterface: ChromeUtils.generateQI([
+      "nsIPresentationDeviceListener",
+      "nsISupportsWeakReference",
+    ]),
+    addDevice(device) {
+      let tests = [
+        {
+          requestedUrl: "app://fling-player.gaiamobile.org/index.html",
+          supported: true,
+        },
+        {
+          requestedUrl: "app://notification-receiver.gaiamobile.org/index.html",
+          supported: true,
+        },
+        { requestedUrl: "http://example.com", supported: true },
+        { requestedUrl: "https://example.com", supported: true },
+        { requestedUrl: "ftp://example.com", supported: false },
+        { requestedUrl: "app://unknown-app-id", supported: false },
+        { requestedUrl: "unknowSchem://example.com", supported: false },
+      ];
+
+      for (let test of tests) {
+        Assert.equal(
+          device.isRequestedUrlSupported(test.requestedUrl),
+          test.supported
+        );
+      }
+
+      provider.listener = null;
+      provider = null;
+      run_next_test();
+    },
+    updateDevice() {},
+    removeDevice() {},
+    onSessionRequest() {},
+  };
+
+  provider.listener = listener;
+}
+
+function handleSessionRequest() {
+  Services.prefs.setBoolPref(PREF_DISCOVERY, true);
+  Services.prefs.setBoolPref(PREF_DISCOVERABLE, false);
+
+  const testDeviceName = "test-device-name";
+
+  Services.prefs.setCharPref(PREF_DEVICENAME, testDeviceName);
+
+  let mockDevice = createDevice(
+    "device.local",
+    12345,
+    "service.name",
+    SERVICE_TYPE
+  );
+  let mockSDObj = {
+    QueryInterface: ChromeUtils.generateQI(["nsIDNSServiceDiscovery"]),
+    startDiscovery(serviceType, listener) {
+      listener.onDiscoveryStarted(serviceType);
+      listener.onServiceFound(
+        createDevice("", 0, mockDevice.serviceName, mockDevice.serviceType)
+      );
+      return {
+        QueryInterface: ChromeUtils.generateQI(["nsICancelable"]),
+        cancel() {},
+      };
+    },
+    registerService(serviceInfo, listener) {},
+    resolveService(serviceInfo, listener) {
+      listener.onServiceResolved(
+        createDevice(
+          mockDevice.host,
+          mockDevice.port,
+          mockDevice.serviceName,
+          mockDevice.serviceType
+        )
+      );
+    },
+  };
+
+  let mockServerObj = {
+    QueryInterface: ChromeUtils.generateQI(["nsIPresentationControlService"]),
+    connect(deviceInfo) {
+      this.request = {
+        deviceInfo,
+      };
+      return {
+        QueryInterface: ChromeUtils.generateQI([
+          "nsIPresentationControlChannel",
+        ]),
+      };
+    },
+    id: "",
+    version: LATEST_VERSION,
+    isCompatibleServer(version) {
+      return this.version === version;
+    },
+  };
+
+  new ContractHook(SD_CONTRACT_ID, mockSDObj);
+  new ContractHook(SERVER_CONTRACT_ID, mockServerObj);
+  let provider = Cc[PROVIDER_CONTRACT_ID].createInstance(
+    Ci.nsIPresentationDeviceProvider
+  );
+  let listener = {
+    QueryInterface: ChromeUtils.generateQI([
+      "nsIPresentationDeviceListener",
+      "nsISupportsWeakReference",
+    ]),
+    addDevice(device) {
+      this.device = device;
+    },
+  };
+
+  provider.listener = listener;
+
+  listener.device.establishControlChannel();
+
+  Assert.equal(mockServerObj.request.deviceInfo.id, mockDevice.host);
+  Assert.equal(mockServerObj.request.deviceInfo.address, mockDevice.host);
+  Assert.equal(mockServerObj.request.deviceInfo.port, mockDevice.port);
+  Assert.equal(mockServerObj.id, testDeviceName);
+
+  provider.listener = null;
+
+  run_next_test();
+}
+
+function handleOnSessionRequest() {
+  Services.prefs.setBoolPref(PREF_DISCOVERY, true);
+  Services.prefs.setBoolPref(PREF_DISCOVERABLE, true);
+
+  let mockDevice = createDevice(
+    "device.local",
+    12345,
+    "service.name",
+    SERVICE_TYPE
+  );
+  let mockSDObj = {
+    QueryInterface: ChromeUtils.generateQI(["nsIDNSServiceDiscovery"]),
+    startDiscovery(serviceType, listener) {
+      listener.onDiscoveryStarted(serviceType);
+      listener.onServiceFound(
+        createDevice("", 0, mockDevice.serviceName, mockDevice.serviceType)
+      );
+      return {
+        QueryInterface: ChromeUtils.generateQI(["nsICancelable"]),
+        cancel() {},
+      };
+    },
+    registerService(serviceInfo, listener) {},
+    resolveService(serviceInfo, listener) {
+      listener.onServiceResolved(
+        createDevice(
+          mockDevice.host,
+          mockDevice.port,
+          mockDevice.serviceName,
+          mockDevice.serviceType
+        )
+      );
+    },
+  };
+
+  let mockServerObj = {
+    QueryInterface: ChromeUtils.generateQI(["nsIPresentationControlService"]),
+    startServer() {},
+    sessionRequest() {},
+    close() {},
+    id: "",
+    version: LATEST_VERSION,
+    port: 0,
+    listener: null,
+  };
+
+  new ContractHook(SD_CONTRACT_ID, mockSDObj);
+  new ContractHook(SERVER_CONTRACT_ID, mockServerObj);
+  let provider = Cc[PROVIDER_CONTRACT_ID].createInstance(
+    Ci.nsIPresentationDeviceProvider
+  );
+  let listener = {
+    QueryInterface: ChromeUtils.generateQI([
+      "nsIPresentationDeviceListener",
+      "nsISupportsWeakReference",
+    ]),
+    addDevice(device) {},
+    removeDevice(device) {},
+    updateDevice(device) {},
+    onSessionRequest(device, url, presentationId, controlChannel) {
+      Assert.ok(true, "receive onSessionRequest event");
+      this.request = {
+        deviceId: device.id,
+        url,
+        presentationId,
+      };
+    },
+  };
+
+  provider.listener = listener;
+
+  const deviceInfo = {
+    QueryInterface: ChromeUtils.generateQI(["nsITCPDeviceInfo"]),
+    id: mockDevice.host,
+    address: mockDevice.host,
+    port: 54321,
+  };
+
+  const testUrl = "http://example.com";
+  const testPresentationId = "test-presentation-id";
+  const testControlChannel = {
+    QueryInterface: ChromeUtils.generateQI(["nsIPresentationControlChannel"]),
+  };
+  provider
+    .QueryInterface(Ci.nsIPresentationControlServerListener)
+    .onSessionRequest(
+      deviceInfo,
+      testUrl,
+      testPresentationId,
+      testControlChannel
+    );
+
+  Assert.equal(listener.request.deviceId, deviceInfo.id);
+  Assert.equal(listener.request.url, testUrl);
+  Assert.equal(listener.request.presentationId, testPresentationId);
+
+  provider.listener = null;
+
+  run_next_test();
+}
+
+function handleOnSessionRequestFromUnknownDevice() {
+  Services.prefs.setBoolPref(PREF_DISCOVERY, false);
+  Services.prefs.setBoolPref(PREF_DISCOVERABLE, true);
+
+  let mockSDObj = {
+    QueryInterface: ChromeUtils.generateQI(["nsIDNSServiceDiscovery"]),
+    startDiscovery(serviceType, listener) {},
+    registerService(serviceInfo, listener) {},
+    resolveService(serviceInfo, listener) {},
+  };
+
+  let mockServerObj = {
+    QueryInterface: ChromeUtils.generateQI(["nsIPresentationControlService"]),
+    startServer() {},
+    sessionRequest() {},
+    close() {},
+    id: "",
+    version: LATEST_VERSION,
+    port: 0,
+    listener: null,
+  };
+
+  new ContractHook(SD_CONTRACT_ID, mockSDObj);
+  new ContractHook(SERVER_CONTRACT_ID, mockServerObj);
+  let provider = Cc[PROVIDER_CONTRACT_ID].createInstance(
+    Ci.nsIPresentationDeviceProvider
+  );
+  let listener = {
+    QueryInterface: ChromeUtils.generateQI([
+      "nsIPresentationDeviceListener",
+      "nsISupportsWeakReference",
+    ]),
+    addDevice(device) {
+      Assert.ok(false, "shouldn't create any new device");
+    },
+    removeDevice(device) {
+      Assert.ok(false, "shouldn't remote any device");
+    },
+    updateDevice(device) {
+      Assert.ok(false, "shouldn't update any device");
+    },
+    onSessionRequest(device, url, presentationId, controlChannel) {
+      Assert.ok(true, "receive onSessionRequest event");
+      this.request = {
+        deviceId: device.id,
+        url,
+        presentationId,
+      };
+    },
+  };
+
+  provider.listener = listener;
+
+  const deviceInfo = {
+    QueryInterface: ChromeUtils.generateQI(["nsITCPDeviceInfo"]),
+    id: "unknown-device.local",
+    address: "unknown-device.local",
+    port: 12345,
+  };
+
+  const testUrl = "http://example.com";
+  const testPresentationId = "test-presentation-id";
+  const testControlChannel = {
+    QueryInterface: ChromeUtils.generateQI(["nsIPresentationControlChannel"]),
+  };
+  provider
+    .QueryInterface(Ci.nsIPresentationControlServerListener)
+    .onSessionRequest(
+      deviceInfo,
+      testUrl,
+      testPresentationId,
+      testControlChannel
+    );
+
+  Assert.equal(listener.request.deviceId, deviceInfo.id);
+  Assert.equal(listener.request.url, testUrl);
+  Assert.equal(listener.request.presentationId, testPresentationId);
+
+  provider.listener = null;
+
+  run_next_test();
+}
+
+function noAddDevice() {
+  Services.prefs.setBoolPref(PREF_DISCOVERY, false);
+
+  let mockObj = {
+    QueryInterface: ChromeUtils.generateQI(["nsIDNSServiceDiscovery"]),
+    startDiscovery(serviceType, listener) {
+      Assert.ok(false, "shouldn't perform any device discovery");
+    },
+    registerService(serviceInfo, listener) {},
+    resolveService(serviceInfo, listener) {},
+  };
+  new ContractHook(SD_CONTRACT_ID, mockObj);
+
+  let provider = Cc[PROVIDER_CONTRACT_ID].createInstance(
+    Ci.nsIPresentationDeviceProvider
+  );
+  let listener = {
+    QueryInterface: ChromeUtils.generateQI([
+      "nsIPresentationDeviceListener",
+      "nsISupportsWeakReference",
+    ]),
+    addDevice(device) {},
+    removeDevice(device) {},
+    updateDevice(device) {},
+  };
+  provider.listener = listener;
+  provider.forceDiscovery();
+  provider.listener = null;
+
+  run_next_test();
+}
+
+function ignoreIncompatibleDevice() {
+  Services.prefs.setBoolPref(PREF_DISCOVERY, false);
+  Services.prefs.setBoolPref(PREF_DISCOVERABLE, true);
+
+  let mockDevice = createDevice(
+    "device.local",
+    12345,
+    "service.name",
+    SERVICE_TYPE
+  );
+
+  let deferred = Promise.defer();
+
+  let mockSDObj = {
+    QueryInterface: ChromeUtils.generateQI(["nsIDNSServiceDiscovery"]),
+    startDiscovery(serviceType, listener) {
+      listener.onDiscoveryStarted(serviceType);
+      listener.onServiceFound(
+        createDevice("", 0, mockDevice.serviceName, mockDevice.serviceType)
+      );
+      return {
+        QueryInterface: ChromeUtils.generateQI(["nsICancelable"]),
+        cancel() {},
+      };
+    },
+    registerService(serviceInfo, listener) {
+      deferred.resolve();
+      listener.onServiceRegistered(
+        createDevice("", 54321, mockDevice.serviceName, mockDevice.serviceType)
+      );
+      return {
+        QueryInterface: ChromeUtils.generateQI(["nsICancelable"]),
+        cancel() {},
+      };
+    },
+    resolveService(serviceInfo, listener) {
+      Assert.equal(serviceInfo.serviceName, mockDevice.serviceName);
+      Assert.equal(serviceInfo.serviceType, mockDevice.serviceType);
+      listener.onServiceResolved(
+        createDevice(
+          mockDevice.host,
+          mockDevice.port,
+          mockDevice.serviceName,
+          mockDevice.serviceType
+        )
+      );
+    },
+  };
+
+  let mockServerObj = {
+    QueryInterface: ChromeUtils.generateQI(["nsIPresentationControlService"]),
+    startServer() {
+      Services.tm.dispatchToMainThread(() => {
+        this.listener.onServerReady(this.port, this.certFingerprint);
+      });
+    },
+    sessionRequest() {},
+    close() {},
+    id: "",
+    version: LATEST_VERSION,
+    isCompatibleServer(version) {
+      return false;
+    },
+    port: 54321,
+    certFingerprint: "mock-cert-fingerprint",
+    listener: null,
+  };
+
+  new ContractHook(SD_CONTRACT_ID, mockSDObj);
+  new ContractHook(SERVER_CONTRACT_ID, mockServerObj);
+  let provider = Cc[PROVIDER_CONTRACT_ID].createInstance(
+    Ci.nsIPresentationDeviceProvider
+  );
+  let listener = new TestPresentationDeviceListener();
+
+  // Register service
+  provider.listener = listener;
+
+  deferred.promise.then(function() {
+    Assert.equal(mockServerObj.id, mockDevice.host);
+
+    // Start discovery
+    Services.prefs.setBoolPref(PREF_DISCOVERY, true);
+    Assert.equal(listener.count(), 0);
+
+    provider.listener = null;
+    provider = null;
+
+    run_next_test();
+  });
+}
+
+function ignoreSelfDevice() {
+  Services.prefs.setBoolPref(PREF_DISCOVERY, false);
+  Services.prefs.setBoolPref(PREF_DISCOVERABLE, true);
+
+  let mockDevice = createDevice(
+    "device.local",
+    12345,
+    "service.name",
+    SERVICE_TYPE
+  );
+
+  let deferred = Promise.defer();
+  let mockSDObj = {
+    QueryInterface: ChromeUtils.generateQI(["nsIDNSServiceDiscovery"]),
+    startDiscovery(serviceType, listener) {
+      listener.onDiscoveryStarted(serviceType);
+      listener.onServiceFound(
+        createDevice("", 0, mockDevice.serviceName, mockDevice.serviceType)
+      );
+      return {
+        QueryInterface: ChromeUtils.generateQI(["nsICancelable"]),
+        cancel() {},
+      };
+    },
+    registerService(serviceInfo, listener) {
+      deferred.resolve();
+      listener.onServiceRegistered(
+        createDevice("", 0, mockDevice.serviceName, mockDevice.serviceType)
+      );
+      return {
+        QueryInterface: ChromeUtils.generateQI(["nsICancelable"]),
+        cancel() {},
+      };
+    },
+    resolveService(serviceInfo, listener) {
+      Assert.equal(serviceInfo.serviceName, mockDevice.serviceName);
+      Assert.equal(serviceInfo.serviceType, mockDevice.serviceType);
+      listener.onServiceResolved(
+        createDevice(
+          mockDevice.host,
+          mockDevice.port,
+          mockDevice.serviceName,
+          mockDevice.serviceType
+        )
+      );
+    },
+  };
+
+  let mockServerObj = {
+    QueryInterface: ChromeUtils.generateQI(["nsIPresentationControlService"]),
+    startServer() {
+      Services.tm.dispatchToMainThread(() => {
+        this.listener.onServerReady(this.port, this.certFingerprint);
+      });
+    },
+    sessionRequest() {},
+    close() {},
+    id: "",
+    version: LATEST_VERSION,
+    isCompatibleServer(version) {
+      return this.version === version;
+    },
+    port: 54321,
+    certFingerprint: "mock-cert-fingerprint",
+    listener: null,
+  };
+
+  new ContractHook(SD_CONTRACT_ID, mockSDObj);
+  new ContractHook(SERVER_CONTRACT_ID, mockServerObj);
+  let provider = Cc[PROVIDER_CONTRACT_ID].createInstance(
+    Ci.nsIPresentationDeviceProvider
+  );
+  let listener = new TestPresentationDeviceListener();
+
+  // Register service
+  provider.listener = listener;
+  deferred.promise.then(() => {
+    Assert.equal(mockServerObj.id, mockDevice.host);
+
+    // Start discovery
+    Services.prefs.setBoolPref(PREF_DISCOVERY, true);
+    Assert.equal(listener.count(), 0);
+
+    provider.listener = null;
+    provider = null;
+
+    run_next_test();
+  });
+}
+
+function addDeviceDynamically() {
+  Services.prefs.setBoolPref(PREF_DISCOVERY, false);
+
+  let mockDevice = createDevice(
+    "device.local",
+    12345,
+    "service.name",
+    SERVICE_TYPE
+  );
+  let mockObj = {
+    QueryInterface: ChromeUtils.generateQI(["nsIDNSServiceDiscovery"]),
+    startDiscovery(serviceType, listener) {
+      listener.onDiscoveryStarted(serviceType);
+      listener.onServiceFound(
+        createDevice("", 0, mockDevice.serviceName, mockDevice.serviceType)
+      );
+      return {
+        QueryInterface: ChromeUtils.generateQI(["nsICancelable"]),
+        cancel() {},
+      };
+    },
+    registerService(serviceInfo, listener) {},
+    resolveService(serviceInfo, listener) {
+      Assert.equal(serviceInfo.serviceName, mockDevice.serviceName);
+      Assert.equal(serviceInfo.serviceType, mockDevice.serviceType);
+      listener.onServiceResolved(
+        createDevice(
+          mockDevice.host,
+          mockDevice.port,
+          mockDevice.serviceName,
+          mockDevice.serviceType
+        )
+      );
+    },
+  };
+
+  new ContractHook(SD_CONTRACT_ID, mockObj);
+  let provider = Cc[PROVIDER_CONTRACT_ID].createInstance(
+    Ci.nsIPresentationDeviceProvider
+  );
+  let listener = new TestPresentationDeviceListener();
+  provider.listener = listener;
+  Assert.equal(listener.count(), 0);
+
+  // Enable discovery
+  Services.prefs.setBoolPref(PREF_DISCOVERY, true);
+  Assert.equal(listener.count(), 1);
+
+  // Try discovery again
+  provider.forceDiscovery();
+  Assert.equal(listener.count(), 1);
+
+  // Try discovery once more
+  Services.prefs.setBoolPref(PREF_DISCOVERY, false);
+  Services.prefs.setBoolPref(PREF_DISCOVERY, true);
+  provider.forceDiscovery();
+  Assert.equal(listener.count(), 1);
+
+  provider.listener = null;
+
+  run_next_test();
+}
+
+function updateDevice() {
+  Services.prefs.setBoolPref(PREF_DISCOVERY, true);
+
+  let mockDevice1 = createDevice("A.local", 12345, "N1", SERVICE_TYPE);
+  let mockDevice2 = createDevice("A.local", 23456, "N2", SERVICE_TYPE);
+
+  let mockObj = {
+    discovered: false,
+
+    QueryInterface: ChromeUtils.generateQI(["nsIDNSServiceDiscovery"]),
+    startDiscovery(serviceType, listener) {
+      listener.onDiscoveryStarted(serviceType);
+
+      if (!this.discovered) {
+        listener.onServiceFound(mockDevice1);
+      } else {
+        listener.onServiceFound(mockDevice2);
+      }
+      this.discovered = true;
+
+      return {
+        QueryInterface: ChromeUtils.generateQI(["nsICancelable"]),
+        cancel() {
+          listener.onDiscoveryStopped(serviceType);
+        },
+      };
+    },
+    registerService(serviceInfo, listener) {},
+    resolveService(serviceInfo, listener) {
+      Assert.equal(serviceInfo.serviceType, SERVICE_TYPE);
+      if (serviceInfo.serviceName == "N1") {
+        listener.onServiceResolved(mockDevice1);
+      } else if (serviceInfo.serviceName == "N2") {
+        listener.onServiceResolved(mockDevice2);
+      } else {
+        Assert.ok(false);
+      }
+    },
+  };
+
+  new ContractHook(SD_CONTRACT_ID, mockObj);
+  let provider = Cc[PROVIDER_CONTRACT_ID].createInstance(
+    Ci.nsIPresentationDeviceProvider
+  );
+  let listener = {
+    QueryInterface: ChromeUtils.generateQI([
+      "nsIPresentationDeviceListener",
+      "nsISupportsWeakReference",
+    ]),
+
+    addDevice(device) {
+      Assert.ok(!this.isDeviceAdded);
+      Assert.equal(device.id, mockDevice1.host);
+      Assert.equal(device.name, mockDevice1.serviceName);
+      this.isDeviceAdded = true;
+    },
+    removeDevice(device) {
+      Assert.ok(false);
+    },
+    updateDevice(device) {
+      Assert.ok(!this.isDeviceUpdated);
+      Assert.equal(device.id, mockDevice2.host);
+      Assert.equal(device.name, mockDevice2.serviceName);
+      this.isDeviceUpdated = true;
+    },
+
+    isDeviceAdded: false,
+    isDeviceUpdated: false,
+  };
+  Assert.equal(listener.isDeviceAdded, false);
+  Assert.equal(listener.isDeviceUpdated, false);
+
+  // Start discovery
+  provider.listener = listener; // discover: N1
+
+  Assert.equal(listener.isDeviceAdded, true);
+  Assert.equal(listener.isDeviceUpdated, false);
+
+  // temporarily disable to stop discovery and re-enable
+  Services.prefs.setBoolPref(PREF_DISCOVERY, false);
+  Services.prefs.setBoolPref(PREF_DISCOVERY, true);
+
+  provider.forceDiscovery(); // discover: N2
+
+  Assert.equal(listener.isDeviceAdded, true);
+  Assert.equal(listener.isDeviceUpdated, true);
+
+  provider.listener = null;
+
+  run_next_test();
+}
+
+function diffDiscovery() {
+  Services.prefs.setBoolPref(PREF_DISCOVERY, true);
+
+  let mockDevice1 = createDevice("A.local", 12345, "N1", SERVICE_TYPE);
+  let mockDevice2 = createDevice("B.local", 23456, "N2", SERVICE_TYPE);
+  let mockDevice3 = createDevice("C.local", 45678, "N3", SERVICE_TYPE);
+
+  let mockObj = {
+    discovered: false,
+
+    QueryInterface: ChromeUtils.generateQI(["nsIDNSServiceDiscovery"]),
+    startDiscovery(serviceType, listener) {
+      listener.onDiscoveryStarted(serviceType);
+
+      if (!this.discovered) {
+        listener.onServiceFound(mockDevice1);
+        listener.onServiceFound(mockDevice2);
+      } else {
+        listener.onServiceFound(mockDevice1);
+        listener.onServiceFound(mockDevice3);
+      }
+      this.discovered = true;
+
+      return {
+        QueryInterface: ChromeUtils.generateQI(["nsICancelable"]),
+        cancel() {
+          listener.onDiscoveryStopped(serviceType);
+        },
+      };
+    },
+    registerService(serviceInfo, listener) {},
+    resolveService(serviceInfo, listener) {
+      Assert.equal(serviceInfo.serviceType, SERVICE_TYPE);
+      if (serviceInfo.serviceName == "N1") {
+        listener.onServiceResolved(mockDevice1);
+      } else if (serviceInfo.serviceName == "N2") {
+        listener.onServiceResolved(mockDevice2);
+      } else if (serviceInfo.serviceName == "N3") {
+        listener.onServiceResolved(mockDevice3);
+      } else {
+        Assert.ok(false);
+      }
+    },
+  };
+
+  new ContractHook(SD_CONTRACT_ID, mockObj);
+  let provider = Cc[PROVIDER_CONTRACT_ID].createInstance(
+    Ci.nsIPresentationDeviceProvider
+  );
+  let listener = new TestPresentationDeviceListener();
+  Assert.equal(listener.count(), 0);
+
+  // Start discovery
+  provider.listener = listener; // discover: N1, N2
+  Assert.equal(listener.count(), 2);
+  Assert.equal(listener.devices["A.local"].name, mockDevice1.serviceName);
+  Assert.equal(listener.devices["B.local"].name, mockDevice2.serviceName);
+  Assert.ok(!listener.devices["C.local"]);
+
+  // temporarily disable to stop discovery and re-enable
+  Services.prefs.setBoolPref(PREF_DISCOVERY, false);
+  Services.prefs.setBoolPref(PREF_DISCOVERY, true);
+
+  provider.forceDiscovery(); // discover: N1, N3, going to remove: N2
+  Assert.equal(listener.count(), 3);
+  Assert.equal(listener.devices["A.local"].name, mockDevice1.serviceName);
+  Assert.equal(listener.devices["B.local"].name, mockDevice2.serviceName);
+  Assert.equal(listener.devices["C.local"].name, mockDevice3.serviceName);
+
+  // temporarily disable to stop discovery and re-enable
+  Services.prefs.setBoolPref(PREF_DISCOVERY, false);
+  Services.prefs.setBoolPref(PREF_DISCOVERY, true);
+
+  provider.forceDiscovery(); // discover: N1, N3, remove: N2
+  Assert.equal(listener.count(), 2);
+  Assert.equal(listener.devices["A.local"].name, mockDevice1.serviceName);
+  Assert.ok(!listener.devices["B.local"]);
+  Assert.equal(listener.devices["C.local"].name, mockDevice3.serviceName);
+
+  provider.listener = null;
+
+  run_next_test();
+}
+
+function serverClosed() {
+  Services.prefs.setBoolPref(PREF_DISCOVERABLE, true);
+  Services.prefs.setBoolPref(PREF_DISCOVERY, true);
+
+  let mockDevice = createDevice(
+    "device.local",
+    12345,
+    "service.name",
+    SERVICE_TYPE
+  );
+
+  let mockObj = {
+    QueryInterface: ChromeUtils.generateQI(["nsIDNSServiceDiscovery"]),
+    startDiscovery(serviceType, listener) {
+      listener.onDiscoveryStarted(serviceType);
+      listener.onServiceFound(
+        createDevice("", 0, mockDevice.serviceName, mockDevice.serviceType)
+      );
+      return {
+        QueryInterface: ChromeUtils.generateQI(["nsICancelable"]),
+        cancel() {},
+      };
+    },
+    registerService(serviceInfo, listener) {
+      this.serviceRegistered++;
+      return {
+        QueryInterface: ChromeUtils.generateQI(["nsICancelable"]),
+        cancel: () => {
+          this.serviceUnregistered++;
+        },
+      };
+    },
+    resolveService(serviceInfo, listener) {
+      Assert.equal(serviceInfo.serviceName, mockDevice.serviceName);
+      Assert.equal(serviceInfo.serviceType, mockDevice.serviceType);
+      listener.onServiceResolved(
+        createDevice(
+          mockDevice.host,
+          mockDevice.port,
+          mockDevice.serviceName,
+          mockDevice.serviceType
+        )
+      );
+    },
+    serviceRegistered: 0,
+    serviceUnregistered: 0,
+  };
+  new ContractHook(SD_CONTRACT_ID, mockObj);
+  let provider = Cc[PROVIDER_CONTRACT_ID].createInstance(
+    Ci.nsIPresentationDeviceProvider
+  );
+
+  Assert.equal(mockObj.serviceRegistered, 0);
+  Assert.equal(mockObj.serviceUnregistered, 0);
+
+  // Register
+  let listener = {
+    QueryInterface: ChromeUtils.generateQI([
+      "nsIPresentationDeviceListener",
+      "nsISupportsWeakReference",
+    ]),
+    addDevice(device) {
+      this.devices.push(device);
+    },
+    removeDevice(device) {},
+    updateDevice(device) {},
+    devices: [],
+  };
+  Assert.equal(listener.devices.length, 0);
+
+  provider.listener = listener;
+  Assert.equal(mockObj.serviceRegistered, 1);
+  Assert.equal(mockObj.serviceUnregistered, 0);
+  Assert.equal(listener.devices.length, 1);
+
+  let serverListener = provider.QueryInterface(
+    Ci.nsIPresentationControlServerListener
+  );
+  let randomPort = 9527;
+  serverListener.onServerReady(randomPort, "");
+
+  Assert.equal(mockObj.serviceRegistered, 2);
+  Assert.equal(mockObj.serviceUnregistered, 1);
+  Assert.equal(listener.devices.length, 1);
+
+  // Unregister
+  provider.listener = null;
+  Assert.equal(mockObj.serviceRegistered, 2);
+  Assert.equal(mockObj.serviceUnregistered, 2);
+  Assert.equal(listener.devices.length, 1);
+
+  run_next_test();
+}
+
+function serverRetry() {
+  Services.prefs.setBoolPref(PREF_DISCOVERY, false);
+  Services.prefs.setBoolPref(PREF_DISCOVERABLE, true);
+
+  let isRetrying = false;
+
+  let mockSDObj = {
+    QueryInterface: ChromeUtils.generateQI(["nsIDNSServiceDiscovery"]),
+    startDiscovery(serviceType, listener) {},
+    registerService(serviceInfo, listener) {
+      Assert.ok(isRetrying, "register service after retrying startServer");
+      provider.listener = null;
+      run_next_test();
+    },
+    resolveService(serviceInfo, listener) {},
+  };
+
+  let mockServerObj = {
+    QueryInterface: ChromeUtils.generateQI(["nsIPresentationControlService"]),
+    startServer(encrypted, port) {
+      if (!isRetrying) {
+        isRetrying = true;
+        Services.tm.dispatchToMainThread(() => {
+          this.listener.onServerStopped(Cr.NS_ERROR_FAILURE);
+        });
+      } else {
+        this.port = 54321;
+        Services.tm.dispatchToMainThread(() => {
+          this.listener.onServerReady(this.port, this.certFingerprint);
+        });
+      }
+    },
+    sessionRequest() {},
+    close() {},
+    id: "",
+    version: LATEST_VERSION,
+    port: 0,
+    certFingerprint: "mock-cert-fingerprint",
+    listener: null,
+  };
+
+  new ContractHook(SD_CONTRACT_ID, mockSDObj);
+  new ContractHook(SERVER_CONTRACT_ID, mockServerObj);
+  let provider = Cc[PROVIDER_CONTRACT_ID].createInstance(
+    Ci.nsIPresentationDeviceProvider
+  );
+  let listener = {
+    QueryInterface: ChromeUtils.generateQI([
+      "nsIPresentationDeviceListener",
+      "nsISupportsWeakReference",
+    ]),
+    addDevice(device) {},
+    removeDevice(device) {},
+    updateDevice(device) {},
+    onSessionRequest(device, url, presentationId, controlChannel) {},
+  };
+
+  provider.listener = listener;
+}
+
+function run_test() {
+  // Need profile dir to store the key / cert
+  do_get_profile();
+  // Ensure PSM is initialized
+  Cc["@mozilla.org/psm;1"].getService(Ci.nsISupports);
+
+  new ContractHook(INFO_CONTRACT_ID, MockDNSServiceInfo);
+
+  registerCleanupFunction(() => {
+    Services.prefs.clearUserPref(PREF_DISCOVERY);
+    Services.prefs.clearUserPref(PREF_DISCOVERABLE);
+  });
+
+  add_test(registerService);
+  add_test(noRegisterService);
+  add_test(registerServiceDynamically);
+  add_test(addDevice);
+  add_test(filterDevice);
+  add_test(handleSessionRequest);
+  add_test(handleOnSessionRequest);
+  add_test(handleOnSessionRequestFromUnknownDevice);
+  add_test(noAddDevice);
+  add_test(ignoreIncompatibleDevice);
+  add_test(ignoreSelfDevice);
+  add_test(addDeviceDynamically);
+  add_test(updateDevice);
+  add_test(diffDiscovery);
+  add_test(serverClosed);
+  add_test(serverRetry);
+
+  run_next_test();
+}
diff --git a/dom/presentation/tests/xpcshell/test_presentation_device_manager.js b/dom/presentation/tests/xpcshell/test_presentation_device_manager.js
new file mode 100644
index 0000000000..e49a794ebc
--- /dev/null
+++ b/dom/presentation/tests/xpcshell/test_presentation_device_manager.js
@@ -0,0 +1,288 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+
+const manager = Cc["@mozilla.org/presentation-device/manager;1"].getService(
+  Ci.nsIPresentationDeviceManager
+);
+
+function TestPresentationDevice() {}
+
+function TestPresentationControlChannel() {}
+
+TestPresentationControlChannel.prototype = {
+  QueryInterface: ChromeUtils.generateQI(["nsIPresentationControlChannel"]),
+  sendOffer(offer) {},
+  sendAnswer(answer) {},
+  disconnect() {},
+  launch() {},
+  terminate() {},
+  reconnect() {},
+  set listener(listener) {},
+  get listener() {},
+};
+
+var testProvider = {
+  QueryInterface: ChromeUtils.generateQI(["nsIPresentationDeviceProvider"]),
+
+  forceDiscovery() {},
+  set listener(listener) {},
+  get listener() {},
+};
+
+const forbiddenRequestedUrl = "http://example.com";
+var testDevice = {
+  QueryInterface: ChromeUtils.generateQI(["nsIPresentationDevice"]),
+  id: "id",
+  name: "name",
+  type: "type",
+  establishControlChannel(url, presentationId) {
+    return null;
+  },
+  disconnect() {},
+  isRequestedUrlSupported(requestedUrl) {
+    return forbiddenRequestedUrl !== requestedUrl;
+  },
+};
+
+function addProvider() {
+  Object.defineProperty(testProvider, "listener", {
+    configurable: true,
+    set(listener) {
+      Assert.strictEqual(
+        listener,
+        manager,
+        "listener setter is invoked by PresentationDeviceManager"
+      );
+      delete testProvider.listener;
+      run_next_test();
+    },
+  });
+  manager.addDeviceProvider(testProvider);
+}
+
+function forceDiscovery() {
+  testProvider.forceDiscovery = function() {
+    testProvider.forceDiscovery = function() {};
+    Assert.ok(true, "forceDiscovery is invoked by PresentationDeviceManager");
+    run_next_test();
+  };
+  manager.forceDiscovery();
+}
+
+function addDevice() {
+  Services.obs.addObserver(function observer(subject, topic, data) {
+    Services.obs.removeObserver(observer, topic);
+
+    let updatedDevice = subject.QueryInterface(Ci.nsIPresentationDevice);
+    Assert.equal(updatedDevice.id, testDevice.id, "expected device id");
+    Assert.equal(updatedDevice.name, testDevice.name, "expected device name");
+    Assert.equal(updatedDevice.type, testDevice.type, "expected device type");
+    Assert.equal(data, "add", "expected update type");
+
+    Assert.ok(manager.deviceAvailable, "device is available");
+
+    let devices = manager.getAvailableDevices();
+    Assert.equal(devices.length, 1, "expect 1 available device");
+
+    let device = devices.queryElementAt(0, Ci.nsIPresentationDevice);
+    Assert.equal(device.id, testDevice.id, "expected device id");
+    Assert.equal(device.name, testDevice.name, "expected device name");
+    Assert.equal(device.type, testDevice.type, "expected device type");
+
+    run_next_test();
+  }, "presentation-device-change");
+  manager
+    .QueryInterface(Ci.nsIPresentationDeviceListener)
+    .addDevice(testDevice);
+}
+
+function updateDevice() {
+  Services.obs.addObserver(function observer(subject, topic, data) {
+    Services.obs.removeObserver(observer, topic);
+
+    let updatedDevice = subject.QueryInterface(Ci.nsIPresentationDevice);
+    Assert.equal(updatedDevice.id, testDevice.id, "expected device id");
+    Assert.equal(updatedDevice.name, testDevice.name, "expected device name");
+    Assert.equal(updatedDevice.type, testDevice.type, "expected device type");
+    Assert.equal(data, "update", "expected update type");
+
+    Assert.ok(manager.deviceAvailable, "device is available");
+
+    let devices = manager.getAvailableDevices();
+    Assert.equal(devices.length, 1, "expect 1 available device");
+
+    let device = devices.queryElementAt(0, Ci.nsIPresentationDevice);
+    Assert.equal(device.id, testDevice.id, "expected device id");
+    Assert.equal(
+      device.name,
+      testDevice.name,
+      "expected name after device update"
+    );
+    Assert.equal(device.type, testDevice.type, "expected device type");
+
+    run_next_test();
+  }, "presentation-device-change");
+  testDevice.name = "updated-name";
+  manager
+    .QueryInterface(Ci.nsIPresentationDeviceListener)
+    .updateDevice(testDevice);
+}
+
+function filterDevice() {
+  let presentationUrls = Cc["@mozilla.org/array;1"].createInstance(
+    Ci.nsIMutableArray
+  );
+  let url = Cc["@mozilla.org/supports-string;1"].createInstance(
+    Ci.nsISupportsString
+  );
+  url.data = forbiddenRequestedUrl;
+  presentationUrls.appendElement(url);
+  let devices = manager.getAvailableDevices(presentationUrls);
+  Assert.equal(devices.length, 0, "expect 0 available device for example.com");
+  run_next_test();
+}
+
+function sessionRequest() {
+  let testUrl = "http://www.example.org/";
+  let testPresentationId = "test-presentation-id";
+  let testControlChannel = new TestPresentationControlChannel();
+  Services.obs.addObserver(function observer(subject, topic, data) {
+    Services.obs.removeObserver(observer, topic);
+
+    let request = subject.QueryInterface(Ci.nsIPresentationSessionRequest);
+
+    Assert.equal(request.device.id, testDevice.id, "expected device");
+    Assert.equal(request.url, testUrl, "expected requesting URL");
+    Assert.equal(
+      request.presentationId,
+      testPresentationId,
+      "expected presentation Id"
+    );
+
+    run_next_test();
+  }, "presentation-session-request");
+  manager
+    .QueryInterface(Ci.nsIPresentationDeviceListener)
+    .onSessionRequest(
+      testDevice,
+      testUrl,
+      testPresentationId,
+      testControlChannel
+    );
+}
+
+function terminateRequest() {
+  let testPresentationId = "test-presentation-id";
+  let testControlChannel = new TestPresentationControlChannel();
+  let testIsFromReceiver = true;
+  Services.obs.addObserver(function observer(subject, topic, data) {
+    Services.obs.removeObserver(observer, topic);
+
+    let request = subject.QueryInterface(Ci.nsIPresentationTerminateRequest);
+
+    Assert.equal(request.device.id, testDevice.id, "expected device");
+    Assert.equal(
+      request.presentationId,
+      testPresentationId,
+      "expected presentation Id"
+    );
+    Assert.equal(
+      request.isFromReceiver,
+      testIsFromReceiver,
+      "expected isFromReceiver"
+    );
+
+    run_next_test();
+  }, "presentation-terminate-request");
+  manager
+    .QueryInterface(Ci.nsIPresentationDeviceListener)
+    .onTerminateRequest(
+      testDevice,
+      testPresentationId,
+      testControlChannel,
+      testIsFromReceiver
+    );
+}
+
+function reconnectRequest() {
+  let testUrl = "http://www.example.org/";
+  let testPresentationId = "test-presentation-id";
+  let testControlChannel = new TestPresentationControlChannel();
+  Services.obs.addObserver(function observer(subject, topic, data) {
+    Services.obs.removeObserver(observer, topic);
+
+    let request = subject.QueryInterface(Ci.nsIPresentationSessionRequest);
+
+    Assert.equal(request.device.id, testDevice.id, "expected device");
+    Assert.equal(request.url, testUrl, "expected requesting URL");
+    Assert.equal(
+      request.presentationId,
+      testPresentationId,
+      "expected presentation Id"
+    );
+
+    run_next_test();
+  }, "presentation-reconnect-request");
+  manager
+    .QueryInterface(Ci.nsIPresentationDeviceListener)
+    .onReconnectRequest(
+      testDevice,
+      testUrl,
+      testPresentationId,
+      testControlChannel
+    );
+}
+
+function removeDevice() {
+  Services.obs.addObserver(function observer(subject, topic, data) {
+    Services.obs.removeObserver(observer, topic);
+
+    let updatedDevice = subject.QueryInterface(Ci.nsIPresentationDevice);
+    Assert.equal(updatedDevice.id, testDevice.id, "expected device id");
+    Assert.equal(updatedDevice.name, testDevice.name, "expected device name");
+    Assert.equal(updatedDevice.type, testDevice.type, "expected device type");
+    Assert.equal(data, "remove", "expected update type");
+
+    Assert.ok(!manager.deviceAvailable, "device is not available");
+
+    let devices = manager.getAvailableDevices();
+    Assert.equal(devices.length, 0, "expect 0 available device");
+
+    run_next_test();
+  }, "presentation-device-change");
+  manager
+    .QueryInterface(Ci.nsIPresentationDeviceListener)
+    .removeDevice(testDevice);
+}
+
+function removeProvider() {
+  Object.defineProperty(testProvider, "listener", {
+    configurable: true,
+    set(listener) {
+      Assert.strictEqual(
+        listener,
+        null,
+        "unsetListener is invoked by PresentationDeviceManager"
+      );
+      delete testProvider.listener;
+      run_next_test();
+    },
+  });
+  manager.removeDeviceProvider(testProvider);
+}
+
+add_test(addProvider);
+add_test(forceDiscovery);
+add_test(addDevice);
+add_test(updateDevice);
+add_test(filterDevice);
+add_test(sessionRequest);
+add_test(terminateRequest);
+add_test(reconnectRequest);
+add_test(removeDevice);
+add_test(removeProvider);
diff --git a/dom/presentation/tests/xpcshell/test_presentation_session_transport.js b/dom/presentation/tests/xpcshell/test_presentation_session_transport.js
new file mode 100644
index 0000000000..6f5f267c4c
--- /dev/null
+++ b/dom/presentation/tests/xpcshell/test_presentation_session_transport.js
@@ -0,0 +1,225 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const CC = Components.Constructor;
+const ServerSocket = CC(
+  "@mozilla.org/network/server-socket;1",
+  "nsIServerSocket",
+  "init"
+);
+
+var testServer = null;
+var clientTransport = null;
+var serverTransport = null;
+
+var clientBuilder = null;
+var serverBuilder = null;
+
+const clientMessage = "Client Message";
+const serverMessage = "Server Message";
+
+const address = Cc["@mozilla.org/supports-cstring;1"].createInstance(
+  Ci.nsISupportsCString
+);
+address.data = "127.0.0.1";
+const addresses = Cc["@mozilla.org/array;1"].createInstance(Ci.nsIMutableArray);
+addresses.appendElement(address);
+
+const serverChannelDescription = {
+  QueryInterface: ChromeUtils.generateQI(["nsIPresentationChannelDescription"]),
+  type: 1,
+  tcpAddress: addresses,
+};
+
+var isClientReady = false;
+var isServerReady = false;
+var isClientClosed = false;
+var isServerClosed = false;
+
+const clientCallback = {
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIPresentationSessionTransportCallback",
+  ]),
+  notifyTransportReady() {
+    Assert.ok(true, "Client transport ready.");
+
+    isClientReady = true;
+    if (isClientReady && isServerReady) {
+      run_next_test();
+    }
+  },
+  notifyTransportClosed(aReason) {
+    Assert.ok(true, "Client transport is closed.");
+
+    isClientClosed = true;
+    if (isClientClosed && isServerClosed) {
+      run_next_test();
+    }
+  },
+  notifyData(aData) {
+    Assert.equal(aData, serverMessage, "Client transport receives data.");
+    run_next_test();
+  },
+};
+
+const serverCallback = {
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIPresentationSessionTransportCallback",
+  ]),
+  notifyTransportReady() {
+    Assert.ok(true, "Server transport ready.");
+
+    isServerReady = true;
+    if (isClientReady && isServerReady) {
+      run_next_test();
+    }
+  },
+  notifyTransportClosed(aReason) {
+    Assert.ok(true, "Server transport is closed.");
+
+    isServerClosed = true;
+    if (isClientClosed && isServerClosed) {
+      run_next_test();
+    }
+  },
+  notifyData(aData) {
+    Assert.equal(aData, clientMessage, "Server transport receives data.");
+    run_next_test();
+  },
+};
+
+const clientListener = {
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIPresentationSessionTransportBuilderListener",
+  ]),
+  onSessionTransport(aTransport) {
+    Assert.ok(true, "Client Transport is built.");
+    clientTransport = aTransport;
+    clientTransport.callback = clientCallback;
+
+    if (serverTransport) {
+      run_next_test();
+    }
+  },
+};
+
+const serverListener = {
+  QueryInterface: ChromeUtils.generateQI([
+    "nsIPresentationSessionTransportBuilderListener",
+  ]),
+  onSessionTransport(aTransport) {
+    Assert.ok(true, "Server Transport is built.");
+    serverTransport = aTransport;
+    serverTransport.callback = serverCallback;
+    serverTransport.enableDataNotification();
+
+    if (clientTransport) {
+      run_next_test();
+    }
+  },
+};
+
+function TestServer() {
+  this.serverSocket = ServerSocket(-1, true, -1);
+  this.serverSocket.asyncListen(this);
+}
+
+TestServer.prototype = {
+  onSocketAccepted(aSocket, aTransport) {
+    print("Test server gets a client connection.");
+    serverBuilder = Cc[
+      "@mozilla.org/presentation/presentationtcpsessiontransport;1"
+    ].createInstance(Ci.nsIPresentationTCPSessionTransportBuilder);
+    serverBuilder.buildTCPSenderTransport(aTransport, serverListener);
+  },
+  onStopListening(aSocket) {
+    print("Test server stops listening.");
+  },
+  close() {
+    if (this.serverSocket) {
+      this.serverSocket.close();
+      this.serverSocket = null;
+    }
+  },
+};
+
+// Set up the transport connection and ensure |notifyTransportReady| triggered
+// at both sides.
+function setup() {
+  clientBuilder = Cc[
+    "@mozilla.org/presentation/presentationtcpsessiontransport;1"
+  ].createInstance(Ci.nsIPresentationTCPSessionTransportBuilder);
+  clientBuilder.buildTCPReceiverTransport(
+    serverChannelDescription,
+    clientListener
+  );
+}
+
+// Test |selfAddress| attribute of |nsIPresentationSessionTransport|.
+function selfAddress() {
+  var serverSelfAddress = serverTransport.selfAddress;
+  Assert.equal(
+    serverSelfAddress.address,
+    address.data,
+    "The self address of server transport should be set."
+  );
+  Assert.equal(
+    serverSelfAddress.port,
+    testServer.serverSocket.port,
+    "The port of server transport should be set."
+  );
+
+  var clientSelfAddress = clientTransport.selfAddress;
+  Assert.ok(
+    clientSelfAddress.address,
+    "The self address of client transport should be set."
+  );
+  Assert.ok(
+    clientSelfAddress.port,
+    "The port of client transport should be set."
+  );
+
+  run_next_test();
+}
+
+// Test the client sends a message and then a corresponding notification gets
+// triggered at the server side.
+function clientSendMessage() {
+  clientTransport.send(clientMessage);
+}
+
+// Test the server sends a message an then a corresponding notification gets
+// triggered at the client side.
+function serverSendMessage() {
+  serverTransport.send(serverMessage);
+  // The client enables data notification even after the incoming message has
+  // been sent, and should still be able to consume it.
+  clientTransport.enableDataNotification();
+}
+
+function transportClose() {
+  clientTransport.close(Cr.NS_OK);
+}
+
+function shutdown() {
+  testServer.close();
+  run_next_test();
+}
+
+add_test(setup);
+add_test(selfAddress);
+add_test(clientSendMessage);
+add_test(serverSendMessage);
+add_test(transportClose);
+add_test(shutdown);
+
+function run_test() {
+  testServer = new TestServer();
+  // Get the port of the test server.
+  serverChannelDescription.tcpPort = testServer.serverSocket.port;
+
+  run_next_test();
+}
diff --git a/dom/presentation/tests/xpcshell/test_presentation_state_machine.js b/dom/presentation/tests/xpcshell/test_presentation_state_machine.js
new file mode 100644
index 0000000000..05726ab4b1
--- /dev/null
+++ b/dom/presentation/tests/xpcshell/test_presentation_state_machine.js
@@ -0,0 +1,376 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const { ControllerStateMachine } = ChromeUtils.import(
+  "resource://gre/modules/presentation/ControllerStateMachine.jsm"
+);
+const { ReceiverStateMachine } = ChromeUtils.import(
+  "resource://gre/modules/presentation/ReceiverStateMachine.jsm"
+);
+const { State } = ChromeUtils.import(
+  "resource://gre/modules/presentation/StateMachineHelper.jsm"
+);
+
+const testControllerId = "test-controller-id";
+const testPresentationId = "test-presentation-id";
+const testUrl = "http://example.org";
+
+let mockControllerChannel = {};
+let mockReceiverChannel = {};
+
+let controllerState = new ControllerStateMachine(
+  mockControllerChannel,
+  testControllerId
+);
+let receiverState = new ReceiverStateMachine(mockReceiverChannel);
+
+mockControllerChannel.sendCommand = function(command) {
+  executeSoon(function() {
+    receiverState.onCommand(command);
+  });
+};
+
+mockReceiverChannel.sendCommand = function(command) {
+  executeSoon(function() {
+    controllerState.onCommand(command);
+  });
+};
+
+function connect() {
+  Assert.equal(controllerState.state, State.INIT, "controller in init state");
+  Assert.equal(receiverState.state, State.INIT, "receiver in init state");
+  // step 1: underlying connection is ready
+  controllerState.onChannelReady();
+  Assert.equal(
+    controllerState.state,
+    State.CONNECTING,
+    "controller in connecting state"
+  );
+  receiverState.onChannelReady();
+  Assert.equal(
+    receiverState.state,
+    State.CONNECTING,
+    "receiver in connecting state"
+  );
+
+  // step 2: receiver reply to connect command
+  mockReceiverChannel.notifyDeviceConnected = function(deviceId) {
+    Assert.equal(
+      deviceId,
+      testControllerId,
+      "receiver connect to mock controller"
+    );
+    Assert.equal(
+      receiverState.state,
+      State.CONNECTED,
+      "receiver in connected state"
+    );
+
+    // step 3: controller receive connect-ack command
+    mockControllerChannel.notifyDeviceConnected = function() {
+      Assert.equal(
+        controllerState.state,
+        State.CONNECTED,
+        "controller in connected state"
+      );
+      run_next_test();
+    };
+  };
+}
+
+function launch() {
+  Assert.equal(
+    controllerState.state,
+    State.CONNECTED,
+    "controller in connected state"
+  );
+  Assert.equal(
+    receiverState.state,
+    State.CONNECTED,
+    "receiver in connected state"
+  );
+
+  controllerState.launch(testPresentationId, testUrl);
+  mockReceiverChannel.notifyLaunch = function(presentationId, url) {
+    Assert.equal(
+      receiverState.state,
+      State.CONNECTED,
+      "receiver in connected state"
+    );
+    Assert.equal(
+      presentationId,
+      testPresentationId,
+      "expected presentationId received"
+    );
+    Assert.equal(url, testUrl, "expected url received");
+
+    mockControllerChannel.notifyLaunch = function(presId) {
+      Assert.equal(
+        controllerState.state,
+        State.CONNECTED,
+        "controller in connected state"
+      );
+      Assert.equal(
+        presId,
+        testPresentationId,
+        "expected presentationId received from ack"
+      );
+
+      run_next_test();
+    };
+  };
+}
+
+function terminateByController() {
+  Assert.equal(
+    controllerState.state,
+    State.CONNECTED,
+    "controller in connected state"
+  );
+  Assert.equal(
+    receiverState.state,
+    State.CONNECTED,
+    "receiver in connected state"
+  );
+
+  controllerState.terminate(testPresentationId);
+  mockReceiverChannel.notifyTerminate = function(presentationId) {
+    Assert.equal(
+      receiverState.state,
+      State.CONNECTED,
+      "receiver in connected state"
+    );
+    Assert.equal(
+      presentationId,
+      testPresentationId,
+      "expected presentationId received"
+    );
+
+    mockControllerChannel.notifyTerminate = function(presId) {
+      Assert.equal(
+        controllerState.state,
+        State.CONNECTED,
+        "controller in connected state"
+      );
+      Assert.equal(
+        presId,
+        testPresentationId,
+        "expected presentationId received from ack"
+      );
+
+      run_next_test();
+    };
+
+    receiverState.terminateAck(presentationId);
+  };
+}
+
+function terminateByReceiver() {
+  Assert.equal(
+    controllerState.state,
+    State.CONNECTED,
+    "controller in connected state"
+  );
+  Assert.equal(
+    receiverState.state,
+    State.CONNECTED,
+    "receiver in connected state"
+  );
+
+  receiverState.terminate(testPresentationId);
+  mockControllerChannel.notifyTerminate = function(presentationId) {
+    Assert.equal(
+      controllerState.state,
+      State.CONNECTED,
+      "controller in connected state"
+    );
+    Assert.equal(
+      presentationId,
+      testPresentationId,
+      "expected presentationId received"
+    );
+
+    mockReceiverChannel.notifyTerminate = function(presId) {
+      Assert.equal(
+        receiverState.state,
+        State.CONNECTED,
+        "receiver in connected state"
+      );
+      Assert.equal(
+        presId,
+        testPresentationId,
+        "expected presentationId received from ack"
+      );
+      run_next_test();
+    };
+
+    controllerState.terminateAck(presentationId);
+  };
+}
+
+function exchangeSDP() {
+  Assert.equal(
+    controllerState.state,
+    State.CONNECTED,
+    "controller in connected state"
+  );
+  Assert.equal(
+    receiverState.state,
+    State.CONNECTED,
+    "receiver in connected state"
+  );
+
+  const testOffer = "test-offer";
+  const testAnswer = "test-answer";
+  const testIceCandidate = "test-ice-candidate";
+  controllerState.sendOffer(testOffer);
+  mockReceiverChannel.notifyOffer = function(offer) {
+    Assert.equal(offer, testOffer, "expected offer received");
+
+    receiverState.sendAnswer(testAnswer);
+    mockControllerChannel.notifyAnswer = function(answer) {
+      Assert.equal(answer, testAnswer, "expected answer received");
+
+      controllerState.updateIceCandidate(testIceCandidate);
+      mockReceiverChannel.notifyIceCandidate = function(candidate) {
+        Assert.equal(
+          candidate,
+          testIceCandidate,
+          "expected ice candidate received in receiver"
+        );
+
+        receiverState.updateIceCandidate(testIceCandidate);
+        mockControllerChannel.notifyIceCandidate = function(
+          controllerCandidate
+        ) {
+          Assert.equal(
+            controllerCandidate,
+            testIceCandidate,
+            "expected ice candidate received in controller"
+          );
+
+          run_next_test();
+        };
+      };
+    };
+  };
+}
+
+function disconnect() {
+  // step 1: controller send disconnect command
+  controllerState.onChannelClosed(Cr.NS_OK, false);
+  Assert.equal(
+    controllerState.state,
+    State.CLOSING,
+    "controller in closing state"
+  );
+
+  mockReceiverChannel.notifyDisconnected = function(reason) {
+    Assert.equal(reason, Cr.NS_OK, "receive close reason");
+    Assert.equal(receiverState.state, State.CLOSED, "receiver in closed state");
+
+    receiverState.onChannelClosed(Cr.NS_OK, true);
+    Assert.equal(receiverState.state, State.CLOSED, "receiver in closed state");
+
+    mockControllerChannel.notifyDisconnected = function(disconnectReason) {
+      Assert.equal(disconnectReason, Cr.NS_OK, "receive close reason");
+      Assert.equal(
+        controllerState.state,
+        State.CLOSED,
+        "controller in closed state"
+      );
+
+      run_next_test();
+    };
+    controllerState.onChannelClosed(Cr.NS_OK, true);
+  };
+}
+
+function receiverDisconnect() {
+  // initial state: controller and receiver are connected
+  controllerState.state = State.CONNECTED;
+  receiverState.state = State.CONNECTED;
+
+  // step 1: controller send disconnect command
+  receiverState.onChannelClosed(Cr.NS_OK, false);
+  Assert.equal(receiverState.state, State.CLOSING, "receiver in closing state");
+
+  mockControllerChannel.notifyDisconnected = function(reason) {
+    Assert.equal(reason, Cr.NS_OK, "receive close reason");
+    Assert.equal(
+      controllerState.state,
+      State.CLOSED,
+      "controller in closed state"
+    );
+
+    controllerState.onChannelClosed(Cr.NS_OK, true);
+    Assert.equal(
+      controllerState.state,
+      State.CLOSED,
+      "controller in closed state"
+    );
+
+    mockReceiverChannel.notifyDisconnected = function(disconnectReason) {
+      Assert.equal(disconnectReason, Cr.NS_OK, "receive close reason");
+      Assert.equal(
+        receiverState.state,
+        State.CLOSED,
+        "receiver in closed state"
+      );
+
+      run_next_test();
+    };
+    receiverState.onChannelClosed(Cr.NS_OK, true);
+  };
+}
+
+function abnormalDisconnect() {
+  // initial state: controller and receiver are connected
+  controllerState.state = State.CONNECTED;
+  receiverState.state = State.CONNECTED;
+
+  const testErrorReason = Cr.NS_ERROR_FAILURE;
+  // step 1: controller send disconnect command
+  controllerState.onChannelClosed(testErrorReason, false);
+  Assert.equal(
+    controllerState.state,
+    State.CLOSING,
+    "controller in closing state"
+  );
+
+  mockReceiverChannel.notifyDisconnected = function(reason) {
+    Assert.equal(reason, testErrorReason, "receive abnormal close reason");
+    Assert.equal(receiverState.state, State.CLOSED, "receiver in closed state");
+
+    receiverState.onChannelClosed(Cr.NS_OK, true);
+    Assert.equal(receiverState.state, State.CLOSED, "receiver in closed state");
+
+    mockControllerChannel.notifyDisconnected = function(disconnectReason) {
+      Assert.equal(
+        disconnectReason,
+        testErrorReason,
+        "receive abnormal close reason"
+      );
+      Assert.equal(
+        controllerState.state,
+        State.CLOSED,
+        "controller in closed state"
+      );
+
+      run_next_test();
+    };
+    controllerState.onChannelClosed(Cr.NS_OK, true);
+  };
+}
+
+add_test(connect);
+add_test(launch);
+add_test(terminateByController);
+add_test(terminateByReceiver);
+add_test(exchangeSDP);
+add_test(disconnect);
+add_test(receiverDisconnect);
+add_test(abnormalDisconnect);
diff --git a/dom/presentation/tests/xpcshell/test_tcp_control_channel.js b/dom/presentation/tests/xpcshell/test_tcp_control_channel.js
new file mode 100644
index 0000000000..ee0b3aa074
--- /dev/null
+++ b/dom/presentation/tests/xpcshell/test_tcp_control_channel.js
@@ -0,0 +1,523 @@
+/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const { Services } = ChromeUtils.import("resource://gre/modules/Services.jsm");
+
+var pcs;
+
+// Call |run_next_test| if all functions in |names| are called
+function makeJointSuccess(names) {
+  let funcs = {},
+    successCount = 0;
+  names.forEach(function(name) {
+    funcs[name] = function() {
+      info("got expected: " + name);
+      if (++successCount === names.length) {
+        run_next_test();
+      }
+    };
+  });
+  return funcs;
+}
+
+function TestDescription(aType, aTcpAddress, aTcpPort) {
+  this.type = aType;
+  this.tcpAddress = Cc["@mozilla.org/array;1"].createInstance(
+    Ci.nsIMutableArray
+  );
+  for (let address of aTcpAddress) {
+    let wrapper = Cc["@mozilla.org/supports-cstring;1"].createInstance(
+      Ci.nsISupportsCString
+    );
+    wrapper.data = address;
+    this.tcpAddress.appendElement(wrapper);
+  }
+  this.tcpPort = aTcpPort;
+}
+
+TestDescription.prototype = {
+  QueryInterface: ChromeUtils.generateQI(["nsIPresentationChannelDescription"]),
+};
+
+const CONTROLLER_CONTROL_CHANNEL_PORT = 36777;
+const PRESENTER_CONTROL_CHANNEL_PORT = 36888;
+
+var CLOSE_CONTROL_CHANNEL_REASON = Cr.NS_OK;
+var candidate;
+
+// presenter's presentation channel description
+const OFFER_ADDRESS = "192.168.123.123";
+const OFFER_PORT = 123;
+
+// controller's presentation channel description
+const ANSWER_ADDRESS = "192.168.321.321";
+const ANSWER_PORT = 321;
+
+function loopOfferAnser() {
+  pcs = Cc["@mozilla.org/presentation/control-service;1"].createInstance(
+    Ci.nsIPresentationControlService
+  );
+  pcs.id = "controllerID";
+  pcs.listener = {
+    onServerReady() {
+      testPresentationServer();
+    },
+  };
+
+  // First run with TLS enabled.
+  pcs.startServer(true, PRESENTER_CONTROL_CHANNEL_PORT);
+}
+
+function testPresentationServer() {
+  let yayFuncs = makeJointSuccess([
+    "controllerControlChannelClose",
+    "presenterControlChannelClose",
+    "controllerControlChannelReconnect",
+    "presenterControlChannelReconnect",
+  ]);
+  let presenterControlChannel;
+
+  pcs.listener = {
+    onSessionRequest(deviceInfo, url, presentationId, controlChannel) {
+      presenterControlChannel = controlChannel;
+      Assert.equal(deviceInfo.id, pcs.id, "expected device id");
+      Assert.equal(deviceInfo.address, "127.0.0.1", "expected device address");
+      Assert.equal(url, "http://example.com", "expected url");
+      Assert.equal(
+        presentationId,
+        "testPresentationId",
+        "expected presentation id"
+      );
+
+      presenterControlChannel.listener = {
+        status: "created",
+        onOffer(aOffer) {
+          Assert.equal(
+            this.status,
+            "opened",
+            "1. presenterControlChannel: get offer, send answer"
+          );
+          this.status = "onOffer";
+
+          let offer = aOffer.QueryInterface(
+            Ci.nsIPresentationChannelDescription
+          );
+          Assert.strictEqual(
+            offer.tcpAddress.queryElementAt(0, Ci.nsISupportsCString).data,
+            OFFER_ADDRESS,
+            "expected offer address array"
+          );
+          Assert.equal(offer.tcpPort, OFFER_PORT, "expected offer port");
+          try {
+            let tcpType = Ci.nsIPresentationChannelDescription.TYPE_TCP;
+            let answer = new TestDescription(
+              tcpType,
+              [ANSWER_ADDRESS],
+              ANSWER_PORT
+            );
+            presenterControlChannel.sendAnswer(answer);
+          } catch (e) {
+            Assert.ok(false, "sending answer fails" + e);
+          }
+        },
+        onAnswer(aAnswer) {
+          Assert.ok(false, "get answer");
+        },
+        onIceCandidate(aCandidate) {
+          Assert.ok(
+            true,
+            "3. presenterControlChannel: get ice candidate, close channel"
+          );
+          let recvCandidate = JSON.parse(aCandidate);
+          for (let key in recvCandidate) {
+            if (typeof recvCandidate[key] !== "function") {
+              Assert.equal(
+                recvCandidate[key],
+                candidate[key],
+                "key " + key + " should match."
+              );
+            }
+          }
+          presenterControlChannel.disconnect(CLOSE_CONTROL_CHANNEL_REASON);
+        },
+        notifyConnected() {
+          Assert.equal(
+            this.status,
+            "created",
+            "0. presenterControlChannel: opened"
+          );
+          this.status = "opened";
+        },
+        notifyDisconnected(aReason) {
+          Assert.equal(
+            this.status,
+            "onOffer",
+            "4. presenterControlChannel: closed"
+          );
+          Assert.equal(
+            aReason,
+            CLOSE_CONTROL_CHANNEL_REASON,
+            "presenterControlChannel notify closed"
+          );
+          this.status = "closed";
+          yayFuncs.controllerControlChannelClose();
+        },
+        QueryInterface: ChromeUtils.generateQI([
+          "nsIPresentationControlChannelListener",
+        ]),
+      };
+    },
+    onReconnectRequest(deviceInfo, url, presentationId, controlChannel) {
+      Assert.equal(url, "http://example.com", "expected url");
+      Assert.equal(
+        presentationId,
+        "testPresentationId",
+        "expected presentation id"
+      );
+      yayFuncs.presenterControlChannelReconnect();
+    },
+
+    QueryInterface: ChromeUtils.generateQI([
+      "nsIPresentationControlServerListener",
+    ]),
+  };
+
+  let presenterDeviceInfo = {
+    id: "presentatorID",
+    address: "127.0.0.1",
+    port: PRESENTER_CONTROL_CHANNEL_PORT,
+    certFingerprint: pcs.certFingerprint,
+    QueryInterface: ChromeUtils.generateQI(["nsITCPDeviceInfo"]),
+  };
+
+  let controllerControlChannel = pcs.connect(presenterDeviceInfo);
+
+  controllerControlChannel.listener = {
+    status: "created",
+    onOffer(offer) {
+      Assert.ok(false, "get offer");
+    },
+    onAnswer(aAnswer) {
+      Assert.equal(
+        this.status,
+        "opened",
+        "2. controllerControlChannel: get answer, send ICE candidate"
+      );
+
+      let answer = aAnswer.QueryInterface(Ci.nsIPresentationChannelDescription);
+      Assert.strictEqual(
+        answer.tcpAddress.queryElementAt(0, Ci.nsISupportsCString).data,
+        ANSWER_ADDRESS,
+        "expected answer address array"
+      );
+      Assert.equal(answer.tcpPort, ANSWER_PORT, "expected answer port");
+      candidate = {
+        candidate: "1 1 UDP 1 127.0.0.1 34567 type host",
+        sdpMid: "helloworld",
+        sdpMLineIndex: 1,
+      };
+      controllerControlChannel.sendIceCandidate(JSON.stringify(candidate));
+    },
+    onIceCandidate(aCandidate) {
+      Assert.ok(false, "get ICE candidate");
+    },
+    notifyConnected() {
+      Assert.equal(
+        this.status,
+        "created",
+        "0. controllerControlChannel: opened, send offer"
+      );
+      controllerControlChannel.launch(
+        "testPresentationId",
+        "http://example.com"
+      );
+      this.status = "opened";
+      try {
+        let tcpType = Ci.nsIPresentationChannelDescription.TYPE_TCP;
+        let offer = new TestDescription(tcpType, [OFFER_ADDRESS], OFFER_PORT);
+        controllerControlChannel.sendOffer(offer);
+      } catch (e) {
+        Assert.ok(false, "sending offer fails:" + e);
+      }
+    },
+    notifyDisconnected(aReason) {
+      this.status = "closed";
+      Assert.equal(
+        aReason,
+        CLOSE_CONTROL_CHANNEL_REASON,
+        "4. controllerControlChannel notify closed"
+      );
+      yayFuncs.presenterControlChannelClose();
+
+      let reconnectControllerControlChannel = pcs.connect(presenterDeviceInfo);
+      reconnectControllerControlChannel.listener = {
+        notifyConnected() {
+          reconnectControllerControlChannel.reconnect(
+            "testPresentationId",
+            "http://example.com"
+          );
+        },
+        notifyReconnected() {
+          yayFuncs.controllerControlChannelReconnect();
+        },
+        QueryInterface: ChromeUtils.generateQI([
+          "nsIPresentationControlChannelListener",
+        ]),
+      };
+    },
+    QueryInterface: ChromeUtils.generateQI([
+      "nsIPresentationControlChannelListener",
+    ]),
+  };
+}
+
+function terminateRequest() {
+  let yayFuncs = makeJointSuccess([
+    "controllerControlChannelConnected",
+    "controllerControlChannelDisconnected",
+    "presenterControlChannelDisconnected",
+    "terminatedByController",
+    "terminatedByReceiver",
+  ]);
+  let controllerControlChannel;
+  let terminatePhase = "controller";
+
+  pcs.listener = {
+    onTerminateRequest(
+      deviceInfo,
+      presentationId,
+      controlChannel,
+      isFromReceiver
+    ) {
+      Assert.equal(deviceInfo.address, "127.0.0.1", "expected device address");
+      Assert.equal(
+        presentationId,
+        "testPresentationId",
+        "expected presentation id"
+      );
+      controlChannel.terminate(presentationId); // Reply terminate ack.
+
+      if (terminatePhase === "controller") {
+        controllerControlChannel = controlChannel;
+        Assert.equal(deviceInfo.id, pcs.id, "expected controller device id");
+        Assert.equal(isFromReceiver, false, "expected request from controller");
+        yayFuncs.terminatedByController();
+
+        controllerControlChannel.listener = {
+          notifyConnected() {
+            Assert.ok(true, "control channel notify connected");
+            yayFuncs.controllerControlChannelConnected();
+
+            terminatePhase = "receiver";
+            controllerControlChannel.terminate("testPresentationId");
+          },
+          notifyDisconnected(aReason) {
+            Assert.equal(
+              aReason,
+              CLOSE_CONTROL_CHANNEL_REASON,
+              "controllerControlChannel notify disconncted"
+            );
+            yayFuncs.controllerControlChannelDisconnected();
+          },
+          QueryInterface: ChromeUtils.generateQI([
+            "nsIPresentationControlChannelListener",
+          ]),
+        };
+      } else {
+        Assert.equal(
+          deviceInfo.id,
+          presenterDeviceInfo.id,
+          "expected presenter device id"
+        );
+        Assert.equal(isFromReceiver, true, "expected request from receiver");
+        yayFuncs.terminatedByReceiver();
+        presenterControlChannel.disconnect(CLOSE_CONTROL_CHANNEL_REASON);
+      }
+    },
+    QueryInterface: ChromeUtils.generateQI([
+      "nsITCPPresentationServerListener",
+    ]),
+  };
+
+  let presenterDeviceInfo = {
+    id: "presentatorID",
+    address: "127.0.0.1",
+    port: PRESENTER_CONTROL_CHANNEL_PORT,
+    certFingerprint: pcs.certFingerprint,
+    QueryInterface: ChromeUtils.generateQI(["nsITCPDeviceInfo"]),
+  };
+
+  let presenterControlChannel = pcs.connect(presenterDeviceInfo);
+
+  presenterControlChannel.listener = {
+    notifyConnected() {
+      presenterControlChannel.terminate("testPresentationId");
+    },
+    notifyDisconnected(aReason) {
+      Assert.equal(
+        aReason,
+        CLOSE_CONTROL_CHANNEL_REASON,
+        "4. presenterControlChannel notify disconnected"
+      );
+      yayFuncs.presenterControlChannelDisconnected();
+    },
+    QueryInterface: ChromeUtils.generateQI([
+      "nsIPresentationControlChannelListener",
+    ]),
+  };
+}
+
+function terminateRequestAbnormal() {
+  let yayFuncs = makeJointSuccess([
+    "controllerControlChannelConnected",
+    "controllerControlChannelDisconnected",
+    "presenterControlChannelDisconnected",
+  ]);
+  let controllerControlChannel;
+
+  pcs.listener = {
+    onTerminateRequest(
+      deviceInfo,
+      presentationId,
+      controlChannel,
+      isFromReceiver
+    ) {
+      Assert.equal(deviceInfo.id, pcs.id, "expected controller device id");
+      Assert.equal(deviceInfo.address, "127.0.0.1", "expected device address");
+      Assert.equal(
+        presentationId,
+        "testPresentationId",
+        "expected presentation id"
+      );
+      Assert.equal(isFromReceiver, false, "expected request from controller");
+      controlChannel.terminate("unmatched-presentationId"); // Reply abnormal terminate ack.
+
+      controllerControlChannel = controlChannel;
+
+      controllerControlChannel.listener = {
+        notifyConnected() {
+          Assert.ok(true, "control channel notify connected");
+          yayFuncs.controllerControlChannelConnected();
+        },
+        notifyDisconnected(aReason) {
+          Assert.equal(
+            aReason,
+            Cr.NS_ERROR_FAILURE,
+            "controllerControlChannel notify disconncted with error"
+          );
+          yayFuncs.controllerControlChannelDisconnected();
+        },
+        QueryInterface: ChromeUtils.generateQI([
+          "nsIPresentationControlChannelListener",
+        ]),
+      };
+    },
+    QueryInterface: ChromeUtils.generateQI([
+      "nsITCPPresentationServerListener",
+    ]),
+  };
+
+  let presenterDeviceInfo = {
+    id: "presentatorID",
+    address: "127.0.0.1",
+    port: PRESENTER_CONTROL_CHANNEL_PORT,
+    certFingerprint: pcs.certFingerprint,
+    QueryInterface: ChromeUtils.generateQI(["nsITCPDeviceInfo"]),
+  };
+
+  let presenterControlChannel = pcs.connect(presenterDeviceInfo);
+
+  presenterControlChannel.listener = {
+    notifyConnected() {
+      presenterControlChannel.terminate("testPresentationId");
+    },
+    notifyDisconnected(aReason) {
+      Assert.equal(
+        aReason,
+        Cr.NS_ERROR_FAILURE,
+        "4. presenterControlChannel notify disconnected with error"
+      );
+      yayFuncs.presenterControlChannelDisconnected();
+    },
+    QueryInterface: ChromeUtils.generateQI([
+      "nsIPresentationControlChannelListener",
+    ]),
+  };
+}
+
+function setOffline() {
+  pcs.listener = {
+    onServerReady(aPort, aCertFingerprint) {
+      Assert.notEqual(
+        aPort,
+        0,
+        "TCPPresentationServer port changed and the port should be valid"
+      );
+      pcs.close();
+      run_next_test();
+    },
+  };
+
+  // Let the server socket restart automatically.
+  Services.io.offline = true;
+  Services.io.offline = false;
+}
+
+function oneMoreLoop() {
+  try {
+    pcs.listener = {
+      onServerReady() {
+        testPresentationServer();
+      },
+    };
+
+    // Second run with TLS disabled.
+    pcs.startServer(false, PRESENTER_CONTROL_CHANNEL_PORT);
+  } catch (e) {
+    Assert.ok(false, "TCP presentation init fail:" + e);
+    run_next_test();
+  }
+}
+
+function shutdown() {
+  pcs.listener = {
+    onServerReady(aPort, aCertFingerprint) {
+      Assert.ok(false, "TCPPresentationServer port changed");
+    },
+  };
+  pcs.close();
+  Assert.equal(pcs.port, 0, "TCPPresentationServer closed");
+  run_next_test();
+}
+
+// Test manually close control channel with NS_ERROR_FAILURE
+function changeCloseReason() {
+  CLOSE_CONTROL_CHANNEL_REASON = Cr.NS_ERROR_FAILURE;
+  run_next_test();
+}
+
+add_test(loopOfferAnser);
+add_test(terminateRequest);
+add_test(terminateRequestAbnormal);
+add_test(setOffline);
+add_test(changeCloseReason);
+add_test(oneMoreLoop);
+add_test(shutdown);
+
+function run_test() {
+  // Need profile dir to store the key / cert
+  do_get_profile();
+  // Ensure PSM is initialized
+  Cc["@mozilla.org/psm;1"].getService(Ci.nsISupports);
+
+  Services.prefs.setBoolPref("dom.presentation.tcp_server.debug", true);
+
+  registerCleanupFunction(() => {
+    Services.prefs.clearUserPref("dom.presentation.tcp_server.debug");
+  });
+
+  run_next_test();
+}
diff --git a/dom/presentation/tests/xpcshell/xpcshell.ini b/dom/presentation/tests/xpcshell/xpcshell.ini
new file mode 100644
index 0000000000..635cabe5cd
--- /dev/null
+++ b/dom/presentation/tests/xpcshell/xpcshell.ini
@@ -0,0 +1,9 @@
+[DEFAULT]
+head =
+
+[test_multicast_dns_device_provider.js]
+[test_presentation_device_manager.js]
+[test_presentation_session_transport.js]
+[test_tcp_control_channel.js]
+skip-if = os == "android" || tsan || socketprocess_networking # Bugs 1422582, 1580136, 1450502, 1584360, 1606813
+[test_presentation_state_machine.js]