ipc/glue/BackgroundChildImpl.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "BackgroundChildImpl.h"
   8
   9 #include "BroadcastChannelChild.h"
  10 #ifdef MOZ_WEBRTC
  11 #  include "CamerasChild.h"
  12 #endif
  13 #include "mozilla/Assertions.h"
  14 #include "mozilla/SchedulerGroup.h"
  15 #include "mozilla/dom/ClientManagerActors.h"
  16 #include "mozilla/dom/FileCreatorChild.h"
  17 #include "mozilla/dom/PBackgroundLSDatabaseChild.h"
  18 #include "mozilla/dom/PBackgroundLSObserverChild.h"
  19 #include "mozilla/dom/PBackgroundLSRequestChild.h"
  20 #include "mozilla/dom/PBackgroundLSSimpleRequestChild.h"
  21 #include "mozilla/dom/PBackgroundSDBConnectionChild.h"
  22 #include "mozilla/dom/PFileSystemRequestChild.h"
  23 #include "mozilla/dom/EndpointForReportChild.h"
  24 #include "mozilla/dom/PVsync.h"
  25 #include "mozilla/dom/TemporaryIPCBlobChild.h"
  26 #include "mozilla/dom/cache/ActorUtils.h"
  27 #include "mozilla/dom/indexedDB/PBackgroundIndexedDBUtilsChild.h"
  28 #include "mozilla/dom/indexedDB/ThreadLocal.h"
  29 #include "mozilla/dom/quota/PQuotaChild.h"
  30 #include "mozilla/dom/RemoteWorkerChild.h"
  31 #include "mozilla/dom/RemoteWorkerControllerChild.h"
  32 #include "mozilla/dom/RemoteWorkerServiceChild.h"
  33 #include "mozilla/dom/ServiceWorkerChild.h"
  34 #include "mozilla/dom/SharedWorkerChild.h"
  35 #include "mozilla/dom/StorageIPC.h"
  36 #include "mozilla/dom/MessagePortChild.h"
  37 #include "mozilla/dom/ServiceWorkerContainerChild.h"
  38 #include "mozilla/dom/ServiceWorkerManagerChild.h"
  39 #include "mozilla/ipc/PBackgroundTestChild.h"
  40 #include "mozilla/net/PUDPSocketChild.h"
  41 #include "mozilla/dom/network/UDPSocketChild.h"
  42 #include "mozilla/dom/WebAuthnTransactionChild.h"
  43 #include "mozilla/dom/MIDIPortChild.h"
  44 #include "mozilla/dom/MIDIManagerChild.h"
  45 #include "nsID.h"
  46
  47 namespace {
  48
  49 class TestChild final : public mozilla::ipc::PBackgroundTestChild {
  50   friend class mozilla::ipc::BackgroundChildImpl;
  51
  52   nsCString mTestArg;
  53
  54   explicit TestChild(const nsACString& aTestArg) : mTestArg(aTestArg) {
  55     MOZ_COUNT_CTOR(TestChild);
  56   }
  57
  58  protected:
  59   ~TestChild() override { MOZ_COUNT_DTOR(TestChild); }
  60
  61  public:
  62   mozilla::ipc::IPCResult Recv__delete__(const nsACString& aTestArg) override;
  63 };
  64
  65 }  // namespace
  66
  67 namespace mozilla::ipc {
  68
  69 using mozilla::dom::UDPSocketChild;
  70 using mozilla::net::PUDPSocketChild;
  71
  72 using mozilla::dom::PRemoteWorkerChild;
  73 using mozilla::dom::PServiceWorkerChild;
  74 using mozilla::dom::PServiceWorkerContainerChild;
  75 using mozilla::dom::PServiceWorkerRegistrationChild;
  76 using mozilla::dom::RemoteWorkerChild;
  77 using mozilla::dom::StorageDBChild;
  78 using mozilla::dom::cache::PCacheChild;
  79 using mozilla::dom::cache::PCacheStreamControlChild;
  80
  81 using mozilla::dom::WebAuthnTransactionChild;
  82
  83 using mozilla::dom::PMIDIManagerChild;
  84 using mozilla::dom::PMIDIPortChild;
  85
  86 // -----------------------------------------------------------------------------
  87 // BackgroundChildImpl::ThreadLocal
  88 // -----------------------------------------------------------------------------
  89
  90 BackgroundChildImpl::ThreadLocal::ThreadLocal() : mCurrentFileHandle(nullptr) {
  91   // May happen on any thread!
  92   MOZ_COUNT_CTOR(mozilla::ipc::BackgroundChildImpl::ThreadLocal);
  93 }
  94
  95 BackgroundChildImpl::ThreadLocal::~ThreadLocal() {
  96   // May happen on any thread!
  97   MOZ_COUNT_DTOR(mozilla::ipc::BackgroundChildImpl::ThreadLocal);
  98 }
  99
 100 // -----------------------------------------------------------------------------
 101 // BackgroundChildImpl
 102 // -----------------------------------------------------------------------------
 103
 104 BackgroundChildImpl::BackgroundChildImpl() {
 105   // May happen on any thread!
 106   MOZ_COUNT_CTOR(mozilla::ipc::BackgroundChildImpl);
 107 }
 108
 109 BackgroundChildImpl::~BackgroundChildImpl() {
 110   // May happen on any thread!
 111   MOZ_COUNT_DTOR(mozilla::ipc::BackgroundChildImpl);
 112 }
 113
 114 void BackgroundChildImpl::ProcessingError(Result aCode, const char* aReason) {
 115   // May happen on any thread!
 116
 117   nsAutoCString abortMessage;
 118
 119   switch (aCode) {
 120     case MsgDropped:
 121       return;
 122
 123 #define HANDLE_CASE(_result)              \
 124   case _result:                           \
 125     abortMessage.AssignLiteral(#_result); \
 126     break
 127
 128       HANDLE_CASE(MsgNotKnown);
 129       HANDLE_CASE(MsgNotAllowed);
 130       HANDLE_CASE(MsgPayloadError);
 131       HANDLE_CASE(MsgProcessingError);
 132       HANDLE_CASE(MsgRouteError);
 133       HANDLE_CASE(MsgValueError);
 134
 135 #undef HANDLE_CASE
 136
 137     default:
 138       MOZ_CRASH("Unknown error code!");
 139   }
 140
 141   nsDependentCString reason(aReason);
 142   CrashReporter::AnnotateCrashReport(
 143       CrashReporter::Annotation::ipc_channel_error, reason);
 144
 145   MOZ_CRASH_UNSAFE_PRINTF("%s: %s", abortMessage.get(), aReason);
 146 }
 147
 148 void BackgroundChildImpl::ActorDestroy(ActorDestroyReason aWhy) {
 149   // May happen on any thread!
 150 }
 151
 152 PBackgroundTestChild* BackgroundChildImpl::AllocPBackgroundTestChild(
 153     const nsACString& aTestArg) {
 154   return new TestChild(aTestArg);
 155 }
 156
 157 bool BackgroundChildImpl::DeallocPBackgroundTestChild(
 158     PBackgroundTestChild* aActor) {
 159   MOZ_ASSERT(aActor);
 160
 161   delete static_cast<TestChild*>(aActor);
 162   return true;
 163 }
 164
 165 BackgroundChildImpl::PBackgroundIndexedDBUtilsChild*
 166 BackgroundChildImpl::AllocPBackgroundIndexedDBUtilsChild() {
 167   MOZ_CRASH(
 168       "PBackgroundIndexedDBUtilsChild actors should be manually "
 169       "constructed!");
 170 }
 171
 172 bool BackgroundChildImpl::DeallocPBackgroundIndexedDBUtilsChild(
 173     PBackgroundIndexedDBUtilsChild* aActor) {
 174   MOZ_ASSERT(aActor);
 175
 176   delete aActor;
 177   return true;
 178 }
 179
 180 BackgroundChildImpl::PBackgroundLSObserverChild*
 181 BackgroundChildImpl::AllocPBackgroundLSObserverChild(
 182     const uint64_t& aObserverId) {
 183   MOZ_CRASH("PBackgroundLSObserverChild actor should be manually constructed!");
 184 }
 185
 186 bool BackgroundChildImpl::DeallocPBackgroundLSObserverChild(
 187     PBackgroundLSObserverChild* aActor) {
 188   MOZ_ASSERT(aActor);
 189
 190   delete aActor;
 191   return true;
 192 }
 193
 194 BackgroundChildImpl::PBackgroundLSRequestChild*
 195 BackgroundChildImpl::AllocPBackgroundLSRequestChild(
 196     const LSRequestParams& aParams) {
 197   MOZ_CRASH("PBackgroundLSRequestChild actor should be manually constructed!");
 198 }
 199
 200 bool BackgroundChildImpl::DeallocPBackgroundLSRequestChild(
 201     PBackgroundLSRequestChild* aActor) {
 202   MOZ_ASSERT(aActor);
 203
 204   delete aActor;
 205   return true;
 206 }
 207
 208 BackgroundChildImpl::PBackgroundLocalStorageCacheChild*
 209 BackgroundChildImpl::AllocPBackgroundLocalStorageCacheChild(
 210     const PrincipalInfo& aPrincipalInfo, const nsACString& aOriginKey,
 211     const uint32_t& aPrivateBrowsingId) {
 212   MOZ_CRASH(
 213       "PBackgroundLocalStorageChild actors should be manually "
 214       "constructed!");
 215 }
 216
 217 bool BackgroundChildImpl::DeallocPBackgroundLocalStorageCacheChild(
 218     PBackgroundLocalStorageCacheChild* aActor) {
 219   MOZ_ASSERT(aActor);
 220
 221   delete aActor;
 222   return true;
 223 }
 224
 225 BackgroundChildImpl::PBackgroundLSSimpleRequestChild*
 226 BackgroundChildImpl::AllocPBackgroundLSSimpleRequestChild(
 227     const LSSimpleRequestParams& aParams) {
 228   MOZ_CRASH(
 229       "PBackgroundLSSimpleRequestChild actor should be manually "
 230       "constructed!");
 231 }
 232
 233 bool BackgroundChildImpl::DeallocPBackgroundLSSimpleRequestChild(
 234     PBackgroundLSSimpleRequestChild* aActor) {
 235   MOZ_ASSERT(aActor);
 236
 237   delete aActor;
 238   return true;
 239 }
 240
 241 BackgroundChildImpl::PBackgroundStorageChild*
 242 BackgroundChildImpl::AllocPBackgroundStorageChild(
 243     const nsAString& aProfilePath, const uint32_t& aPrivateBrowsingId) {
 244   MOZ_CRASH("PBackgroundStorageChild actors should be manually constructed!");
 245 }
 246
 247 bool BackgroundChildImpl::DeallocPBackgroundStorageChild(
 248     PBackgroundStorageChild* aActor) {
 249   MOZ_ASSERT(aActor);
 250
 251   StorageDBChild* child = static_cast<StorageDBChild*>(aActor);
 252   child->ReleaseIPDLReference();
 253   return true;
 254 }
 255
 256 already_AddRefed<PRemoteWorkerChild>
 257 BackgroundChildImpl::AllocPRemoteWorkerChild(const RemoteWorkerData& aData) {
 258   return MakeAndAddRef<RemoteWorkerChild>(aData);
 259 }
 260
 261 IPCResult BackgroundChildImpl::RecvPRemoteWorkerConstructor(
 262     PRemoteWorkerChild* aActor, const RemoteWorkerData& aData) {
 263   dom::RemoteWorkerChild* actor = static_cast<dom::RemoteWorkerChild*>(aActor);
 264   actor->ExecWorker(aData);
 265   return IPC_OK();
 266 }
 267
 268 dom::PSharedWorkerChild* BackgroundChildImpl::AllocPSharedWorkerChild(
 269     const dom::RemoteWorkerData& aData, const uint64_t& aWindowID,
 270     const dom::MessagePortIdentifier& aPortIdentifier) {
 271   RefPtr<dom::SharedWorkerChild> agent = new dom::SharedWorkerChild();
 272   return agent.forget().take();
 273 }
 274
 275 bool BackgroundChildImpl::DeallocPSharedWorkerChild(
 276     dom::PSharedWorkerChild* aActor) {
 277   RefPtr<dom::SharedWorkerChild> actor =
 278       dont_AddRef(static_cast<dom::SharedWorkerChild*>(aActor));
 279   return true;
 280 }
 281
 282 dom::PTemporaryIPCBlobChild*
 283 BackgroundChildImpl::AllocPTemporaryIPCBlobChild() {
 284   MOZ_CRASH("This is not supposed to be called.");
 285   return nullptr;
 286 }
 287
 288 bool BackgroundChildImpl::DeallocPTemporaryIPCBlobChild(
 289     dom::PTemporaryIPCBlobChild* aActor) {
 290   RefPtr<dom::TemporaryIPCBlobChild> actor =
 291       dont_AddRef(static_cast<dom::TemporaryIPCBlobChild*>(aActor));
 292   return true;
 293 }
 294
 295 dom::PFileCreatorChild* BackgroundChildImpl::AllocPFileCreatorChild(
 296     const nsAString& aFullPath, const nsAString& aType, const nsAString& aName,
 297     const Maybe<int64_t>& aLastModified, const bool& aExistenceCheck,
 298     const bool& aIsFromNsIFile) {
 299   return new dom::FileCreatorChild();
 300 }
 301
 302 bool BackgroundChildImpl::DeallocPFileCreatorChild(PFileCreatorChild* aActor) {
 303   delete static_cast<dom::FileCreatorChild*>(aActor);
 304   return true;
 305 }
 306
 307 PUDPSocketChild* BackgroundChildImpl::AllocPUDPSocketChild(
 308     const Maybe<PrincipalInfo>& aPrincipalInfo, const nsACString& aFilter) {
 309   MOZ_CRASH("AllocPUDPSocket should not be called");
 310   return nullptr;
 311 }
 312
 313 bool BackgroundChildImpl::DeallocPUDPSocketChild(PUDPSocketChild* child) {
 314   UDPSocketChild* p = static_cast<UDPSocketChild*>(child);
 315   p->ReleaseIPDLReference();
 316   return true;
 317 }
 318
 319 // -----------------------------------------------------------------------------
 320 // BroadcastChannel API
 321 // -----------------------------------------------------------------------------
 322
 323 dom::PBroadcastChannelChild* BackgroundChildImpl::AllocPBroadcastChannelChild(
 324     const PrincipalInfo& aPrincipalInfo, const nsACString& aOrigin,
 325     const nsAString& aChannel) {
 326   RefPtr<dom::BroadcastChannelChild> agent = new dom::BroadcastChannelChild();
 327   return agent.forget().take();
 328 }
 329
 330 bool BackgroundChildImpl::DeallocPBroadcastChannelChild(
 331     PBroadcastChannelChild* aActor) {
 332   RefPtr<dom::BroadcastChannelChild> child =
 333       dont_AddRef(static_cast<dom::BroadcastChannelChild*>(aActor));
 334   MOZ_ASSERT(child);
 335   return true;
 336 }
 337
 338 camera::PCamerasChild* BackgroundChildImpl::AllocPCamerasChild() {
 339 #ifdef MOZ_WEBRTC
 340   RefPtr<camera::CamerasChild> agent = new camera::CamerasChild();
 341   return agent.forget().take();
 342 #else
 343   return nullptr;
 344 #endif
 345 }
 346
 347 bool BackgroundChildImpl::DeallocPCamerasChild(camera::PCamerasChild* aActor) {
 348 #ifdef MOZ_WEBRTC
 349   RefPtr<camera::CamerasChild> child =
 350       dont_AddRef(static_cast<camera::CamerasChild*>(aActor));
 351   MOZ_ASSERT(aActor);
 352   camera::Shutdown();
 353 #endif
 354   return true;
 355 }
 356
 357 // -----------------------------------------------------------------------------
 358 // ServiceWorkerManager
 359 // -----------------------------------------------------------------------------
 360
 361 dom::PServiceWorkerManagerChild*
 362 BackgroundChildImpl::AllocPServiceWorkerManagerChild() {
 363   RefPtr<dom::ServiceWorkerManagerChild> agent =
 364       new dom::ServiceWorkerManagerChild();
 365   return agent.forget().take();
 366 }
 367
 368 bool BackgroundChildImpl::DeallocPServiceWorkerManagerChild(
 369     PServiceWorkerManagerChild* aActor) {
 370   RefPtr<dom::ServiceWorkerManagerChild> child =
 371       dont_AddRef(static_cast<dom::ServiceWorkerManagerChild*>(aActor));
 372   MOZ_ASSERT(child);
 373   return true;
 374 }
 375
 376 // -----------------------------------------------------------------------------
 377 // Cache API
 378 // -----------------------------------------------------------------------------
 379
 380 already_AddRefed<PCacheChild> BackgroundChildImpl::AllocPCacheChild() {
 381   return dom::cache::AllocPCacheChild();
 382 }
 383
 384 already_AddRefed<PCacheStreamControlChild>
 385 BackgroundChildImpl::AllocPCacheStreamControlChild() {
 386   return dom::cache::AllocPCacheStreamControlChild();
 387 }
 388
 389 // -----------------------------------------------------------------------------
 390 // MessageChannel/MessagePort API
 391 // -----------------------------------------------------------------------------
 392
 393 dom::PMessagePortChild* BackgroundChildImpl::AllocPMessagePortChild(
 394     const nsID& aUUID, const nsID& aDestinationUUID,
 395     const uint32_t& aSequenceID) {
 396   RefPtr<dom::MessagePortChild> agent = new dom::MessagePortChild();
 397   return agent.forget().take();
 398 }
 399
 400 bool BackgroundChildImpl::DeallocPMessagePortChild(PMessagePortChild* aActor) {
 401   RefPtr<dom::MessagePortChild> child =
 402       dont_AddRef(static_cast<dom::MessagePortChild*>(aActor));
 403   MOZ_ASSERT(child);
 404   return true;
 405 }
 406
 407 dom::PWebAuthnTransactionChild*
 408 BackgroundChildImpl::AllocPWebAuthnTransactionChild() {
 409   MOZ_CRASH("PWebAuthnTransaction actor should be manually constructed!");
 410   return nullptr;
 411 }
 412
 413 bool BackgroundChildImpl::DeallocPWebAuthnTransactionChild(
 414     PWebAuthnTransactionChild* aActor) {
 415   MOZ_ASSERT(aActor);
 416   RefPtr<dom::WebAuthnTransactionChild> child =
 417       dont_AddRef(static_cast<dom::WebAuthnTransactionChild*>(aActor));
 418   return true;
 419 }
 420
 421 already_AddRefed<PServiceWorkerChild>
 422 BackgroundChildImpl::AllocPServiceWorkerChild(
 423     const IPCServiceWorkerDescriptor&) {
 424   MOZ_CRASH("Shouldn't be called.");
 425   return {};
 426 }
 427
 428 already_AddRefed<PServiceWorkerContainerChild>
 429 BackgroundChildImpl::AllocPServiceWorkerContainerChild() {
 430   return mozilla::dom::ServiceWorkerContainerChild::Create();
 431 }
 432
 433 already_AddRefed<PServiceWorkerRegistrationChild>
 434 BackgroundChildImpl::AllocPServiceWorkerRegistrationChild(
 435     const IPCServiceWorkerRegistrationDescriptor&) {
 436   MOZ_CRASH("Shouldn't be called.");
 437   return {};
 438 }
 439
 440 dom::PEndpointForReportChild* BackgroundChildImpl::AllocPEndpointForReportChild(
 441     const nsAString& aGroupName, const PrincipalInfo& aPrincipalInfo) {
 442   return new dom::EndpointForReportChild();
 443 }
 444
 445 bool BackgroundChildImpl::DeallocPEndpointForReportChild(
 446     PEndpointForReportChild* aActor) {
 447   MOZ_ASSERT(aActor);
 448   delete static_cast<dom::EndpointForReportChild*>(aActor);
 449   return true;
 450 }
 451
 452 }  // namespace mozilla::ipc
 453
 454 mozilla::ipc::IPCResult TestChild::Recv__delete__(const nsACString& aTestArg) {
 455   MOZ_RELEASE_ASSERT(aTestArg == mTestArg,
 456                      "BackgroundTest message was corrupted!");
 457
 458   return IPC_OK();
 459 }