gecko-dev/dom/presentation/ipc/PresentationBuilderParent.cpp

/* -*- 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