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