path: root/ipc/glue/BackgroundChildImpl.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 "BackgroundChildImpl.h"

#include "BroadcastChannelChild.h"
#ifdef MOZ_WEBRTC
#  include "CamerasChild.h"
#endif
#include "mozilla/Assertions.h"
#include "mozilla/SchedulerGroup.h"
#include "mozilla/dom/ClientManagerActors.h"
#include "mozilla/dom/FileCreatorChild.h"
#include "mozilla/dom/PBackgroundLSDatabaseChild.h"
#include "mozilla/dom/PBackgroundLSObserverChild.h"
#include "mozilla/dom/PBackgroundLSRequestChild.h"
#include "mozilla/dom/PBackgroundLSSimpleRequestChild.h"
#include "mozilla/dom/PBackgroundSDBConnectionChild.h"
#include "mozilla/dom/PFileSystemRequestChild.h"
#include "mozilla/dom/EndpointForReportChild.h"
#include "mozilla/dom/PMediaTransportChild.h"
#include "mozilla/dom/PVsync.h"
#include "mozilla/dom/TemporaryIPCBlobChild.h"
#include "mozilla/dom/cache/ActorUtils.h"
#include "mozilla/dom/indexedDB/PBackgroundIndexedDBUtilsChild.h"
#include "mozilla/dom/indexedDB/ThreadLocal.h"
#include "mozilla/dom/quota/PQuotaChild.h"
#include "mozilla/dom/RemoteWorkerChild.h"
#include "mozilla/dom/RemoteWorkerControllerChild.h"
#include "mozilla/dom/RemoteWorkerServiceChild.h"
#include "mozilla/dom/ServiceWorkerChild.h"
#include "mozilla/dom/SharedWorkerChild.h"
#include "mozilla/dom/StorageIPC.h"
#include "mozilla/dom/MessagePortChild.h"
#include "mozilla/dom/ServiceWorkerContainerChild.h"
#include "mozilla/dom/ServiceWorkerManagerChild.h"
#include "mozilla/ipc/PBackgroundTestChild.h"
#include "mozilla/net/PUDPSocketChild.h"
#include "mozilla/dom/network/UDPSocketChild.h"
#include "mozilla/dom/WebAuthnTransactionChild.h"
#include "mozilla/dom/MIDIPortChild.h"
#include "mozilla/dom/MIDIManagerChild.h"
#include "nsID.h"

namespace {

class TestChild final : public mozilla::ipc::PBackgroundTestChild {
  friend class mozilla::ipc::BackgroundChildImpl;

  nsCString mTestArg;

  explicit TestChild(const nsACString& aTestArg) : mTestArg(aTestArg) {
    MOZ_COUNT_CTOR(TestChild);
  }

 protected:
  ~TestChild() override { MOZ_COUNT_DTOR(TestChild); }

 public:
  mozilla::ipc::IPCResult Recv__delete__(const nsACString& aTestArg) override;
};

}  // namespace

namespace mozilla::ipc {

using mozilla::dom::UDPSocketChild;
using mozilla::net::PUDPSocketChild;

using mozilla::dom::PServiceWorkerChild;
using mozilla::dom::PServiceWorkerContainerChild;
using mozilla::dom::PServiceWorkerRegistrationChild;
using mozilla::dom::StorageDBChild;
using mozilla::dom::cache::PCacheChild;
using mozilla::dom::cache::PCacheStreamControlChild;

using mozilla::dom::WebAuthnTransactionChild;

using mozilla::dom::PMIDIManagerChild;
using mozilla::dom::PMIDIPortChild;

// -----------------------------------------------------------------------------
// BackgroundChildImpl::ThreadLocal
// -----------------------------------------------------------------------------

BackgroundChildImpl::ThreadLocal::ThreadLocal() : mCurrentFileHandle(nullptr) {
  // May happen on any thread!
  MOZ_COUNT_CTOR(mozilla::ipc::BackgroundChildImpl::ThreadLocal);
}

BackgroundChildImpl::ThreadLocal::~ThreadLocal() {
  // May happen on any thread!
  MOZ_COUNT_DTOR(mozilla::ipc::BackgroundChildImpl::ThreadLocal);
}

// -----------------------------------------------------------------------------
// BackgroundChildImpl
// -----------------------------------------------------------------------------

BackgroundChildImpl::BackgroundChildImpl() {
  // May happen on any thread!
  MOZ_COUNT_CTOR(mozilla::ipc::BackgroundChildImpl);
}

BackgroundChildImpl::~BackgroundChildImpl() {
  // May happen on any thread!
  MOZ_COUNT_DTOR(mozilla::ipc::BackgroundChildImpl);
}

void BackgroundChildImpl::ProcessingError(Result aCode, const char* aReason) {
  // May happen on any thread!

  nsAutoCString abortMessage;

  switch (aCode) {
    case MsgDropped:
      return;

#define HANDLE_CASE(_result)              \
  case _result:                           \
    abortMessage.AssignLiteral(#_result); \
    break

      HANDLE_CASE(MsgNotKnown);
      HANDLE_CASE(MsgNotAllowed);
      HANDLE_CASE(MsgPayloadError);
      HANDLE_CASE(MsgProcessingError);
      HANDLE_CASE(MsgRouteError);
      HANDLE_CASE(MsgValueError);

#undef HANDLE_CASE

    default:
      MOZ_CRASH("Unknown error code!");
  }

  MOZ_CRASH_UNSAFE_PRINTF("%s: %s", abortMessage.get(), aReason);
}

void BackgroundChildImpl::ActorDestroy(ActorDestroyReason aWhy) {
  // May happen on any thread!
}

PBackgroundTestChild* BackgroundChildImpl::AllocPBackgroundTestChild(
    const nsACString& aTestArg) {
  return new TestChild(aTestArg);
}

bool BackgroundChildImpl::DeallocPBackgroundTestChild(
    PBackgroundTestChild* aActor) {
  MOZ_ASSERT(aActor);

  delete static_cast<TestChild*>(aActor);
  return true;
}

BackgroundChildImpl::PBackgroundIndexedDBUtilsChild*
BackgroundChildImpl::AllocPBackgroundIndexedDBUtilsChild() {
  MOZ_CRASH(
      "PBackgroundIndexedDBUtilsChild actors should be manually "
      "constructed!");
}

bool BackgroundChildImpl::DeallocPBackgroundIndexedDBUtilsChild(
    PBackgroundIndexedDBUtilsChild* aActor) {
  MOZ_ASSERT(aActor);

  delete aActor;
  return true;
}

BackgroundChildImpl::PBackgroundSDBConnectionChild*
BackgroundChildImpl::AllocPBackgroundSDBConnectionChild(
    const PersistenceType& aPersistenceType,
    const PrincipalInfo& aPrincipalInfo) {
  MOZ_CRASH(
      "PBackgroundSDBConnectionChild actor should be manually "
      "constructed!");
}

bool BackgroundChildImpl::DeallocPBackgroundSDBConnectionChild(
    PBackgroundSDBConnectionChild* aActor) {
  MOZ_ASSERT(aActor);

  delete aActor;
  return true;
}

BackgroundChildImpl::PBackgroundLSDatabaseChild*
BackgroundChildImpl::AllocPBackgroundLSDatabaseChild(
    const PrincipalInfo& aPrincipalInfo, const uint32_t& aPrivateBrowsingId,
    const uint64_t& aDatastoreId) {
  MOZ_CRASH("PBackgroundLSDatabaseChild actor should be manually constructed!");
}

bool BackgroundChildImpl::DeallocPBackgroundLSDatabaseChild(
    PBackgroundLSDatabaseChild* aActor) {
  MOZ_ASSERT(aActor);

  delete aActor;
  return true;
}

BackgroundChildImpl::PBackgroundLSObserverChild*
BackgroundChildImpl::AllocPBackgroundLSObserverChild(
    const uint64_t& aObserverId) {
  MOZ_CRASH("PBackgroundLSObserverChild actor should be manually constructed!");
}

bool BackgroundChildImpl::DeallocPBackgroundLSObserverChild(
    PBackgroundLSObserverChild* aActor) {
  MOZ_ASSERT(aActor);

  delete aActor;
  return true;
}

BackgroundChildImpl::PBackgroundLSRequestChild*
BackgroundChildImpl::AllocPBackgroundLSRequestChild(
    const LSRequestParams& aParams) {
  MOZ_CRASH("PBackgroundLSRequestChild actor should be manually constructed!");
}

bool BackgroundChildImpl::DeallocPBackgroundLSRequestChild(
    PBackgroundLSRequestChild* aActor) {
  MOZ_ASSERT(aActor);

  delete aActor;
  return true;
}

BackgroundChildImpl::PBackgroundLocalStorageCacheChild*
BackgroundChildImpl::AllocPBackgroundLocalStorageCacheChild(
    const PrincipalInfo& aPrincipalInfo, const nsACString& aOriginKey,
    const uint32_t& aPrivateBrowsingId) {
  MOZ_CRASH(
      "PBackgroundLocalStorageChild actors should be manually "
      "constructed!");
}

bool BackgroundChildImpl::DeallocPBackgroundLocalStorageCacheChild(
    PBackgroundLocalStorageCacheChild* aActor) {
  MOZ_ASSERT(aActor);

  delete aActor;
  return true;
}

BackgroundChildImpl::PBackgroundLSSimpleRequestChild*
BackgroundChildImpl::AllocPBackgroundLSSimpleRequestChild(
    const LSSimpleRequestParams& aParams) {
  MOZ_CRASH(
      "PBackgroundLSSimpleRequestChild actor should be manually "
      "constructed!");
}

bool BackgroundChildImpl::DeallocPBackgroundLSSimpleRequestChild(
    PBackgroundLSSimpleRequestChild* aActor) {
  MOZ_ASSERT(aActor);

  delete aActor;
  return true;
}

BackgroundChildImpl::PBackgroundStorageChild*
BackgroundChildImpl::AllocPBackgroundStorageChild(
    const nsAString& aProfilePath, const uint32_t& aPrivateBrowsingId) {
  MOZ_CRASH("PBackgroundStorageChild actors should be manually constructed!");
}

bool BackgroundChildImpl::DeallocPBackgroundStorageChild(
    PBackgroundStorageChild* aActor) {
  MOZ_ASSERT(aActor);

  StorageDBChild* child = static_cast<StorageDBChild*>(aActor);
  child->ReleaseIPDLReference();
  return true;
}

dom::PRemoteWorkerChild* BackgroundChildImpl::AllocPRemoteWorkerChild(
    const RemoteWorkerData& aData) {
  RefPtr<dom::RemoteWorkerChild> agent = new dom::RemoteWorkerChild(aData);
  return agent.forget().take();
}

IPCResult BackgroundChildImpl::RecvPRemoteWorkerConstructor(
    PRemoteWorkerChild* aActor, const RemoteWorkerData& aData) {
  dom::RemoteWorkerChild* actor = static_cast<dom::RemoteWorkerChild*>(aActor);
  actor->ExecWorker(aData);
  return IPC_OK();
}

bool BackgroundChildImpl::DeallocPRemoteWorkerChild(
    dom::PRemoteWorkerChild* aActor) {
  RefPtr<dom::RemoteWorkerChild> actor =
      dont_AddRef(static_cast<dom::RemoteWorkerChild*>(aActor));
  return true;
}

dom::PRemoteWorkerControllerChild*
BackgroundChildImpl::AllocPRemoteWorkerControllerChild(
    const dom::RemoteWorkerData& aRemoteWorkerData) {
  MOZ_CRASH(
      "PRemoteWorkerControllerChild actors must be manually constructed!");
  return nullptr;
}

bool BackgroundChildImpl::DeallocPRemoteWorkerControllerChild(
    dom::PRemoteWorkerControllerChild* aActor) {
  MOZ_ASSERT(aActor);

  RefPtr<dom::RemoteWorkerControllerChild> actor =
      dont_AddRef(static_cast<dom::RemoteWorkerControllerChild*>(aActor));
  return true;
}

dom::PRemoteWorkerServiceChild*
BackgroundChildImpl::AllocPRemoteWorkerServiceChild() {
  RefPtr<dom::RemoteWorkerServiceChild> agent =
      new dom::RemoteWorkerServiceChild();
  return agent.forget().take();
}

bool BackgroundChildImpl::DeallocPRemoteWorkerServiceChild(
    dom::PRemoteWorkerServiceChild* aActor) {
  RefPtr<dom::RemoteWorkerServiceChild> actor =
      dont_AddRef(static_cast<dom::RemoteWorkerServiceChild*>(aActor));
  return true;
}

dom::PSharedWorkerChild* BackgroundChildImpl::AllocPSharedWorkerChild(
    const dom::RemoteWorkerData& aData, const uint64_t& aWindowID,
    const dom::MessagePortIdentifier& aPortIdentifier) {
  RefPtr<dom::SharedWorkerChild> agent = new dom::SharedWorkerChild();
  return agent.forget().take();
}

bool BackgroundChildImpl::DeallocPSharedWorkerChild(
    dom::PSharedWorkerChild* aActor) {
  RefPtr<dom::SharedWorkerChild> actor =
      dont_AddRef(static_cast<dom::SharedWorkerChild*>(aActor));
  return true;
}

dom::PTemporaryIPCBlobChild*
BackgroundChildImpl::AllocPTemporaryIPCBlobChild() {
  MOZ_CRASH("This is not supposed to be called.");
  return nullptr;
}

bool BackgroundChildImpl::DeallocPTemporaryIPCBlobChild(
    dom::PTemporaryIPCBlobChild* aActor) {
  RefPtr<dom::TemporaryIPCBlobChild> actor =
      dont_AddRef(static_cast<dom::TemporaryIPCBlobChild*>(aActor));
  return true;
}

dom::PFileCreatorChild* BackgroundChildImpl::AllocPFileCreatorChild(
    const nsAString& aFullPath, const nsAString& aType, const nsAString& aName,
    const Maybe<int64_t>& aLastModified, const bool& aExistenceCheck,
    const bool& aIsFromNsIFile) {
  return new dom::FileCreatorChild();
}

bool BackgroundChildImpl::DeallocPFileCreatorChild(PFileCreatorChild* aActor) {
  delete static_cast<dom::FileCreatorChild*>(aActor);
  return true;
}

PUDPSocketChild* BackgroundChildImpl::AllocPUDPSocketChild(
    const Maybe<PrincipalInfo>& aPrincipalInfo, const nsACString& aFilter) {
  MOZ_CRASH("AllocPUDPSocket should not be called");
  return nullptr;
}

bool BackgroundChildImpl::DeallocPUDPSocketChild(PUDPSocketChild* child) {
  UDPSocketChild* p = static_cast<UDPSocketChild*>(child);
  p->ReleaseIPDLReference();
  return true;
}

// -----------------------------------------------------------------------------
// BroadcastChannel API
// -----------------------------------------------------------------------------

dom::PBroadcastChannelChild* BackgroundChildImpl::AllocPBroadcastChannelChild(
    const PrincipalInfo& aPrincipalInfo, const nsACString& aOrigin,
    const nsAString& aChannel) {
  RefPtr<dom::BroadcastChannelChild> agent = new dom::BroadcastChannelChild();
  return agent.forget().take();
}

bool BackgroundChildImpl::DeallocPBroadcastChannelChild(
    PBroadcastChannelChild* aActor) {
  RefPtr<dom::BroadcastChannelChild> child =
      dont_AddRef(static_cast<dom::BroadcastChannelChild*>(aActor));
  MOZ_ASSERT(child);
  return true;
}

camera::PCamerasChild* BackgroundChildImpl::AllocPCamerasChild() {
#ifdef MOZ_WEBRTC
  RefPtr<camera::CamerasChild> agent = new camera::CamerasChild();
  return agent.forget().take();
#else
  return nullptr;
#endif
}

bool BackgroundChildImpl::DeallocPCamerasChild(camera::PCamerasChild* aActor) {
#ifdef MOZ_WEBRTC
  RefPtr<camera::CamerasChild> child =
      dont_AddRef(static_cast<camera::CamerasChild*>(aActor));
  MOZ_ASSERT(aActor);
  camera::Shutdown();
#endif
  return true;
}

// -----------------------------------------------------------------------------
// ServiceWorkerManager
// -----------------------------------------------------------------------------

dom::PServiceWorkerManagerChild*
BackgroundChildImpl::AllocPServiceWorkerManagerChild() {
  RefPtr<dom::ServiceWorkerManagerChild> agent =
      new dom::ServiceWorkerManagerChild();
  return agent.forget().take();
}

bool BackgroundChildImpl::DeallocPServiceWorkerManagerChild(
    PServiceWorkerManagerChild* aActor) {
  RefPtr<dom::ServiceWorkerManagerChild> child =
      dont_AddRef(static_cast<dom::ServiceWorkerManagerChild*>(aActor));
  MOZ_ASSERT(child);
  return true;
}

// -----------------------------------------------------------------------------
// Cache API
// -----------------------------------------------------------------------------

already_AddRefed<PCacheChild> BackgroundChildImpl::AllocPCacheChild() {
  return dom::cache::AllocPCacheChild();
}

already_AddRefed<PCacheStreamControlChild>
BackgroundChildImpl::AllocPCacheStreamControlChild() {
  return dom::cache::AllocPCacheStreamControlChild();
}

// -----------------------------------------------------------------------------
// MessageChannel/MessagePort API
// -----------------------------------------------------------------------------

dom::PMessagePortChild* BackgroundChildImpl::AllocPMessagePortChild(
    const nsID& aUUID, const nsID& aDestinationUUID,
    const uint32_t& aSequenceID) {
  RefPtr<dom::MessagePortChild> agent = new dom::MessagePortChild();
  return agent.forget().take();
}

bool BackgroundChildImpl::DeallocPMessagePortChild(PMessagePortChild* aActor) {
  RefPtr<dom::MessagePortChild> child =
      dont_AddRef(static_cast<dom::MessagePortChild*>(aActor));
  MOZ_ASSERT(child);
  return true;
}

BackgroundChildImpl::PQuotaChild* BackgroundChildImpl::AllocPQuotaChild() {
  MOZ_CRASH("PQuotaChild actor should be manually constructed!");
}

bool BackgroundChildImpl::DeallocPQuotaChild(PQuotaChild* aActor) {
  MOZ_ASSERT(aActor);
  delete aActor;
  return true;
}

mozilla::dom::PClientManagerChild*
BackgroundChildImpl::AllocPClientManagerChild() {
  return mozilla::dom::AllocClientManagerChild();
}

bool BackgroundChildImpl::DeallocPClientManagerChild(
    mozilla::dom::PClientManagerChild* aActor) {
  return mozilla::dom::DeallocClientManagerChild(aActor);
}

#ifdef EARLY_BETA_OR_EARLIER
void BackgroundChildImpl::OnChannelReceivedMessage(const Message& aMsg) {
  if (aMsg.type() == dom::PVsync::MessageType::Msg_Notify__ID) {
    // Not really necessary to look at the message payload, it will be
    // <0.5ms away from TimeStamp::Now()
    SchedulerGroup::MarkVsyncReceived();
  }
}
#endif

dom::PWebAuthnTransactionChild*
BackgroundChildImpl::AllocPWebAuthnTransactionChild() {
  MOZ_CRASH("PWebAuthnTransaction actor should be manually constructed!");
  return nullptr;
}

bool BackgroundChildImpl::DeallocPWebAuthnTransactionChild(
    PWebAuthnTransactionChild* aActor) {
  MOZ_ASSERT(aActor);
  RefPtr<dom::WebAuthnTransactionChild> child =
      dont_AddRef(static_cast<dom::WebAuthnTransactionChild*>(aActor));
  return true;
}

already_AddRefed<PServiceWorkerChild>
BackgroundChildImpl::AllocPServiceWorkerChild(
    const IPCServiceWorkerDescriptor&) {
  MOZ_CRASH("Shouldn't be called.");
  return {};
}

already_AddRefed<PServiceWorkerContainerChild>
BackgroundChildImpl::AllocPServiceWorkerContainerChild() {
  return mozilla::dom::ServiceWorkerContainerChild::Create();
}

already_AddRefed<PServiceWorkerRegistrationChild>
BackgroundChildImpl::AllocPServiceWorkerRegistrationChild(
    const IPCServiceWorkerRegistrationDescriptor&) {
  MOZ_CRASH("Shouldn't be called.");
  return {};
}

dom::PEndpointForReportChild* BackgroundChildImpl::AllocPEndpointForReportChild(
    const nsAString& aGroupName, const PrincipalInfo& aPrincipalInfo) {
  return new dom::EndpointForReportChild();
}

bool BackgroundChildImpl::DeallocPEndpointForReportChild(
    PEndpointForReportChild* aActor) {
  MOZ_ASSERT(aActor);
  delete static_cast<dom::EndpointForReportChild*>(aActor);
  return true;
}

dom::PMediaTransportChild* BackgroundChildImpl::AllocPMediaTransportChild() {
  // We don't allocate here: MediaTransportHandlerIPC is in charge of that,
  // so we don't need to know the implementation particulars here.
  MOZ_ASSERT_UNREACHABLE(
      "The only thing that ought to be creating a PMediaTransportChild is "
      "MediaTransportHandlerIPC!");
  return nullptr;
}

bool BackgroundChildImpl::DeallocPMediaTransportChild(
    dom::PMediaTransportChild* aActor) {
  delete aActor;
  return true;
}

}  // namespace mozilla::ipc

mozilla::ipc::IPCResult TestChild::Recv__delete__(const nsACString& aTestArg) {
  MOZ_RELEASE_ASSERT(aTestArg == mTestArg,
                     "BackgroundTest message was corrupted!");

  return IPC_OK();
}