dom/ipc/ContentChild.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=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
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_dom_ContentChild_h
   8 #define mozilla_dom_ContentChild_h
   9
  10 #include "mozilla/Atomics.h"
  11 #include "mozilla/dom/BlobImpl.h"
  12 #include "mozilla/dom/GetFilesHelper.h"
  13 #include "mozilla/dom/UserActivation.h"
  14 #include "mozilla/dom/PContentChild.h"
  15 #include "mozilla/dom/ProcessActor.h"
  16 #include "mozilla/dom/RemoteType.h"
  17 #include "mozilla/Hal.h"
  18 #include "mozilla/ipc/InputStreamUtils.h"
  19 #include "mozilla/ipc/ProtocolUtils.h"
  20 #include "mozilla/StaticPtr.h"
  21 #include "mozilla/UniquePtr.h"
  22 #include "nsClassHashtable.h"
  23 #include "nscore.h"
  24 #include "nsHashKeys.h"
  25 #include "nsIDOMProcessChild.h"
  26 #include "nsRefPtrHashtable.h"
  27 #include "nsString.h"
  28 #include "nsTArrayForwardDeclare.h"
  29 #include "nsTHashSet.h"
  30
  31 #if defined(XP_MACOSX) && defined(MOZ_SANDBOX)
  32 #  include "nsIFile.h"
  33 #endif
  34
  35 #if defined(MOZ_SANDBOX) && defined(MOZ_DEBUG) && defined(ENABLE_TESTS)
  36 #  include "mozilla/PSandboxTestingChild.h"
  37 #endif
  38
  39 struct ChromePackage;
  40 class nsIObserver;
  41 struct SubstitutionMapping;
  42 struct OverrideMapping;
  43 class nsIDomainPolicy;
  44 class nsIURIClassifierCallback;
  45 class nsDocShellLoadState;
  46 class nsFrameLoader;
  47 class nsIOpenWindowInfo;
  48
  49 namespace mozilla {
  50 class RemoteSpellcheckEngineChild;
  51 class ChildProfilerController;
  52 class BenchmarkStorageChild;
  53
  54 namespace ipc {
  55 class UntypedEndpoint;
  56 }
  57
  58 namespace loader {
  59 class PScriptCacheChild;
  60 }
  61
  62 namespace widget {
  63 enum class ThemeChangeKind : uint8_t;
  64 }
  65 namespace dom {
  66
  67 namespace ipc {
  68 class SharedMap;
  69 }
  70
  71 class AlertObserver;
  72 class ConsoleListener;
  73 class ClonedMessageData;
  74 class BrowserChild;
  75 class TabContext;
  76 enum class CallerType : uint32_t;
  77
  78 class ContentChild final : public PContentChild,
  79                            public nsIDOMProcessChild,
  80                            public mozilla::ipc::IShmemAllocator,
  81                            public ProcessActor {
  82   using ClonedMessageData = mozilla::dom::ClonedMessageData;
  83   using FileDescriptor = mozilla::ipc::FileDescriptor;
  84
  85   friend class PContentChild;
  86
  87  public:
  88   NS_DECL_NSIDOMPROCESSCHILD
  89
  90   ContentChild();
  91   virtual ~ContentChild();
  92   NS_IMETHOD QueryInterface(REFNSIID aIID, void** aInstancePtr) override;
  93   NS_IMETHOD_(MozExternalRefCountType) AddRef(void) override { return 1; }
  94   NS_IMETHOD_(MozExternalRefCountType) Release(void) override { return 1; }
  95
  96   struct AppInfo {
  97     nsCString version;
  98     nsCString buildID;
  99     nsCString name;
 100     nsCString UAName;
 101     nsCString ID;
 102     nsCString vendor;
 103     nsCString sourceURL;
 104     nsCString updateURL;
 105   };
 106
 107   MOZ_CAN_RUN_SCRIPT_BOUNDARY nsresult ProvideWindowCommon(
 108       NotNull<BrowserChild*> aTabOpener, nsIOpenWindowInfo* aOpenWindowInfo,
 109       uint32_t aChromeFlags, bool aCalledFromJS, nsIURI* aURI,
 110       const nsAString& aName, const nsACString& aFeatures,
 111       const UserActivation::Modifiers& aModifiers, bool aForceNoOpener,
 112       bool aForceNoReferrer, bool aIsPopupRequested,
 113       nsDocShellLoadState* aLoadState, bool* aWindowIsNew,
 114       BrowsingContext** aReturn);
 115
 116   void Init(mozilla::ipc::UntypedEndpoint&& aEndpoint,
 117             const char* aParentBuildID, uint64_t aChildID, bool aIsForBrowser);
 118
 119   void InitXPCOM(XPCOMInitData&& aXPCOMInit,
 120                  const mozilla::dom::ipc::StructuredCloneData& aInitialData,
 121                  bool aIsReadyForBackgroundProcessing);
 122
 123   void InitSharedUASheets(Maybe<base::SharedMemoryHandle>&& aHandle,
 124                           uintptr_t aAddress);
 125
 126   void InitGraphicsDeviceData(const ContentDeviceData& aData);
 127
 128   static ContentChild* GetSingleton() { return sSingleton; }
 129
 130   const AppInfo& GetAppInfo() { return mAppInfo; }
 131
 132   void SetProcessName(const nsACString& aName,
 133                       const nsACString* aETLDplus1 = nullptr,
 134                       const nsACString* aCurrentProfile = nullptr);
 135
 136   void GetProcessName(nsACString& aName) const;
 137
 138 #if defined(XP_MACOSX) && defined(MOZ_SANDBOX)
 139   void GetProfileDir(nsIFile** aProfileDir) const {
 140     *aProfileDir = mProfileDir;
 141     NS_IF_ADDREF(*aProfileDir);
 142   }
 143
 144   void SetProfileDir(nsIFile* aProfileDir) { mProfileDir = aProfileDir; }
 145 #endif
 146
 147   bool IsAlive() const;
 148
 149   bool IsShuttingDown() const;
 150
 151   ipc::SharedMap* SharedData() { return mSharedData; };
 152
 153   static void AppendProcessId(nsACString& aName);
 154
 155   static RefPtr<GenericPromise> UpdateCookieStatus(nsIChannel* aChannel);
 156
 157   mozilla::ipc::IPCResult RecvInitGMPService(
 158       Endpoint<PGMPServiceChild>&& aGMPService);
 159
 160   mozilla::ipc::IPCResult RecvInitProfiler(
 161       Endpoint<PProfilerChild>&& aEndpoint);
 162
 163   mozilla::ipc::IPCResult RecvGMPsChanged(
 164       nsTArray<GMPCapabilityData>&& capabilities);
 165
 166   mozilla::ipc::IPCResult RecvInitProcessHangMonitor(
 167       Endpoint<PProcessHangMonitorChild>&& aHangMonitor);
 168
 169   mozilla::ipc::IPCResult RecvInitRendering(
 170       Endpoint<PCompositorManagerChild>&& aCompositor,
 171       Endpoint<PImageBridgeChild>&& aImageBridge,
 172       Endpoint<PVRManagerChild>&& aVRBridge,
 173       Endpoint<PRemoteDecoderManagerChild>&& aVideoManager,
 174       nsTArray<uint32_t>&& namespaces);
 175
 176   mozilla::ipc::IPCResult RecvReinitRendering(
 177       Endpoint<PCompositorManagerChild>&& aCompositor,
 178       Endpoint<PImageBridgeChild>&& aImageBridge,
 179       Endpoint<PVRManagerChild>&& aVRBridge,
 180       Endpoint<PRemoteDecoderManagerChild>&& aVideoManager,
 181       nsTArray<uint32_t>&& namespaces);
 182
 183   mozilla::ipc::IPCResult RecvReinitRenderingForDeviceReset();
 184
 185   mozilla::ipc::IPCResult RecvSetProcessSandbox(
 186       const Maybe<FileDescriptor>& aBroker);
 187
 188   PHalChild* AllocPHalChild();
 189   bool DeallocPHalChild(PHalChild*);
 190
 191   PHeapSnapshotTempFileHelperChild* AllocPHeapSnapshotTempFileHelperChild();
 192
 193   bool DeallocPHeapSnapshotTempFileHelperChild(
 194       PHeapSnapshotTempFileHelperChild*);
 195
 196   PCycleCollectWithLogsChild* AllocPCycleCollectWithLogsChild(
 197       const bool& aDumpAllTraces, const FileDescriptor& aGCLog,
 198       const FileDescriptor& aCCLog);
 199
 200   bool DeallocPCycleCollectWithLogsChild(PCycleCollectWithLogsChild* aActor);
 201
 202   virtual mozilla::ipc::IPCResult RecvPCycleCollectWithLogsConstructor(
 203       PCycleCollectWithLogsChild* aChild, const bool& aDumpAllTraces,
 204       const FileDescriptor& aGCLog, const FileDescriptor& aCCLog) override;
 205
 206   already_AddRefed<PWebBrowserPersistDocumentChild>
 207   AllocPWebBrowserPersistDocumentChild(
 208       PBrowserChild* aBrowser, const MaybeDiscarded<BrowsingContext>& aContext);
 209
 210   virtual mozilla::ipc::IPCResult RecvPWebBrowserPersistDocumentConstructor(
 211       PWebBrowserPersistDocumentChild* aActor, PBrowserChild* aBrowser,
 212       const MaybeDiscarded<BrowsingContext>& aContext) override;
 213
 214   already_AddRefed<PTestShellChild> AllocPTestShellChild();
 215
 216   virtual mozilla::ipc::IPCResult RecvPTestShellConstructor(
 217       PTestShellChild*) override;
 218
 219   PScriptCacheChild* AllocPScriptCacheChild(const FileDescOrError& cacheFile,
 220                                             const bool& wantCacheData);
 221
 222   bool DeallocPScriptCacheChild(PScriptCacheChild*);
 223
 224   virtual mozilla::ipc::IPCResult RecvPScriptCacheConstructor(
 225       PScriptCacheChild*, const FileDescOrError& cacheFile,
 226       const bool& wantCacheData) override;
 227
 228   PRemotePrintJobChild* AllocPRemotePrintJobChild();
 229
 230   PMediaChild* AllocPMediaChild();
 231
 232   bool DeallocPMediaChild(PMediaChild* aActor);
 233
 234   PBenchmarkStorageChild* AllocPBenchmarkStorageChild();
 235
 236   bool DeallocPBenchmarkStorageChild(PBenchmarkStorageChild* aActor);
 237
 238   mozilla::ipc::IPCResult RecvNotifyEmptyHTTPCache();
 239
 240   mozilla::ipc::IPCResult RecvRegisterChrome(
 241       nsTArray<ChromePackage>&& packages,
 242       nsTArray<SubstitutionMapping>&& resources,
 243       nsTArray<OverrideMapping>&& overrides, const nsCString& locale,
 244       const bool& reset);
 245   mozilla::ipc::IPCResult RecvRegisterChromeItem(
 246       const ChromeRegistryItem& item);
 247
 248   mozilla::ipc::IPCResult RecvClearStyleSheetCache(
 249       const Maybe<RefPtr<nsIPrincipal>>& aForPrincipal,
 250       const Maybe<nsCString>& aBaseDomain);
 251
 252   mozilla::ipc::IPCResult RecvClearImageCacheFromPrincipal(
 253       nsIPrincipal* aPrincipal);
 254   mozilla::ipc::IPCResult RecvClearImageCacheFromBaseDomain(
 255       const nsCString& aBaseDomain);
 256   mozilla::ipc::IPCResult RecvClearImageCache(const bool& privateLoader,
 257                                               const bool& chrome);
 258
 259   PRemoteSpellcheckEngineChild* AllocPRemoteSpellcheckEngineChild();
 260
 261   bool DeallocPRemoteSpellcheckEngineChild(PRemoteSpellcheckEngineChild*);
 262
 263   mozilla::ipc::IPCResult RecvSetOffline(const bool& offline);
 264
 265   mozilla::ipc::IPCResult RecvSetConnectivity(const bool& connectivity);
 266   mozilla::ipc::IPCResult RecvSetCaptivePortalState(const int32_t& state);
 267   mozilla::ipc::IPCResult RecvSetTRRMode(
 268       const nsIDNSService::ResolverMode& mode,
 269       const nsIDNSService::ResolverMode& modeFromPref);
 270
 271   mozilla::ipc::IPCResult RecvBidiKeyboardNotify(const bool& isLangRTL,
 272                                                  const bool& haveBidiKeyboards);
 273
 274   mozilla::ipc::IPCResult RecvNotifyVisited(nsTArray<VisitedQueryResult>&&);
 275
 276   mozilla::ipc::IPCResult RecvThemeChanged(FullLookAndFeel&&,
 277                                            widget::ThemeChangeKind);
 278
 279   // auto remove when alertfinished is received.
 280   nsresult AddRemoteAlertObserver(const nsString& aData,
 281                                   nsIObserver* aObserver);
 282
 283   mozilla::ipc::IPCResult RecvPreferenceUpdate(const Pref& aPref);
 284   mozilla::ipc::IPCResult RecvVarUpdate(const GfxVarUpdate& pref);
 285
 286   mozilla::ipc::IPCResult RecvUpdatePerfStatsCollectionMask(
 287       const uint64_t& aMask);
 288
 289   mozilla::ipc::IPCResult RecvCollectPerfStatsJSON(
 290       CollectPerfStatsJSONResolver&& aResolver);
 291
 292   mozilla::ipc::IPCResult RecvCollectScrollingMetrics(
 293       CollectScrollingMetricsResolver&& aResolver);
 294
 295   mozilla::ipc::IPCResult RecvNotifyAlertsObserver(const nsCString& aType,
 296                                                    const nsString& aData);
 297
 298   mozilla::ipc::IPCResult RecvLoadProcessScript(const nsString& aURL);
 299
 300   mozilla::ipc::IPCResult RecvAsyncMessage(const nsString& aMsg,
 301                                            const ClonedMessageData& aData);
 302
 303   mozilla::ipc::IPCResult RecvRegisterStringBundles(
 304       nsTArray<StringBundleDescriptor>&& stringBundles);
 305
 306   mozilla::ipc::IPCResult RecvUpdateL10nFileSources(
 307       nsTArray<L10nFileSourceDescriptor>&& aDescriptors);
 308
 309   mozilla::ipc::IPCResult RecvUpdateSharedData(
 310       const FileDescriptor& aMapFile, const uint32_t& aMapSize,
 311       nsTArray<IPCBlob>&& aBlobs, nsTArray<nsCString>&& aChangedKeys);
 312
 313   mozilla::ipc::IPCResult RecvFontListChanged();
 314   mozilla::ipc::IPCResult RecvForceGlobalReflow(bool aNeedsReframe);
 315
 316   mozilla::ipc::IPCResult RecvGeolocationUpdate(nsIDOMGeoPosition* aPosition);
 317
 318   // MOZ_CAN_RUN_SCRIPT_BOUNDARY because we don't have MOZ_CAN_RUN_SCRIPT bits
 319   // in IPC code yet.
 320   MOZ_CAN_RUN_SCRIPT_BOUNDARY
 321   mozilla::ipc::IPCResult RecvGeolocationError(const uint16_t& errorCode);
 322
 323   mozilla::ipc::IPCResult RecvUpdateDictionaryList(
 324       nsTArray<nsCString>&& aDictionaries);
 325
 326   mozilla::ipc::IPCResult RecvUpdateFontList(SystemFontList&&);
 327   mozilla::ipc::IPCResult RecvRebuildFontList(const bool& aFullRebuild);
 328   mozilla::ipc::IPCResult RecvFontListShmBlockAdded(
 329       const uint32_t& aGeneration, const uint32_t& aIndex,
 330       base::SharedMemoryHandle&& aHandle);
 331
 332   mozilla::ipc::IPCResult RecvUpdateAppLocales(
 333       nsTArray<nsCString>&& aAppLocales);
 334   mozilla::ipc::IPCResult RecvUpdateRequestedLocales(
 335       nsTArray<nsCString>&& aRequestedLocales);
 336
 337   mozilla::ipc::IPCResult RecvSystemTimezoneChanged();
 338
 339   mozilla::ipc::IPCResult RecvAddPermission(const IPC::Permission& permission);
 340
 341   mozilla::ipc::IPCResult RecvRemoveAllPermissions();
 342
 343   mozilla::ipc::IPCResult RecvFlushMemory(const nsString& reason);
 344
 345   mozilla::ipc::IPCResult RecvActivateA11y();
 346   mozilla::ipc::IPCResult RecvShutdownA11y();
 347
 348   mozilla::ipc::IPCResult RecvApplicationForeground();
 349   mozilla::ipc::IPCResult RecvApplicationBackground();
 350   mozilla::ipc::IPCResult RecvGarbageCollect();
 351   mozilla::ipc::IPCResult RecvCycleCollect();
 352   mozilla::ipc::IPCResult RecvUnlinkGhosts();
 353
 354   mozilla::ipc::IPCResult RecvAppInfo(
 355       const nsCString& version, const nsCString& buildID, const nsCString& name,
 356       const nsCString& UAName, const nsCString& ID, const nsCString& vendor,
 357       const nsCString& sourceURL, const nsCString& updateURL);
 358
 359   mozilla::ipc::IPCResult RecvRemoteType(const nsCString& aRemoteType,
 360                                          const nsCString& aProfile);
 361
 362   void PreallocInit();
 363
 364   // Call RemoteTypePrefix() on the result to remove URIs if you want to use
 365   // this for telemetry.
 366   const nsACString& GetRemoteType() const override;
 367
 368   mozilla::ipc::IPCResult RecvInitBlobURLs(
 369       nsTArray<BlobURLRegistrationData>&& aRegistations);
 370
 371   mozilla::ipc::IPCResult RecvInitJSActorInfos(
 372       nsTArray<JSProcessActorInfo>&& aContentInfos,
 373       nsTArray<JSWindowActorInfo>&& aWindowInfos);
 374
 375   mozilla::ipc::IPCResult RecvUnregisterJSWindowActor(const nsCString& aName);
 376
 377   mozilla::ipc::IPCResult RecvUnregisterJSProcessActor(const nsCString& aName);
 378
 379   mozilla::ipc::IPCResult RecvLastPrivateDocShellDestroyed();
 380
 381   mozilla::ipc::IPCResult RecvNotifyProcessPriorityChanged(
 382       const hal::ProcessPriority& aPriority);
 383
 384   mozilla::ipc::IPCResult RecvMinimizeMemoryUsage();
 385
 386   mozilla::ipc::IPCResult RecvLoadAndRegisterSheet(nsIURI* aURI,
 387                                                    const uint32_t& aType);
 388
 389   mozilla::ipc::IPCResult RecvUnregisterSheet(nsIURI* aURI,
 390                                               const uint32_t& aType);
 391
 392   void AddIdleObserver(nsIObserver* aObserver, uint32_t aIdleTimeInS);
 393
 394   void RemoveIdleObserver(nsIObserver* aObserver, uint32_t aIdleTimeInS);
 395
 396   mozilla::ipc::IPCResult RecvNotifyIdleObserver(const uint64_t& aObserver,
 397                                                  const nsCString& aTopic,
 398                                                  const nsString& aData);
 399
 400   mozilla::ipc::IPCResult RecvUpdateWindow(const uintptr_t& aChildId);
 401
 402   mozilla::ipc::IPCResult RecvDomainSetChanged(const uint32_t& aSetType,
 403                                                const uint32_t& aChangeType,
 404                                                nsIURI* aDomain);
 405
 406   mozilla::ipc::IPCResult RecvShutdownConfirmedHP();
 407
 408   mozilla::ipc::IPCResult RecvShutdown();
 409
 410   mozilla::ipc::IPCResult RecvInvokeDragSession(
 411       const MaybeDiscarded<WindowContext>& aSourceWindowContext,
 412       const MaybeDiscarded<WindowContext>& aSourceTopWindowContext,
 413       nsTArray<IPCTransferableData>&& aTransferables, const uint32_t& aAction);
 414
 415   mozilla::ipc::IPCResult RecvUpdateDragSession(
 416       nsTArray<IPCTransferableData>&& aTransferables,
 417       EventMessage aEventMessage);
 418
 419   MOZ_CAN_RUN_SCRIPT_BOUNDARY
 420   mozilla::ipc::IPCResult RecvEndDragSession(
 421       const bool& aDoneDrag, const bool& aUserCancelled,
 422       const mozilla::LayoutDeviceIntPoint& aEndDragPoint,
 423       const uint32_t& aKeyModifiers, const uint32_t& aDropEffect);
 424
 425   mozilla::ipc::IPCResult RecvPush(const nsCString& aScope,
 426                                    nsIPrincipal* aPrincipal,
 427                                    const nsString& aMessageId);
 428
 429   mozilla::ipc::IPCResult RecvPushWithData(const nsCString& aScope,
 430                                            nsIPrincipal* aPrincipal,
 431                                            const nsString& aMessageId,
 432                                            nsTArray<uint8_t>&& aData);
 433
 434   mozilla::ipc::IPCResult RecvPushSubscriptionChange(const nsCString& aScope,
 435                                                      nsIPrincipal* aPrincipal);
 436
 437   mozilla::ipc::IPCResult RecvPushError(const nsCString& aScope,
 438                                         nsIPrincipal* aPrincipal,
 439                                         const nsString& aMessage,
 440                                         const uint32_t& aFlags);
 441
 442   mozilla::ipc::IPCResult RecvNotifyPushSubscriptionModifiedObservers(
 443       const nsCString& aScope, nsIPrincipal* aPrincipal);
 444
 445   mozilla::ipc::IPCResult RecvRefreshScreens(
 446       nsTArray<ScreenDetails>&& aScreens);
 447
 448   mozilla::ipc::IPCResult RecvNetworkLinkTypeChange(const uint32_t& aType);
 449   uint32_t NetworkLinkType() const { return mNetworkLinkType; }
 450
 451   mozilla::ipc::IPCResult RecvSocketProcessCrashed();
 452
 453   // Get the directory for IndexedDB files. We query the parent for this and
 454   // cache the value
 455   nsString& GetIndexedDBPath();
 456
 457   ContentParentId GetID() const { return mID; }
 458
 459   bool IsForBrowser() const { return mIsForBrowser; }
 460
 461   MOZ_CAN_RUN_SCRIPT_BOUNDARY mozilla::ipc::IPCResult RecvConstructBrowser(
 462       ManagedEndpoint<PBrowserChild>&& aBrowserEp,
 463       ManagedEndpoint<PWindowGlobalChild>&& aWindowEp, const TabId& aTabId,
 464       const IPCTabContext& aContext, const WindowGlobalInit& aWindowInit,
 465       const uint32_t& aChromeFlags, const ContentParentId& aCpID,
 466       const bool& aIsForBrowser, const bool& aIsTopLevel);
 467
 468   FORWARD_SHMEM_ALLOCATOR_TO(PContentChild)
 469
 470   void GetAvailableDictionaries(nsTArray<nsCString>& aDictionaries);
 471
 472 #ifdef MOZ_WEBRTC
 473   PWebrtcGlobalChild* AllocPWebrtcGlobalChild();
 474   bool DeallocPWebrtcGlobalChild(PWebrtcGlobalChild* aActor);
 475 #endif
 476
 477   PContentPermissionRequestChild* AllocPContentPermissionRequestChild(
 478       Span<const PermissionRequest> aRequests, nsIPrincipal* aPrincipal,
 479       nsIPrincipal* aTopLevelPrincipal, const bool& aIsHandlingUserInput,
 480       const bool& aMaybeUnsafePermissionDelegate, const TabId& aTabId);
 481   bool DeallocPContentPermissionRequestChild(
 482       PContentPermissionRequestChild* actor);
 483
 484   // GetFiles for WebKit/Blink FileSystem API and Directory API must run on the
 485   // parent process.
 486   void CreateGetFilesRequest(const nsAString& aDirectoryPath,
 487                              bool aRecursiveFlag, nsID& aUUID,
 488                              GetFilesHelperChild* aChild);
 489
 490   void DeleteGetFilesRequest(nsID& aUUID, GetFilesHelperChild* aChild);
 491
 492   mozilla::ipc::IPCResult RecvGetFilesResponse(
 493       const nsID& aUUID, const GetFilesResponseResult& aResult);
 494
 495   mozilla::ipc::IPCResult RecvBlobURLRegistration(
 496       const nsCString& aURI, const IPCBlob& aBlob, nsIPrincipal* aPrincipal,
 497       const nsCString& aPartitionKey);
 498
 499   mozilla::ipc::IPCResult RecvBlobURLUnregistration(const nsCString& aURI);
 500
 501   mozilla::ipc::IPCResult RecvRequestMemoryReport(
 502       const uint32_t& generation, const bool& anonymize,
 503       const bool& minimizeMemoryUsage, const Maybe<FileDescriptor>& DMDFile,
 504       const RequestMemoryReportResolver& aResolver);
 505
 506 #if defined(XP_WIN)
 507   mozilla::ipc::IPCResult RecvGetUntrustedModulesData(
 508       GetUntrustedModulesDataResolver&& aResolver);
 509   mozilla::ipc::IPCResult RecvUnblockUntrustedModulesThread();
 510 #endif  // defined(XP_WIN)
 511
 512   mozilla::ipc::IPCResult RecvSetXPCOMProcessAttributes(
 513       XPCOMInitData&& aXPCOMInit, const StructuredCloneData& aInitialData,
 514       FullLookAndFeel&& aLookAndFeelData, SystemFontList&& aFontList,
 515       Maybe<base::SharedMemoryHandle>&& aSharedUASheetHandle,
 516       const uintptr_t& aSharedUASheetAddress,
 517       nsTArray<base::SharedMemoryHandle>&& aSharedFontListBlocks,
 518       const bool& aIsReadyForBackgroundProcessing);
 519
 520   mozilla::ipc::IPCResult RecvProvideAnonymousTemporaryFile(
 521       const uint64_t& aID, const FileDescOrError& aFD);
 522
 523   mozilla::ipc::IPCResult RecvSetPermissionsWithKey(
 524       const nsCString& aPermissionKey, nsTArray<IPC::Permission>&& aPerms);
 525
 526   mozilla::ipc::IPCResult RecvShareCodeCoverageMutex(
 527       CrossProcessMutexHandle aHandle);
 528
 529   mozilla::ipc::IPCResult RecvFlushCodeCoverageCounters(
 530       FlushCodeCoverageCountersResolver&& aResolver);
 531
 532   mozilla::ipc::IPCResult RecvSetInputEventQueueEnabled();
 533
 534   mozilla::ipc::IPCResult RecvFlushInputEventQueue();
 535
 536   mozilla::ipc::IPCResult RecvSuspendInputEventQueue();
 537
 538   mozilla::ipc::IPCResult RecvResumeInputEventQueue();
 539
 540   mozilla::ipc::IPCResult RecvAddDynamicScalars(
 541       nsTArray<DynamicScalarDefinition>&& aDefs);
 542
 543   // Get a reference to the font list passed from the chrome process,
 544   // for use during gfx initialization.
 545   SystemFontList& SystemFontList() { return mFontList; }
 546
 547   nsTArray<base::SharedMemoryHandle>& SharedFontListBlocks() {
 548     return mSharedFontListBlocks;
 549   }
 550
 551   // PURLClassifierChild
 552   PURLClassifierChild* AllocPURLClassifierChild(nsIPrincipal* aPrincipal,
 553                                                 bool* aSuccess);
 554   bool DeallocPURLClassifierChild(PURLClassifierChild* aActor);
 555
 556   // PURLClassifierLocalChild
 557   PURLClassifierLocalChild* AllocPURLClassifierLocalChild(
 558       nsIURI* aUri, Span<const IPCURLClassifierFeature> aFeatures);
 559   bool DeallocPURLClassifierLocalChild(PURLClassifierLocalChild* aActor);
 560
 561   PSessionStorageObserverChild* AllocPSessionStorageObserverChild();
 562
 563   bool DeallocPSessionStorageObserverChild(
 564       PSessionStorageObserverChild* aActor);
 565
 566   FullLookAndFeel& BorrowLookAndFeelData() { return mLookAndFeelData; }
 567
 568   /**
 569    * Helper function for protocols that use the GPU process when available.
 570    * Overrides FatalError to just be a warning when communicating with the
 571    * GPU process since we don't want to crash the content process when the
 572    * GPU process crashes.
 573    */
 574   static void FatalErrorIfNotUsingGPUProcess(const char* const aErrorMsg,
 575                                              base::ProcessId aOtherPid);
 576
 577   using AnonymousTemporaryFileCallback = std::function<void(PRFileDesc*)>;
 578   nsresult AsyncOpenAnonymousTemporaryFile(
 579       const AnonymousTemporaryFileCallback& aCallback);
 580
 581   mozilla::ipc::IPCResult RecvSaveRecording(const FileDescriptor& aFile);
 582
 583   mozilla::ipc::IPCResult RecvCrossProcessRedirect(
 584       RedirectToRealChannelArgs&& aArgs,
 585       nsTArray<Endpoint<extensions::PStreamFilterParent>>&& aEndpoints,
 586       CrossProcessRedirectResolver&& aResolve);
 587
 588   mozilla::ipc::IPCResult RecvStartDelayedAutoplayMediaComponents(
 589       const MaybeDiscarded<BrowsingContext>& aContext);
 590
 591   mozilla::ipc::IPCResult RecvUpdateMediaControlAction(
 592       const MaybeDiscarded<BrowsingContext>& aContext,
 593       const MediaControlAction& aAction);
 594
 595   // See `BrowsingContext::mEpochs` for an explanation of this field.
 596   uint64_t GetBrowsingContextFieldEpoch() const {
 597     return mBrowsingContextFieldEpoch;
 598   }
 599   uint64_t NextBrowsingContextFieldEpoch() {
 600     mBrowsingContextFieldEpoch++;
 601     return mBrowsingContextFieldEpoch;
 602   }
 603
 604   mozilla::ipc::IPCResult RecvOnAllowAccessFor(
 605       const MaybeDiscarded<BrowsingContext>& aContext,
 606       const nsCString& aTrackingOrigin, uint32_t aCookieBehavior,
 607       const ContentBlockingNotifier::StorageAccessPermissionGrantedReason&
 608           aReason);
 609
 610   mozilla::ipc::IPCResult RecvOnContentBlockingDecision(
 611       const MaybeDiscarded<BrowsingContext>& aContext,
 612       const ContentBlockingNotifier::BlockingDecision& aDecision,
 613       uint32_t aRejectedReason);
 614
 615 #ifdef NIGHTLY_BUILD
 616   // Fetch the current number of pending input events.
 617   //
 618   // NOTE: This method performs an atomic read, and is safe to call from all
 619   // threads.
 620   uint32_t GetPendingInputEvents() { return mPendingInputEvents; }
 621 #endif
 622
 623 #if defined(MOZ_SANDBOX) && defined(MOZ_DEBUG) && defined(ENABLE_TESTS)
 624   mozilla::ipc::IPCResult RecvInitSandboxTesting(
 625       Endpoint<PSandboxTestingChild>&& aEndpoint);
 626 #endif
 627
 628  private:
 629   static void ForceKillTimerCallback(nsITimer* aTimer, void* aClosure);
 630   void StartForceKillTimer();
 631
 632   void ShutdownInternal();
 633
 634   mozilla::ipc::IPCResult GetResultForRenderingInitFailure(
 635       base::ProcessId aOtherPid);
 636
 637   virtual void ActorDestroy(ActorDestroyReason why) override;
 638
 639   virtual void ProcessingError(Result aCode, const char* aReason) override;
 640
 641   mozilla::ipc::IPCResult RecvCreateBrowsingContext(
 642       uint64_t aGroupId, BrowsingContext::IPCInitializer&& aInit);
 643
 644   mozilla::ipc::IPCResult RecvDiscardBrowsingContext(
 645       const MaybeDiscarded<BrowsingContext>& aContext, bool aDoDiscard,
 646       DiscardBrowsingContextResolver&& aResolve);
 647
 648   mozilla::ipc::IPCResult RecvRegisterBrowsingContextGroup(
 649       uint64_t aGroupId, nsTArray<SyncedContextInitializer>&& aInits);
 650   mozilla::ipc::IPCResult RecvDestroyBrowsingContextGroup(uint64_t aGroupId);
 651
 652   mozilla::ipc::IPCResult RecvWindowClose(
 653       const MaybeDiscarded<BrowsingContext>& aContext, bool aTrustedCaller);
 654   mozilla::ipc::IPCResult RecvWindowFocus(
 655       const MaybeDiscarded<BrowsingContext>& aContext, CallerType aCallerType,
 656       uint64_t aActionId);
 657   mozilla::ipc::IPCResult RecvWindowBlur(
 658       const MaybeDiscarded<BrowsingContext>& aContext, CallerType aCallerType);
 659   MOZ_CAN_RUN_SCRIPT_BOUNDARY mozilla::ipc::IPCResult RecvRaiseWindow(
 660       const MaybeDiscarded<BrowsingContext>& aContext, CallerType aCallerType,
 661       uint64_t aActionId);
 662   MOZ_CAN_RUN_SCRIPT_BOUNDARY mozilla::ipc::IPCResult RecvAdjustWindowFocus(
 663       const MaybeDiscarded<BrowsingContext>& aContext, bool aIsVisible,
 664       uint64_t aActionId);
 665   MOZ_CAN_RUN_SCRIPT_BOUNDARY mozilla::ipc::IPCResult RecvClearFocus(
 666       const MaybeDiscarded<BrowsingContext>& aContext);
 667   mozilla::ipc::IPCResult RecvSetFocusedBrowsingContext(
 668       const MaybeDiscarded<BrowsingContext>& aContext, uint64_t aActionId);
 669   mozilla::ipc::IPCResult RecvSetActiveBrowsingContext(
 670       const MaybeDiscarded<BrowsingContext>& aContext, uint64_t aActionId);
 671   mozilla::ipc::IPCResult RecvAbortOrientationPendingPromises(
 672       const MaybeDiscarded<BrowsingContext>& aContext);
 673   mozilla::ipc::IPCResult RecvUnsetActiveBrowsingContext(
 674       const MaybeDiscarded<BrowsingContext>& aContext, uint64_t aActionId);
 675   mozilla::ipc::IPCResult RecvSetFocusedElement(
 676       const MaybeDiscarded<BrowsingContext>& aContext, bool aNeedsFocus);
 677   mozilla::ipc::IPCResult RecvFinalizeFocusOuter(
 678       const MaybeDiscarded<BrowsingContext>& aContext, bool aCanFocus,
 679       CallerType aCallerType);
 680   MOZ_CAN_RUN_SCRIPT_BOUNDARY mozilla::ipc::IPCResult RecvBlurToChild(
 681       const MaybeDiscarded<BrowsingContext>& aFocusedBrowsingContext,
 682       const MaybeDiscarded<BrowsingContext>& aBrowsingContextToClear,
 683       const MaybeDiscarded<BrowsingContext>& aAncestorBrowsingContextToFocus,
 684       bool aIsLeavingDocument, bool aAdjustWidget, uint64_t aActionId);
 685   mozilla::ipc::IPCResult RecvSetupFocusedAndActive(
 686       const MaybeDiscarded<BrowsingContext>& aFocusedBrowsingContext,
 687       uint64_t aActionIdForFocused,
 688       const MaybeDiscarded<BrowsingContext>& aActiveBrowsingContext,
 689       uint64_t aActionIdForActive);
 690   mozilla::ipc::IPCResult RecvReviseActiveBrowsingContext(
 691       uint64_t aOldActionId,
 692       const MaybeDiscarded<BrowsingContext>& aActiveBrowsingContext,
 693       uint64_t aNewActionId);
 694   mozilla::ipc::IPCResult RecvReviseFocusedBrowsingContext(
 695       uint64_t aOldActionId,
 696       const MaybeDiscarded<BrowsingContext>& aFocusedBrowsingContext,
 697       uint64_t aNewActionId);
 698   mozilla::ipc::IPCResult RecvMaybeExitFullscreen(
 699       const MaybeDiscarded<BrowsingContext>& aContext);
 700
 701   mozilla::ipc::IPCResult RecvWindowPostMessage(
 702       const MaybeDiscarded<BrowsingContext>& aContext,
 703       const ClonedOrErrorMessageData& aMessage, const PostMessageData& aData);
 704
 705   mozilla::ipc::IPCResult RecvCommitBrowsingContextTransaction(
 706       const MaybeDiscarded<BrowsingContext>& aContext,
 707       BrowsingContext::BaseTransaction&& aTransaction, uint64_t aEpoch);
 708
 709   mozilla::ipc::IPCResult RecvCommitWindowContextTransaction(
 710       const MaybeDiscarded<WindowContext>& aContext,
 711       WindowContext::BaseTransaction&& aTransaction, uint64_t aEpoch);
 712
 713   mozilla::ipc::IPCResult RecvCreateWindowContext(
 714       WindowContext::IPCInitializer&& aInit);
 715   mozilla::ipc::IPCResult RecvDiscardWindowContext(
 716       uint64_t aContextId, DiscardWindowContextResolver&& aResolve);
 717
 718   mozilla::ipc::IPCResult RecvScriptError(
 719       const nsString& aMessage, const nsString& aSourceName,
 720       const nsString& aSourceLine, const uint32_t& aLineNumber,
 721       const uint32_t& aColNumber, const uint32_t& aFlags,
 722       const nsCString& aCategory, const bool& aFromPrivateWindow,
 723       const uint64_t& aInnerWindowId, const bool& aFromChromeContext);
 724
 725   mozilla::ipc::IPCResult RecvReportFrameTimingData(
 726       const LoadInfoArgs& loadInfoArgs, const nsString& entryName,
 727       const nsString& initiatorType, UniquePtr<PerformanceTimingData>&& aData);
 728
 729   mozilla::ipc::IPCResult RecvLoadURI(
 730       const MaybeDiscarded<BrowsingContext>& aContext,
 731       nsDocShellLoadState* aLoadState, bool aSetNavigating,
 732       LoadURIResolver&& aResolve);
 733
 734   mozilla::ipc::IPCResult RecvInternalLoad(nsDocShellLoadState* aLoadState);
 735
 736   mozilla::ipc::IPCResult RecvDisplayLoadError(
 737       const MaybeDiscarded<BrowsingContext>& aContext, const nsAString& aURI);
 738
 739   mozilla::ipc::IPCResult RecvGoBack(
 740       const MaybeDiscarded<BrowsingContext>& aContext,
 741       const Maybe<int32_t>& aCancelContentJSEpoch, bool aRequireUserInteraction,
 742       bool aUserActivation);
 743   mozilla::ipc::IPCResult RecvGoForward(
 744       const MaybeDiscarded<BrowsingContext>& aContext,
 745       const Maybe<int32_t>& aCancelContentJSEpoch, bool aRequireUserInteraction,
 746       bool aUserActivation);
 747   mozilla::ipc::IPCResult RecvGoToIndex(
 748       const MaybeDiscarded<BrowsingContext>& aContext, const int32_t& aIndex,
 749       const Maybe<int32_t>& aCancelContentJSEpoch, bool aUserActivation);
 750   mozilla::ipc::IPCResult RecvReload(
 751       const MaybeDiscarded<BrowsingContext>& aContext,
 752       const uint32_t aReloadFlags);
 753   mozilla::ipc::IPCResult RecvStopLoad(
 754       const MaybeDiscarded<BrowsingContext>& aContext,
 755       const uint32_t aStopFlags);
 756
 757   mozilla::ipc::IPCResult RecvRawMessage(
 758       const JSActorMessageMeta& aMeta, const Maybe<ClonedMessageData>& aData,
 759       const Maybe<ClonedMessageData>& aStack);
 760
 761   already_AddRefed<JSActor> InitJSActor(JS::Handle<JSObject*> aMaybeActor,
 762                                         const nsACString& aName,
 763                                         ErrorResult& aRv) override;
 764   mozilla::ipc::IProtocol* AsNativeActor() override { return this; }
 765
 766   mozilla::ipc::IPCResult RecvHistoryCommitIndexAndLength(
 767       const MaybeDiscarded<BrowsingContext>& aContext, const uint32_t& aIndex,
 768       const uint32_t& aLength, const nsID& aChangeID);
 769
 770   mozilla::ipc::IPCResult RecvGetLayoutHistoryState(
 771       const MaybeDiscarded<BrowsingContext>& aContext,
 772       GetLayoutHistoryStateResolver&& aResolver);
 773
 774   mozilla::ipc::IPCResult RecvDispatchLocationChangeEvent(
 775       const MaybeDiscarded<BrowsingContext>& aContext);
 776
 777   mozilla::ipc::IPCResult RecvDispatchBeforeUnloadToSubtree(
 778       const MaybeDiscarded<BrowsingContext>& aStartingAt,
 779       DispatchBeforeUnloadToSubtreeResolver&& aResolver);
 780
 781   mozilla::ipc::IPCResult RecvDecoderSupportedMimeTypes(
 782       nsTArray<nsCString>&& aSupportedTypes);
 783
 784   mozilla::ipc::IPCResult RecvInitNextGenLocalStorageEnabled(
 785       const bool& aEnabled);
 786
 787  public:
 788   static void DispatchBeforeUnloadToSubtree(
 789       BrowsingContext* aStartingAt,
 790       const DispatchBeforeUnloadToSubtreeResolver& aResolver);
 791
 792   hal::ProcessPriority GetProcessPriority() const { return mProcessPriority; }
 793
 794   hal::PerformanceHintSession* PerformanceHintSession() const {
 795     return mPerformanceHintSession.get();
 796   }
 797
 798   // Returns the target work duration for the PerformanceHintSession, based on
 799   // the refresh interval. Estimate that we want the tick to complete in at most
 800   // half of the refresh period. This is fairly arbitrary and can be tweaked
 801   // later.
 802   static TimeDuration GetPerformanceHintTarget(TimeDuration aRefreshInterval) {
 803     return aRefreshInterval / int64_t(2);
 804   }
 805
 806  private:
 807   void AddProfileToProcessName(const nsACString& aProfile);
 808   mozilla::ipc::IPCResult RecvFlushFOGData(FlushFOGDataResolver&& aResolver);
 809
 810   mozilla::ipc::IPCResult RecvUpdateMediaCodecsSupported(
 811       RemoteDecodeIn aLocation, const media::MediaCodecsSupported& aSupported);
 812
 813 #ifdef NIGHTLY_BUILD
 814   virtual void OnChannelReceivedMessage(const Message& aMsg) override;
 815
 816   virtual PContentChild::Result OnMessageReceived(const Message& aMsg) override;
 817
 818   virtual PContentChild::Result OnMessageReceived(
 819       const Message& aMsg, UniquePtr<Message>& aReply) override;
 820 #endif
 821
 822   void ConfigureThreadPerformanceHints(const hal::ProcessPriority& aPriority);
 823
 824   nsTArray<mozilla::UniquePtr<AlertObserver>> mAlertObservers;
 825   RefPtr<ConsoleListener> mConsoleListener;
 826
 827   nsTHashSet<nsIObserver*> mIdleObservers;
 828
 829   nsTArray<nsCString> mAvailableDictionaries;
 830
 831   // Temporary storage for a list of available fonts, passed from the
 832   // parent process and used to initialize gfx in the child. Currently used
 833   // only on MacOSX and Linux.
 834   dom::SystemFontList mFontList;
 835   // Temporary storage for look and feel data.
 836   FullLookAndFeel mLookAndFeelData;
 837   // Temporary storage for list of shared-fontlist memory blocks.
 838   nsTArray<base::SharedMemoryHandle> mSharedFontListBlocks;
 839
 840   /**
 841    * An ID unique to the process containing our corresponding
 842    * content parent.
 843    *
 844    * We expect our content parent to set this ID immediately after opening a
 845    * channel to us.
 846    */
 847   ContentParentId mID;
 848
 849   AppInfo mAppInfo;
 850
 851   bool mIsForBrowser;
 852   nsCString mRemoteType = NOT_REMOTE_TYPE;
 853   bool mIsAlive;
 854   nsCString mProcessName;
 855
 856   static ContentChild* sSingleton;
 857
 858   class ShutdownCanary;
 859   static StaticAutoPtr<ShutdownCanary> sShutdownCanary;
 860
 861   nsCOMPtr<nsIDomainPolicy> mPolicy;
 862   nsCOMPtr<nsITimer> mForceKillTimer;
 863
 864   RefPtr<ipc::SharedMap> mSharedData;
 865
 866   RefPtr<ChildProfilerController> mProfilerController;
 867
 868 #if defined(XP_MACOSX) && defined(MOZ_SANDBOX)
 869   nsCOMPtr<nsIFile> mProfileDir;
 870 #endif
 871
 872   // Hashtable to keep track of the pending GetFilesHelper objects.
 873   // This GetFilesHelperChild objects are removed when RecvGetFilesResponse is
 874   // received.
 875   nsRefPtrHashtable<nsIDHashKey, GetFilesHelperChild> mGetFilesPendingRequests;
 876
 877   nsClassHashtable<nsUint64HashKey, AnonymousTemporaryFileCallback>
 878       mPendingAnonymousTemporaryFiles;
 879
 880   mozilla::Atomic<bool> mShuttingDown;
 881
 882 #ifdef NIGHTLY_BUILD
 883   // NOTE: This member is atomic because it can be accessed from
 884   // off-main-thread.
 885   mozilla::Atomic<uint32_t> mPendingInputEvents;
 886 #endif
 887
 888   uint32_t mNetworkLinkType = 0;
 889
 890   // See `BrowsingContext::mEpochs` for an explanation of this field.
 891   uint64_t mBrowsingContextFieldEpoch = 0;
 892
 893   hal::ProcessPriority mProcessPriority = hal::PROCESS_PRIORITY_UNKNOWN;
 894
 895   // Session created when the process priority is FOREGROUND to ensure high
 896   // priority scheduling of important threads. (Currently main thread and style
 897   // threads.) The work duration is reported by the RefreshDriverTimer.
 898   UniquePtr<hal::PerformanceHintSession> mPerformanceHintSession;
 899 };
 900
 901 inline nsISupports* ToSupports(mozilla::dom::ContentChild* aContentChild) {
 902   return static_cast<nsIDOMProcessChild*>(aContentChild);
 903 }
 904
 905 }  // namespace dom
 906 }  // namespace mozilla
 907
 908 #endif  // mozilla_dom_ContentChild_h