Add m-esr52 at 52.6.0

1 files changed, 1664 insertions, 0 deletions

diff --git a/dom/presentation/PresentationSessionInfo.cpp b/dom/presentation/PresentationSessionInfo.cpp
new file mode 100644
index 000000000..f93909864
--- /dev/null
+++ b/dom/presentation/PresentationSessionInfo.cpp
@@ -0,0 +1,1664 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim:set ts=2 sw=2 sts=2 et cindent: */
+/* 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/ContentParent.h"
+#include "mozilla/dom/HTMLIFrameElementBinding.h"
+#include "mozilla/dom/TabParent.h"
+#include "mozilla/Function.h"
+#include "mozilla/Logging.h"
+#include "mozilla/Move.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/Services.h"
+#include "nsContentUtils.h"
+#include "nsGlobalWindow.h"
+#include "nsIDocShell.h"
+#include "nsFrameLoader.h"
+#include "nsIMutableArray.h"
+#include "nsINetAddr.h"
+#include "nsISocketTransport.h"
+#include "nsISupportsPrimitives.h"
+#include "nsNetCID.h"
+#include "nsServiceManagerUtils.h"
+#include "nsThreadUtils.h"
+#include "PresentationLog.h"
+#include "PresentationService.h"
+#include "PresentationSessionInfo.h"
+
+#ifdef MOZ_WIDGET_ANDROID
+#include "nsIPresentationNetworkHelper.h"
+#endif // MOZ_WIDGET_ANDROID
+
+#ifdef MOZ_WIDGET_GONK
+#include "nsINetworkInterface.h"
+#include "nsINetworkManager.h"
+#endif
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace mozilla::services;
+
+/*
+ * 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>(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() {}
+
+  nsCString mAddress;
+  uint16_t mPort;
+};
+
+} // namespace dom
+} // namespace mozilla
+
+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, false);
+  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[%x], role[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(mSessionId).get(), 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(nsIDOMBlob* 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;
+}
+
+nsresult
+PresentationSessionInfo::OnTerminate(nsIPresentationControlChannel* aControlChannel)
+{
+  mIsOnTerminating = true; // Mark for terminating transport channel
+  SetStateWithReason(nsIPresentationSessionListener::STATE_TERMINATED, NS_OK);
+  SetControlChannel(aControlChannel);
+
+  return NS_OK;
+}
+
+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;
+  }
+
+  auto window = nsGlobalWindow::GetInnerWindowWithId(windowId);
+  if (!window) {
+    return nullptr;
+  }
+
+  return window->AsInner();
+}
+
+/* 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[%x], role[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(mSessionId).get(), 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[%x], role[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(mSessionId).get(), 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 defined(MOZ_WIDGET_GONK)
+  nsCOMPtr<nsINetworkManager> networkManager =
+    do_GetService("@mozilla.org/network/manager;1");
+  if (NS_WARN_IF(!networkManager)) {
+    return NS_ERROR_NOT_AVAILABLE;
+  }
+
+  nsCOMPtr<nsINetworkInfo> activeNetworkInfo;
+  networkManager->GetActiveNetworkInfo(getter_AddRefs(activeNetworkInfo));
+  if (NS_WARN_IF(!activeNetworkInfo)) {
+    return NS_ERROR_FAILURE;
+  }
+
+  char16_t** ips = nullptr;
+  uint32_t* prefixes = nullptr;
+  uint32_t count = 0;
+  activeNetworkInfo->GetAddresses(&ips, &prefixes, &count);
+  if (NS_WARN_IF(!count)) {
+    NS_Free(prefixes);
+    NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(count, ips);
+    return NS_ERROR_FAILURE;
+  }
+
+  // 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.
+
+  nsAutoString ip;
+  ip.Assign(ips[0]);
+
+  // On Android platform, 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>(
+      this,
+      &PresentationControllingInfo::OnGetAddress,
+      NS_ConvertUTF16toUTF8(ip)));
+
+  NS_Free(prefixes);
+  NS_FREE_XPCOM_ALLOCATED_POINTER_ARRAY(count, ips);
+
+#elif 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[%x], role[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(mSessionId).get(), 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[%x]\n",__func__, 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 char** aAddressArray,
+                                                      uint32_t aAddressArraySize)
+{
+  if (!aAddressArraySize) {
+    return OnListNetworkAddressesFailed();
+  }
+
+  // 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.
+
+  nsAutoCString ip;
+  ip.Assign(aAddressArray[0]);
+
+  // 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>(
+      this,
+      &PresentationControllingInfo::OnGetAddress,
+      ip));
+
+  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>(
+      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 =
+    mReconnectCallback.forget();
+  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)
+
+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);
+  mTimer = do_CreateInstance(NS_TIMER_CONTRACTID, &rv);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+  rv = mTimer->InitWithCallback(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[%x], role[%d]\n", __func__,
+             NS_ConvertUTF16toUTF8(mSessionId).get(), 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);
+}
+
+// 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;
+  }
+
+  nsCOMPtr<nsIFrameLoaderOwner> owner = do_QueryInterface((nsIFrameLoaderOwner*) frame);
+  if (NS_WARN_IF(!owner)) {
+    ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+    return;
+  }
+
+  nsCOMPtr<nsIFrameLoader> frameLoader = owner->GetFrameLoader();
+  if (NS_WARN_IF(!frameLoader)) {
+    ReplyError(NS_ERROR_DOM_OPERATION_ERR);
+    return;
+  }
+
+  RefPtr<TabParent> tabParent = TabParent::GetFrom(frameLoader);
+  if (tabParent) {
+    // OOP frame
+    // Notify the content process that a receiver page has launched, so it can
+    // start monitoring the loading progress.
+    mContentParent = tabParent->Manager();
+    Unused << NS_WARN_IF(!static_cast<ContentParent*>(mContentParent.get())->SendNotifyPresentationReceiverLaunched(tabParent, mSessionId));
+  } else {
+    // In-process frame
+    nsCOMPtr<nsIDocShell> docShell;
+    rv = frameLoader->GetDocShell(getter_AddRefs(docShell));
+    if (NS_WARN_IF(NS_FAILED(rv))) {
+      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);
+}