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   CrashReporter::RecordAnnotationCString(
 142       CrashReporter::Annotation::ipc_channel_error, aReason);
 143
 144   MOZ_CRASH_UNSAFE_PRINTF("%s: %s", abortMessage.get(), aReason);
 145 }
 146
 147 void BackgroundChildImpl::ActorDestroy(ActorDestroyReason aWhy) {
 148   // May happen on any thread!
 149 }
 150
 151 PBackgroundTestChild* BackgroundChildImpl::AllocPBackgroundTestChild(
 152     const nsACString& aTestArg) {
 153   return new TestChild(aTestArg);
 154 }
 155
 156 bool BackgroundChildImpl::DeallocPBackgroundTestChild(
 157     PBackgroundTestChild* aActor) {
 158   MOZ_ASSERT(aActor);
 159
 160   delete static_cast<TestChild*>(aActor);
 161   return true;
 162 }
 163
 164 BackgroundChildImpl::PBackgroundIndexedDBUtilsChild*
 165 BackgroundChildImpl::AllocPBackgroundIndexedDBUtilsChild() {
 166   MOZ_CRASH(
 167       "PBackgroundIndexedDBUtilsChild actors should be manually "
 168       "constructed!");
 169 }
 170
 171 bool BackgroundChildImpl::DeallocPBackgroundIndexedDBUtilsChild(
 172     PBackgroundIndexedDBUtilsChild* aActor) {
 173   MOZ_ASSERT(aActor);
 174
 175   delete aActor;
 176   return true;
 177 }
 178
 179 BackgroundChildImpl::PBackgroundLSObserverChild*
 180 BackgroundChildImpl::AllocPBackgroundLSObserverChild(
 181     const uint64_t& aObserverId) {
 182   MOZ_CRASH("PBackgroundLSObserverChild actor should be manually constructed!");
 183 }
 184
 185 bool BackgroundChildImpl::DeallocPBackgroundLSObserverChild(
 186     PBackgroundLSObserverChild* aActor) {
 187   MOZ_ASSERT(aActor);
 188
 189   delete aActor;
 190   return true;
 191 }
 192
 193 BackgroundChildImpl::PBackgroundLSRequestChild*
 194 BackgroundChildImpl::AllocPBackgroundLSRequestChild(
 195     const LSRequestParams& aParams) {
 196   MOZ_CRASH("PBackgroundLSRequestChild actor should be manually constructed!");
 197 }
 198
 199 bool BackgroundChildImpl::DeallocPBackgroundLSRequestChild(
 200     PBackgroundLSRequestChild* aActor) {
 201   MOZ_ASSERT(aActor);
 202
 203   delete aActor;
 204   return true;
 205 }
 206
 207 BackgroundChildImpl::PBackgroundLocalStorageCacheChild*
 208 BackgroundChildImpl::AllocPBackgroundLocalStorageCacheChild(
 209     const PrincipalInfo& aPrincipalInfo, const nsACString& aOriginKey,
 210     const uint32_t& aPrivateBrowsingId) {
 211   MOZ_CRASH(
 212       "PBackgroundLocalStorageChild actors should be manually "
 213       "constructed!");
 214 }
 215
 216 bool BackgroundChildImpl::DeallocPBackgroundLocalStorageCacheChild(
 217     PBackgroundLocalStorageCacheChild* aActor) {
 218   MOZ_ASSERT(aActor);
 219
 220   delete aActor;
 221   return true;
 222 }
 223
 224 BackgroundChildImpl::PBackgroundLSSimpleRequestChild*
 225 BackgroundChildImpl::AllocPBackgroundLSSimpleRequestChild(
 226     const LSSimpleRequestParams& aParams) {
 227   MOZ_CRASH(
 228       "PBackgroundLSSimpleRequestChild actor should be manually "
 229       "constructed!");
 230 }
 231
 232 bool BackgroundChildImpl::DeallocPBackgroundLSSimpleRequestChild(
 233     PBackgroundLSSimpleRequestChild* aActor) {
 234   MOZ_ASSERT(aActor);
 235
 236   delete aActor;
 237   return true;
 238 }
 239
 240 BackgroundChildImpl::PBackgroundStorageChild*
 241 BackgroundChildImpl::AllocPBackgroundStorageChild(
 242     const nsAString& aProfilePath, const uint32_t& aPrivateBrowsingId) {
 243   MOZ_CRASH("PBackgroundStorageChild actors should be manually constructed!");
 244 }
 245
 246 bool BackgroundChildImpl::DeallocPBackgroundStorageChild(
 247     PBackgroundStorageChild* aActor) {
 248   MOZ_ASSERT(aActor);
 249
 250   StorageDBChild* child = static_cast<StorageDBChild*>(aActor);
 251   child->ReleaseIPDLReference();
 252   return true;
 253 }
 254
 255 already_AddRefed<PRemoteWorkerChild>
 256 BackgroundChildImpl::AllocPRemoteWorkerChild(const RemoteWorkerData& aData) {
 257   return MakeAndAddRef<RemoteWorkerChild>(aData);
 258 }
 259
 260 IPCResult BackgroundChildImpl::RecvPRemoteWorkerConstructor(
 261     PRemoteWorkerChild* aActor, const RemoteWorkerData& aData) {
 262   dom::RemoteWorkerChild* actor = static_cast<dom::RemoteWorkerChild*>(aActor);
 263   actor->ExecWorker(aData);
 264   return IPC_OK();
 265 }
 266
 267 dom::PSharedWorkerChild* BackgroundChildImpl::AllocPSharedWorkerChild(
 268     const dom::RemoteWorkerData& aData, const uint64_t& aWindowID,
 269     const dom::MessagePortIdentifier& aPortIdentifier) {
 270   RefPtr<dom::SharedWorkerChild> agent = new dom::SharedWorkerChild();
 271   return agent.forget().take();
 272 }
 273
 274 bool BackgroundChildImpl::DeallocPSharedWorkerChild(
 275     dom::PSharedWorkerChild* aActor) {
 276   RefPtr<dom::SharedWorkerChild> actor =
 277       dont_AddRef(static_cast<dom::SharedWorkerChild*>(aActor));
 278   return true;
 279 }
 280
 281 dom::PTemporaryIPCBlobChild*
 282 BackgroundChildImpl::AllocPTemporaryIPCBlobChild() {
 283   MOZ_CRASH("This is not supposed to be called.");
 284   return nullptr;
 285 }
 286
 287 bool BackgroundChildImpl::DeallocPTemporaryIPCBlobChild(
 288     dom::PTemporaryIPCBlobChild* aActor) {
 289   RefPtr<dom::TemporaryIPCBlobChild> actor =
 290       dont_AddRef(static_cast<dom::TemporaryIPCBlobChild*>(aActor));
 291   return true;
 292 }
 293
 294 dom::PFileCreatorChild* BackgroundChildImpl::AllocPFileCreatorChild(
 295     const nsAString& aFullPath, const nsAString& aType, const nsAString& aName,
 296     const Maybe<int64_t>& aLastModified, const bool& aExistenceCheck,
 297     const bool& aIsFromNsIFile) {
 298   return new dom::FileCreatorChild();
 299 }
 300
 301 bool BackgroundChildImpl::DeallocPFileCreatorChild(PFileCreatorChild* aActor) {
 302   delete static_cast<dom::FileCreatorChild*>(aActor);
 303   return true;
 304 }
 305
 306 PUDPSocketChild* BackgroundChildImpl::AllocPUDPSocketChild(
 307     const Maybe<PrincipalInfo>& aPrincipalInfo, const nsACString& aFilter) {
 308   MOZ_CRASH("AllocPUDPSocket should not be called");
 309   return nullptr;
 310 }
 311
 312 bool BackgroundChildImpl::DeallocPUDPSocketChild(PUDPSocketChild* child) {
 313   UDPSocketChild* p = static_cast<UDPSocketChild*>(child);
 314   p->ReleaseIPDLReference();
 315   return true;
 316 }
 317
 318 // -----------------------------------------------------------------------------
 319 // BroadcastChannel API
 320 // -----------------------------------------------------------------------------
 321
 322 dom::PBroadcastChannelChild* BackgroundChildImpl::AllocPBroadcastChannelChild(
 323     const PrincipalInfo& aPrincipalInfo, const nsACString& aOrigin,
 324     const nsAString& aChannel) {
 325   RefPtr<dom::BroadcastChannelChild> agent = new dom::BroadcastChannelChild();
 326   return agent.forget().take();
 327 }
 328
 329 bool BackgroundChildImpl::DeallocPBroadcastChannelChild(
 330     PBroadcastChannelChild* aActor) {
 331   RefPtr<dom::BroadcastChannelChild> child =
 332       dont_AddRef(static_cast<dom::BroadcastChannelChild*>(aActor));
 333   MOZ_ASSERT(child);
 334   return true;
 335 }
 336
 337 camera::PCamerasChild* BackgroundChildImpl::AllocPCamerasChild() {
 338 #ifdef MOZ_WEBRTC
 339   RefPtr<camera::CamerasChild> agent = new camera::CamerasChild();
 340   return agent.forget().take();
 341 #else
 342   return nullptr;
 343 #endif
 344 }
 345
 346 bool BackgroundChildImpl::DeallocPCamerasChild(camera::PCamerasChild* aActor) {
 347 #ifdef MOZ_WEBRTC
 348   RefPtr<camera::CamerasChild> child =
 349       dont_AddRef(static_cast<camera::CamerasChild*>(aActor));
 350   MOZ_ASSERT(aActor);
 351   camera::Shutdown();
 352 #endif
 353   return true;
 354 }
 355
 356 // -----------------------------------------------------------------------------
 357 // ServiceWorkerManager
 358 // -----------------------------------------------------------------------------
 359
 360 dom::PServiceWorkerManagerChild*
 361 BackgroundChildImpl::AllocPServiceWorkerManagerChild() {
 362   RefPtr<dom::ServiceWorkerManagerChild> agent =
 363       new dom::ServiceWorkerManagerChild();
 364   return agent.forget().take();
 365 }
 366
 367 bool BackgroundChildImpl::DeallocPServiceWorkerManagerChild(
 368     PServiceWorkerManagerChild* aActor) {
 369   RefPtr<dom::ServiceWorkerManagerChild> child =
 370       dont_AddRef(static_cast<dom::ServiceWorkerManagerChild*>(aActor));
 371   MOZ_ASSERT(child);
 372   return true;
 373 }
 374
 375 // -----------------------------------------------------------------------------
 376 // Cache API
 377 // -----------------------------------------------------------------------------
 378
 379 already_AddRefed<PCacheChild> BackgroundChildImpl::AllocPCacheChild() {
 380   return dom::cache::AllocPCacheChild();
 381 }
 382
 383 already_AddRefed<PCacheStreamControlChild>
 384 BackgroundChildImpl::AllocPCacheStreamControlChild() {
 385   return dom::cache::AllocPCacheStreamControlChild();
 386 }
 387
 388 // -----------------------------------------------------------------------------
 389 // MessageChannel/MessagePort API
 390 // -----------------------------------------------------------------------------
 391
 392 dom::PMessagePortChild* BackgroundChildImpl::AllocPMessagePortChild(
 393     const nsID& aUUID, const nsID& aDestinationUUID,
 394     const uint32_t& aSequenceID) {
 395   RefPtr<dom::MessagePortChild> agent = new dom::MessagePortChild();
 396   return agent.forget().take();
 397 }
 398
 399 bool BackgroundChildImpl::DeallocPMessagePortChild(PMessagePortChild* aActor) {
 400   RefPtr<dom::MessagePortChild> child =
 401       dont_AddRef(static_cast<dom::MessagePortChild*>(aActor));
 402   MOZ_ASSERT(child);
 403   return true;
 404 }
 405
 406 dom::PWebAuthnTransactionChild*
 407 BackgroundChildImpl::AllocPWebAuthnTransactionChild() {
 408   MOZ_CRASH("PWebAuthnTransaction actor should be manually constructed!");
 409   return nullptr;
 410 }
 411
 412 bool BackgroundChildImpl::DeallocPWebAuthnTransactionChild(
 413     PWebAuthnTransactionChild* aActor) {
 414   MOZ_ASSERT(aActor);
 415   RefPtr<dom::WebAuthnTransactionChild> child =
 416       dont_AddRef(static_cast<dom::WebAuthnTransactionChild*>(aActor));
 417   return true;
 418 }
 419
 420 already_AddRefed<PServiceWorkerChild>
 421 BackgroundChildImpl::AllocPServiceWorkerChild(
 422     const IPCServiceWorkerDescriptor&) {
 423   MOZ_CRASH("Shouldn't be called.");
 424   return {};
 425 }
 426
 427 already_AddRefed<PServiceWorkerContainerChild>
 428 BackgroundChildImpl::AllocPServiceWorkerContainerChild() {
 429   return mozilla::dom::ServiceWorkerContainerChild::Create();
 430 }
 431
 432 already_AddRefed<PServiceWorkerRegistrationChild>
 433 BackgroundChildImpl::AllocPServiceWorkerRegistrationChild(
 434     const IPCServiceWorkerRegistrationDescriptor&) {
 435   MOZ_CRASH("Shouldn't be called.");
 436   return {};
 437 }
 438
 439 dom::PEndpointForReportChild* BackgroundChildImpl::AllocPEndpointForReportChild(
 440     const nsAString& aGroupName, const PrincipalInfo& aPrincipalInfo) {
 441   return new dom::EndpointForReportChild();
 442 }
 443
 444 bool BackgroundChildImpl::DeallocPEndpointForReportChild(
 445     PEndpointForReportChild* aActor) {
 446   MOZ_ASSERT(aActor);
 447   delete static_cast<dom::EndpointForReportChild*>(aActor);
 448   return true;
 449 }
 450
 451 }  // namespace mozilla::ipc
 452
 453 mozilla::ipc::IPCResult TestChild::Recv__delete__(const nsACString& aTestArg) {
 454   MOZ_RELEASE_ASSERT(aTestArg == mTestArg,
 455                      "BackgroundTest message was corrupted!");
 456
 457   return IPC_OK();
 458 }