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