tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

ContentChild.h (35890B)

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