diff options
Diffstat (limited to 'dom/ipc/ContentParent.h')
| -rw-r--r-- | dom/ipc/ContentParent.h | 1197 |
1 files changed, 1197 insertions, 0 deletions
diff --git a/dom/ipc/ContentParent.h b/dom/ipc/ContentParent.h new file mode 100644 index 000000000..a3750de1a --- /dev/null +++ b/dom/ipc/ContentParent.h @@ -0,0 +1,1197 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#ifndef mozilla_dom_ContentParent_h +#define mozilla_dom_ContentParent_h + +#include "mozilla/dom/PContentParent.h" +#include "mozilla/dom/nsIContentParent.h" +#include "mozilla/gfx/gfxVarReceiver.h" +#include "mozilla/gfx/GPUProcessListener.h" +#include "mozilla/ipc/GeckoChildProcessHost.h" +#include "mozilla/Attributes.h" +#include "mozilla/FileUtils.h" +#include "mozilla/HalTypes.h" +#include "mozilla/LinkedList.h" +#include "mozilla/StaticPtr.h" +#include "mozilla/UniquePtr.h" + +#include "nsDataHashtable.h" +#include "nsFrameMessageManager.h" +#include "nsHashKeys.h" +#include "nsIObserver.h" +#include "nsIThreadInternal.h" +#include "nsIDOMGeoPositionCallback.h" +#include "nsIDOMGeoPositionErrorCallback.h" +#include "nsRefPtrHashtable.h" +#include "PermissionMessageUtils.h" +#include "DriverCrashGuard.h" + +#define CHILD_PROCESS_SHUTDOWN_MESSAGE NS_LITERAL_STRING("child-process-shutdown") + +class mozIApplication; +class nsConsoleService; +class nsICycleCollectorLogSink; +class nsIDumpGCAndCCLogsCallback; +class nsITimer; +class ParentIdleListener; +class nsIWidget; + +namespace mozilla { +class PRemoteSpellcheckEngineParent; +#ifdef MOZ_ENABLE_PROFILER_SPS +class ProfileGatherer; +#endif + +#if defined(XP_LINUX) && defined(MOZ_CONTENT_SANDBOX) +class SandboxBroker; +class SandboxBrokerPolicyFactory; +#endif + +namespace embedding { +class PrintingParent; +} + +namespace ipc { +class OptionalURIParams; +class PFileDescriptorSetParent; +class URIParams; +class TestShellParent; +} // namespace ipc + +namespace jsipc { +class PJavaScriptParent; +} // namespace jsipc + +namespace layers { +struct TextureFactoryIdentifier; +} // namespace layers + +namespace layout { +class PRenderFrameParent; +} // namespace layout + +namespace dom { + +class Element; +class TabParent; +class PStorageParent; +class ClonedMessageData; +class MemoryReport; +class TabContext; +class ContentBridgeParent; +class GetFilesHelper; + +class ContentParent final : public PContentParent + , public nsIContentParent + , public nsIObserver + , public nsIDOMGeoPositionCallback + , public nsIDOMGeoPositionErrorCallback + , public gfx::gfxVarReceiver + , public mozilla::LinkedListElement<ContentParent> + , public gfx::GPUProcessListener +{ + typedef mozilla::ipc::GeckoChildProcessHost GeckoChildProcessHost; + typedef mozilla::ipc::OptionalURIParams OptionalURIParams; + typedef mozilla::ipc::PFileDescriptorSetParent PFileDescriptorSetParent; + typedef mozilla::ipc::TestShellParent TestShellParent; + typedef mozilla::ipc::URIParams URIParams; + typedef mozilla::ipc::PrincipalInfo PrincipalInfo; + typedef mozilla::dom::ClonedMessageData ClonedMessageData; + +public: + + virtual bool IsContentParent() const override { return true; } + + /** + * Start up the content-process machinery. This might include + * scheduling pre-launch tasks. + */ + static void StartUp(); + + /** Shut down the content-process machinery. */ + static void ShutDown(); + + /** + * Ensure that all subprocesses are terminated and their OS + * resources have been reaped. This is synchronous and can be + * very expensive in general. It also bypasses the normal + * shutdown process. + */ + static void JoinAllSubprocesses(); + + static bool PreallocatedProcessReady(); + + /** + * Get or create a content process for: + * 1. browser iframe + * 2. remote xul <browser> + * 3. normal iframe + */ + static already_AddRefed<ContentParent> + GetNewOrUsedBrowserProcess(bool aForBrowserElement = false, + hal::ProcessPriority aPriority = + hal::ProcessPriority::PROCESS_PRIORITY_FOREGROUND, + ContentParent* aOpener = nullptr, + bool aLargeAllocationProcess = false); + + /** + * Create a subprocess suitable for use as a preallocated app process. + */ + static already_AddRefed<ContentParent> PreallocateAppProcess(); + + /** + * Get or create a content process for the given TabContext. aFrameElement + * should be the frame/iframe element with which this process will + * associated. + */ + static TabParent* + CreateBrowserOrApp(const TabContext& aContext, + Element* aFrameElement, + ContentParent* aOpenerContentParent, + bool aFreshProcess = false); + + static void GetAll(nsTArray<ContentParent*>& aArray); + + static void GetAllEvenIfDead(nsTArray<ContentParent*>& aArray); + + enum CPIteratorPolicy { + eLive, + eAll + }; + + class ContentParentIterator { + private: + ContentParent* mCurrent; + CPIteratorPolicy mPolicy; + + public: + ContentParentIterator(CPIteratorPolicy aPolicy, ContentParent* aCurrent) + : mCurrent(aCurrent), + mPolicy(aPolicy) + { + } + + ContentParentIterator begin() + { + // Move the cursor to the first element that matches the policy. + while (mPolicy != eAll && mCurrent && !mCurrent->mIsAlive) { + mCurrent = mCurrent->LinkedListElement<ContentParent>::getNext(); + } + + return *this; + } + ContentParentIterator end() + { + return ContentParentIterator(mPolicy, nullptr); + } + + const ContentParentIterator& operator++() + { + MOZ_ASSERT(mCurrent); + do { + mCurrent = mCurrent->LinkedListElement<ContentParent>::getNext(); + } while (mPolicy != eAll && mCurrent && !mCurrent->mIsAlive); + + return *this; + } + + bool operator!=(const ContentParentIterator& aOther) + { + MOZ_ASSERT(mPolicy == aOther.mPolicy); + return mCurrent != aOther.mCurrent; + } + + ContentParent* operator*() + { + return mCurrent; + } + }; + + static ContentParentIterator AllProcesses(CPIteratorPolicy aPolicy) + { + ContentParent* first = + sContentParents ? sContentParents->getFirst() : nullptr; + return ContentParentIterator(aPolicy, first); + } + + static bool IgnoreIPCPrincipal(); + + static void NotifyUpdatedDictionaries(); + +#if defined(XP_WIN) + /** + * Windows helper for firing off an update window request to a plugin + * instance. + * + * aWidget - the eWindowType_plugin_ipc_chrome widget associated with + * this plugin window. + */ + static void SendAsyncUpdate(nsIWidget* aWidget); +#endif + + // Let managees query if it is safe to send messages. + bool IsDestroyed() const { return !mIPCOpen; } + + virtual bool RecvCreateChildProcess(const IPCTabContext& aContext, + const hal::ProcessPriority& aPriority, + const TabId& aOpenerTabId, + ContentParentId* aCpId, + bool* aIsForApp, + bool* aIsForBrowser, + TabId* aTabId) override; + + virtual bool RecvBridgeToChildProcess(const ContentParentId& aCpId) override; + + virtual bool RecvCreateGMPService() override; + + virtual bool RecvLoadPlugin(const uint32_t& aPluginId, nsresult* aRv, + uint32_t* aRunID) override; + + virtual bool RecvConnectPluginBridge(const uint32_t& aPluginId, + nsresult* aRv) override; + + virtual bool RecvGetBlocklistState(const uint32_t& aPluginId, + uint32_t* aIsBlocklisted) override; + + virtual bool RecvFindPlugins(const uint32_t& aPluginEpoch, + nsresult* aRv, + nsTArray<PluginTag>* aPlugins, + uint32_t* aNewPluginEpoch) override; + + virtual bool RecvUngrabPointer(const uint32_t& aTime) override; + + virtual bool RecvRemovePermission(const IPC::Principal& aPrincipal, + const nsCString& aPermissionType, + nsresult* aRv) override; + + NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(ContentParent, nsIObserver) + + NS_DECL_CYCLE_COLLECTING_ISUPPORTS + NS_DECL_NSIOBSERVER + NS_DECL_NSIDOMGEOPOSITIONCALLBACK + NS_DECL_NSIDOMGEOPOSITIONERRORCALLBACK + + /** + * MessageManagerCallback methods that we override. + */ + virtual bool DoLoadMessageManagerScript(const nsAString& aURL, + bool aRunInGlobalScope) override; + + virtual nsresult DoSendAsyncMessage(JSContext* aCx, + const nsAString& aMessage, + StructuredCloneData& aData, + JS::Handle<JSObject *> aCpows, + nsIPrincipal* aPrincipal) override; + + virtual bool CheckPermission(const nsAString& aPermission) override; + + virtual bool CheckManifestURL(const nsAString& aManifestURL) override; + + virtual bool CheckAppHasPermission(const nsAString& aPermission) override; + + virtual bool CheckAppHasStatus(unsigned short aStatus) override; + + virtual bool KillChild() override; + + /** Notify that a tab is beginning its destruction sequence. */ + static void NotifyTabDestroying(const TabId& aTabId, + const ContentParentId& aCpId); + + /** Notify that a tab was destroyed during normal operation. */ + void NotifyTabDestroyed(const TabId& aTabId, + bool aNotifiedDestroying); + + TestShellParent* CreateTestShell(); + + bool DestroyTestShell(TestShellParent* aTestShell); + + TestShellParent* GetTestShellSingleton(); + + jsipc::CPOWManager* GetCPOWManager() override; + + static TabId + AllocateTabId(const TabId& aOpenerTabId, + const IPCTabContext& aContext, + const ContentParentId& aCpId); + + static void + DeallocateTabId(const TabId& aTabId, + const ContentParentId& aCpId, + bool aMarkedDestroying); + + void ReportChildAlreadyBlocked(); + + bool RequestRunToCompletion(); + + bool IsAlive() const; + + virtual bool IsForApp() const override; + + virtual bool IsForBrowser() const override + { + return mIsForBrowser; + } + + GeckoChildProcessHost* Process() const + { + return mSubprocess; + } + + ContentParent* Opener() const + { + return mOpener; + } + + bool NeedsPermissionsUpdate() const + { + return mSendPermissionUpdates; + } + + /** + * Kill our subprocess and make sure it dies. Should only be used + * in emergency situations since it bypasses the normal shutdown + * process. + * + * WARNING: aReason appears in telemetry, so any new value passed in requires + * data review. + */ + void KillHard(const char* aWhy); + + ContentParentId ChildID() const override { return mChildID; } + + const nsString& AppManifestURL() const { return mAppManifestURL; } + + bool IsPreallocated() const; + + /** + * Get a user-friendly name for this ContentParent. We make no guarantees + * about this name: It might not be unique, apps can spoof special names, + * etc. So please don't use this name to make any decisions about the + * ContentParent based on the value returned here. + */ + void FriendlyName(nsAString& aName, bool aAnonymize = false); + + virtual void OnChannelError() override; + + virtual PCrashReporterParent* + AllocPCrashReporterParent(const NativeThreadId& tid, + const uint32_t& processType) override; + + virtual bool + RecvPCrashReporterConstructor(PCrashReporterParent* actor, + const NativeThreadId& tid, + const uint32_t& processType) override; + + virtual PNeckoParent* AllocPNeckoParent() override; + + virtual bool RecvPNeckoConstructor(PNeckoParent* aActor) override + { + return PContentParent::RecvPNeckoConstructor(aActor); + } + + virtual PPrintingParent* AllocPPrintingParent() override; + + virtual bool DeallocPPrintingParent(PPrintingParent* aActor) override; + +#if defined(NS_PRINTING) + /** + * @return the PrintingParent for this ContentParent. + */ + already_AddRefed<embedding::PrintingParent> GetPrintingParent(); +#endif + + virtual PSendStreamParent* AllocPSendStreamParent() override; + virtual bool DeallocPSendStreamParent(PSendStreamParent* aActor) override; + + virtual PScreenManagerParent* + AllocPScreenManagerParent(uint32_t* aNumberOfScreens, + float* aSystemDefaultScale, + bool* aSuccess) override; + + virtual bool + DeallocPScreenManagerParent(PScreenManagerParent* aActor) override; + + virtual PHalParent* AllocPHalParent() override; + + virtual bool RecvPHalConstructor(PHalParent* aActor) override + { + return PContentParent::RecvPHalConstructor(aActor); + } + + virtual PHeapSnapshotTempFileHelperParent* + AllocPHeapSnapshotTempFileHelperParent() override; + + virtual PStorageParent* AllocPStorageParent() override; + + virtual bool RecvPStorageConstructor(PStorageParent* aActor) override + { + return PContentParent::RecvPStorageConstructor(aActor); + } + + virtual PJavaScriptParent* + AllocPJavaScriptParent() override; + + virtual bool + RecvPJavaScriptConstructor(PJavaScriptParent* aActor) override + { + return PContentParent::RecvPJavaScriptConstructor(aActor); + } + + virtual PRemoteSpellcheckEngineParent* AllocPRemoteSpellcheckEngineParent() override; + + virtual bool RecvRecordingDeviceEvents(const nsString& aRecordingStatus, + const nsString& aPageURL, + const bool& aIsAudio, + const bool& aIsVideo) override; + + bool CycleCollectWithLogs(bool aDumpAllTraces, + nsICycleCollectorLogSink* aSink, + nsIDumpGCAndCCLogsCallback* aCallback); + + virtual PBlobParent* + SendPBlobConstructor(PBlobParent* aActor, + const BlobConstructorParams& aParams) override; + + virtual bool RecvAllocateTabId(const TabId& aOpenerTabId, + const IPCTabContext& aContext, + const ContentParentId& aCpId, + TabId* aTabId) override; + + virtual bool RecvDeallocateTabId(const TabId& aTabId, + const ContentParentId& aCpId, + const bool& aMarkedDestroying) override; + + virtual bool RecvNotifyTabDestroying(const TabId& aTabId, + const ContentParentId& aCpId) override; + + nsTArray<TabContext> GetManagedTabContext(); + + virtual POfflineCacheUpdateParent* + AllocPOfflineCacheUpdateParent(const URIParams& aManifestURI, + const URIParams& aDocumentURI, + const PrincipalInfo& aLoadingPrincipalInfo, + const bool& aStickDocument) override; + + virtual bool + RecvPOfflineCacheUpdateConstructor(POfflineCacheUpdateParent* aActor, + const URIParams& aManifestURI, + const URIParams& aDocumentURI, + const PrincipalInfo& aLoadingPrincipal, + const bool& stickDocument) override; + + virtual bool + DeallocPOfflineCacheUpdateParent(POfflineCacheUpdateParent* aActor) override; + + virtual bool RecvSetOfflinePermission(const IPC::Principal& principal) override; + + virtual bool RecvFinishShutdown() override; + + void MaybeInvokeDragSession(TabParent* aParent); + + virtual PContentPermissionRequestParent* + AllocPContentPermissionRequestParent(const InfallibleTArray<PermissionRequest>& aRequests, + const IPC::Principal& aPrincipal, + const TabId& aTabId) override; + + virtual bool + DeallocPContentPermissionRequestParent(PContentPermissionRequestParent* actor) override; + + virtual bool HandleWindowsMessages(const Message& aMsg) const override; + + void ForkNewProcess(bool aBlocking); + + virtual bool RecvCreateWindow(PBrowserParent* aThisTabParent, + PBrowserParent* aOpener, + layout::PRenderFrameParent* aRenderFrame, + const uint32_t& aChromeFlags, + const bool& aCalledFromJS, + const bool& aPositionSpecified, + const bool& aSizeSpecified, + const nsCString& aFeatures, + const nsCString& aBaseURI, + const DocShellOriginAttributes& aOpenerOriginAttributes, + const float& aFullZoom, + nsresult* aResult, + bool* aWindowIsNew, + InfallibleTArray<FrameScriptInfo>* aFrameScripts, + nsCString* aURLToLoad, + layers::TextureFactoryIdentifier* aTextureFactoryIdentifier, + uint64_t* aLayersId) override; + + static bool AllocateLayerTreeId(TabParent* aTabParent, uint64_t* aId); + + static void + BroadcastBlobURLRegistration(const nsACString& aURI, + BlobImpl* aBlobImpl, + nsIPrincipal* aPrincipal, + ContentParent* aIgnoreThisCP = nullptr); + + static void + BroadcastBlobURLUnregistration(const nsACString& aURI, + ContentParent* aIgnoreThisCP = nullptr); + + virtual bool + RecvStoreAndBroadcastBlobURLRegistration(const nsCString& aURI, + PBlobParent* aBlobParent, + const Principal& aPrincipal) override; + + virtual bool + RecvUnstoreAndBroadcastBlobURLUnregistration(const nsCString& aURI) override; + + virtual bool + RecvGetA11yContentId(uint32_t* aContentId) override; + + virtual int32_t Pid() const override; + + // Use the PHangMonitor channel to ask the child to repaint a tab. + void ForceTabPaint(TabParent* aTabParent, uint64_t aLayerObserverEpoch); + +protected: + void OnChannelConnected(int32_t pid) override; + + virtual void ActorDestroy(ActorDestroyReason why) override; + + bool ShouldContinueFromReplyTimeout() override; + + void OnVarChanged(const GfxVarUpdate& aVar) override; + void OnCompositorUnexpectedShutdown() override; + +private: + static nsDataHashtable<nsStringHashKey, ContentParent*> *sAppContentParents; + static nsTArray<ContentParent*>* sNonAppContentParents; + static nsTArray<ContentParent*>* sLargeAllocationContentParents; + static nsTArray<ContentParent*>* sPrivateContent; + static StaticAutoPtr<LinkedList<ContentParent> > sContentParents; + + static void JoinProcessesIOThread(const nsTArray<ContentParent*>* aProcesses, + Monitor* aMonitor, bool* aDone); + + // Take the preallocated process and transform it into a "real" app process, + // for the specified manifest URL. If there is no preallocated process (or + // if it's dead), create a new one and set aTookPreAllocated to false. + static already_AddRefed<ContentParent> + GetNewOrPreallocatedAppProcess(mozIApplication* aApp, + hal::ProcessPriority aInitialPriority, + ContentParent* aOpener, + /*out*/ bool* aTookPreAllocated = nullptr); + + static hal::ProcessPriority GetInitialProcessPriority(Element* aFrameElement); + + static ContentBridgeParent* CreateContentBridgeParent(const TabContext& aContext, + const hal::ProcessPriority& aPriority, + const TabId& aOpenerTabId, + /*out*/ TabId* aTabId); + + // Hide the raw constructor methods since we don't want client code + // using them. + virtual PBrowserParent* SendPBrowserConstructor( + PBrowserParent* actor, + const TabId& aTabId, + const IPCTabContext& context, + const uint32_t& chromeFlags, + const ContentParentId& aCpId, + const bool& aIsForApp, + const bool& aIsForBrowser) override; + using PContentParent::SendPTestShellConstructor; + + FORWARD_SHMEM_ALLOCATOR_TO(PContentParent) + + // No more than one of !!aApp, aIsForBrowser, and aIsForPreallocated may be + // true. + ContentParent(mozIApplication* aApp, + ContentParent* aOpener, + bool aIsForBrowser, + bool aIsForPreallocated); + + // The common initialization for the constructors. + void InitializeMembers(); + + // Launch the subprocess and associated initialization. + // Returns false if the process fails to start. + bool LaunchSubprocess(hal::ProcessPriority aInitialPriority = hal::PROCESS_PRIORITY_FOREGROUND); + + // Common initialization after sub process launch or adoption. + void InitInternal(ProcessPriority aPriority, + bool aSetupOffMainThreadCompositing, + bool aSendRegisteredChrome); + + virtual ~ContentParent(); + + void Init(); + + // Some information could be sent to content very early, it + // should be send from this function. This function should only be + // called after the process has been transformed to app or browser. + void ForwardKnownInfo(); + + // Set the child process's priority and then check whether the child is + // still alive. Returns true if the process is still alive, and false + // otherwise. If you pass a FOREGROUND* priority here, it's (hopefully) + // unlikely that the process will be killed after this point. + bool SetPriorityAndCheckIsAlive(hal::ProcessPriority aPriority); + + // Transform a pre-allocated app process into a "real" app + // process, for the specified manifest URL. + void TransformPreallocatedIntoApp(ContentParent* aOpener, + const nsAString& aAppManifestURL); + + // Transform a pre-allocated app process into a browser process. If this + // returns false, the child process has died. + void TransformPreallocatedIntoBrowser(ContentParent* aOpener); + + /** + * Mark this ContentParent as dead for the purposes of Get*(). + * This method is idempotent. + */ + void MarkAsDead(); + + /** + * How we will shut down this ContentParent and its subprocess. + */ + enum ShutDownMethod + { + // Send a shutdown message and wait for FinishShutdown call back. + SEND_SHUTDOWN_MESSAGE, + // Close the channel ourselves and let the subprocess clean up itself. + CLOSE_CHANNEL, + // Close the channel with error and let the subprocess clean up itself. + CLOSE_CHANNEL_WITH_ERROR, + }; + + /** + * Exit the subprocess and vamoose. After this call IsAlive() + * will return false and this ContentParent will not be returned + * by the Get*() funtions. However, the shutdown sequence itself + * may be asynchronous. + * + * If aMethod is CLOSE_CHANNEL_WITH_ERROR and this is the first call + * to ShutDownProcess, then we'll close our channel using CloseWithError() + * rather than vanilla Close(). CloseWithError() indicates to IPC that this + * is an abnormal shutdown (e.g. a crash). + */ + void ShutDownProcess(ShutDownMethod aMethod); + + // Perform any steps necesssary to gracefully shtudown the message + // manager and null out mMessageManager. + void ShutDownMessageManager(); + + // Start the force-kill timer on shutdown. + void StartForceKillTimer(); + + static void ForceKillTimerCallback(nsITimer* aTimer, void* aClosure); + + static bool AllocateLayerTreeId(ContentParent* aContent, + TabParent* aTopLevel, const TabId& aTabId, + uint64_t* aId); + + PGMPServiceParent* + AllocPGMPServiceParent(mozilla::ipc::Transport* aTransport, + base::ProcessId aOtherProcess) override; + + PBackgroundParent* + AllocPBackgroundParent(Transport* aTransport, ProcessId aOtherProcess) + override; + + PProcessHangMonitorParent* + AllocPProcessHangMonitorParent(Transport* aTransport, + ProcessId aOtherProcess) override; + + virtual bool RecvGetProcessAttributes(ContentParentId* aCpId, + bool* aIsForApp, + bool* aIsForBrowser) override; + + virtual bool + RecvGetXPCOMProcessAttributes(bool* aIsOffline, + bool* aIsConnected, + int32_t* aCaptivePortalState, + bool* aIsLangRTL, + bool* aHaveBidiKeyboards, + InfallibleTArray<nsString>* dictionaries, + ClipboardCapabilities* clipboardCaps, + DomainPolicyClone* domainPolicy, + StructuredCloneData* initialData, + OptionalURIParams* aUserContentSheetURL) override; + + virtual bool + DeallocPJavaScriptParent(mozilla::jsipc::PJavaScriptParent*) override; + + virtual bool + DeallocPRemoteSpellcheckEngineParent(PRemoteSpellcheckEngineParent*) override; + + virtual PBrowserParent* AllocPBrowserParent(const TabId& aTabId, + const IPCTabContext& aContext, + const uint32_t& aChromeFlags, + const ContentParentId& aCpId, + const bool& aIsForApp, + const bool& aIsForBrowser) override; + + virtual bool DeallocPBrowserParent(PBrowserParent* frame) override; + + virtual PBlobParent* + AllocPBlobParent(const BlobConstructorParams& aParams) override; + + virtual bool DeallocPBlobParent(PBlobParent* aActor) override; + + virtual bool + RecvPBlobConstructor(PBlobParent* aActor, + const BlobConstructorParams& params) override; + + virtual bool + DeallocPCrashReporterParent(PCrashReporterParent* crashreporter) override; + + virtual bool RecvNSSU2FTokenIsCompatibleVersion(const nsString& aVersion, + bool* aIsCompatible) override; + + virtual bool RecvNSSU2FTokenIsRegistered(nsTArray<uint8_t>&& aKeyHandle, + bool* aIsValidKeyHandle) override; + + virtual bool RecvNSSU2FTokenRegister(nsTArray<uint8_t>&& aApplication, + nsTArray<uint8_t>&& aChallenge, + nsTArray<uint8_t>* aRegistration) override; + + virtual bool RecvNSSU2FTokenSign(nsTArray<uint8_t>&& aApplication, + nsTArray<uint8_t>&& aChallenge, + nsTArray<uint8_t>&& aKeyHandle, + nsTArray<uint8_t>* aSignature) override; + + virtual bool RecvIsSecureURI(const uint32_t& aType, const URIParams& aURI, + const uint32_t& aFlags, bool* aIsSecureURI) override; + + virtual bool RecvAccumulateMixedContentHSTS(const URIParams& aURI, + const bool& aActive, + const bool& aHSTSPriming) override; + + virtual bool DeallocPHalParent(PHalParent*) override; + + virtual bool + DeallocPHeapSnapshotTempFileHelperParent(PHeapSnapshotTempFileHelperParent*) override; + + virtual PMemoryReportRequestParent* + AllocPMemoryReportRequestParent(const uint32_t& aGeneration, + const bool &aAnonymize, + const bool &aMinimizeMemoryUsage, + const MaybeFileDesc &aDMDFile) override; + + virtual bool + DeallocPMemoryReportRequestParent(PMemoryReportRequestParent* actor) override; + + virtual PCycleCollectWithLogsParent* + AllocPCycleCollectWithLogsParent(const bool& aDumpAllTraces, + const FileDescriptor& aGCLog, + const FileDescriptor& aCCLog) override; + + virtual bool + DeallocPCycleCollectWithLogsParent(PCycleCollectWithLogsParent* aActor) override; + + virtual PTestShellParent* AllocPTestShellParent() override; + + virtual bool DeallocPTestShellParent(PTestShellParent* shell) override; + + virtual bool DeallocPNeckoParent(PNeckoParent* necko) override; + + virtual PPSMContentDownloaderParent* + AllocPPSMContentDownloaderParent(const uint32_t& aCertType) override; + + virtual bool + DeallocPPSMContentDownloaderParent(PPSMContentDownloaderParent* aDownloader) override; + + virtual PExternalHelperAppParent* + AllocPExternalHelperAppParent(const OptionalURIParams& aUri, + const nsCString& aMimeContentType, + const nsCString& aContentDisposition, + const uint32_t& aContentDispositionHint, + const nsString& aContentDispositionFilename, + const bool& aForceSave, + const int64_t& aContentLength, + const bool& aWasFileChannel, + const OptionalURIParams& aReferrer, + PBrowserParent* aBrowser) override; + + virtual bool + DeallocPExternalHelperAppParent(PExternalHelperAppParent* aService) override; + + virtual PHandlerServiceParent* AllocPHandlerServiceParent() override; + + virtual bool DeallocPHandlerServiceParent(PHandlerServiceParent*) override; + + virtual PMediaParent* AllocPMediaParent() override; + + virtual bool DeallocPMediaParent(PMediaParent* aActor) override; + + virtual bool DeallocPStorageParent(PStorageParent* aActor) override; + + virtual PPresentationParent* AllocPPresentationParent() override; + + virtual bool DeallocPPresentationParent(PPresentationParent* aActor) override; + + virtual bool RecvPPresentationConstructor(PPresentationParent* aActor) override; + + virtual PFlyWebPublishedServerParent* + AllocPFlyWebPublishedServerParent(const nsString& name, + const FlyWebPublishOptions& params) override; + + virtual bool DeallocPFlyWebPublishedServerParent(PFlyWebPublishedServerParent* aActor) override; + + virtual PSpeechSynthesisParent* AllocPSpeechSynthesisParent() override; + + virtual bool + DeallocPSpeechSynthesisParent(PSpeechSynthesisParent* aActor) override; + + virtual bool + RecvPSpeechSynthesisConstructor(PSpeechSynthesisParent* aActor) override; + + virtual PWebBrowserPersistDocumentParent* + AllocPWebBrowserPersistDocumentParent(PBrowserParent* aBrowser, + const uint64_t& aOuterWindowID) override; + + virtual bool + DeallocPWebBrowserPersistDocumentParent(PWebBrowserPersistDocumentParent* aActor) override; + + virtual bool RecvReadPrefsArray(InfallibleTArray<PrefSetting>* aPrefs) override; + virtual bool RecvGetGfxVars(InfallibleTArray<GfxVarUpdate>* aVars) override; + + virtual bool RecvReadFontList(InfallibleTArray<FontListEntry>* retValue) override; + + virtual bool RecvReadDataStorageArray(const nsString& aFilename, + InfallibleTArray<DataStorageItem>* aValues) override; + + virtual bool RecvReadPermissions(InfallibleTArray<IPC::Permission>* aPermissions) override; + + virtual bool RecvSetClipboard(const IPCDataTransfer& aDataTransfer, + const bool& aIsPrivateData, + const IPC::Principal& aRequestingPrincipal, + const int32_t& aWhichClipboard) override; + + virtual bool RecvGetClipboard(nsTArray<nsCString>&& aTypes, + const int32_t& aWhichClipboard, + IPCDataTransfer* aDataTransfer) override; + + virtual bool RecvEmptyClipboard(const int32_t& aWhichClipboard) override; + + virtual bool RecvClipboardHasType(nsTArray<nsCString>&& aTypes, + const int32_t& aWhichClipboard, + bool* aHasType) override; + + virtual bool RecvGetSystemColors(const uint32_t& colorsCount, + InfallibleTArray<uint32_t>* colors) override; + + virtual bool RecvGetIconForExtension(const nsCString& aFileExt, + const uint32_t& aIconSize, + InfallibleTArray<uint8_t>* bits) override; + + virtual bool RecvGetShowPasswordSetting(bool* showPassword) override; + + virtual bool RecvStartVisitedQuery(const URIParams& uri) override; + + virtual bool RecvVisitURI(const URIParams& uri, + const OptionalURIParams& referrer, + const uint32_t& flags) override; + + virtual bool RecvSetURITitle(const URIParams& uri, + const nsString& title) override; + + bool HasNotificationPermission(const IPC::Principal& aPrincipal); + + virtual bool RecvShowAlert(const AlertNotificationType& aAlert) override; + + virtual bool RecvCloseAlert(const nsString& aName, + const IPC::Principal& aPrincipal) override; + + virtual bool RecvDisableNotifications(const IPC::Principal& aPrincipal) override; + + virtual bool RecvOpenNotificationSettings(const IPC::Principal& aPrincipal) override; + + virtual bool RecvLoadURIExternal(const URIParams& uri, + PBrowserParent* windowContext) override; + virtual bool RecvExtProtocolChannelConnectParent(const uint32_t& registrarId) override; + + virtual bool RecvSyncMessage(const nsString& aMsg, + const ClonedMessageData& aData, + InfallibleTArray<CpowEntry>&& aCpows, + const IPC::Principal& aPrincipal, + nsTArray<StructuredCloneData>* aRetvals) override; + + virtual bool RecvRpcMessage(const nsString& aMsg, + const ClonedMessageData& aData, + InfallibleTArray<CpowEntry>&& aCpows, + const IPC::Principal& aPrincipal, + nsTArray<StructuredCloneData>* aRetvals) override; + + virtual bool RecvAsyncMessage(const nsString& aMsg, + InfallibleTArray<CpowEntry>&& aCpows, + const IPC::Principal& aPrincipal, + const ClonedMessageData& aData) override; + + virtual bool RecvAddGeolocationListener(const IPC::Principal& aPrincipal, + const bool& aHighAccuracy) override; + virtual bool RecvRemoveGeolocationListener() override; + + virtual bool RecvSetGeolocationHigherAccuracy(const bool& aEnable) override; + + virtual bool RecvConsoleMessage(const nsString& aMessage) override; + + virtual bool RecvScriptError(const nsString& aMessage, + const nsString& aSourceName, + const nsString& aSourceLine, + const uint32_t& aLineNumber, + const uint32_t& aColNumber, + const uint32_t& aFlags, + const nsCString& aCategory) override; + + virtual bool RecvPrivateDocShellsExist(const bool& aExist) override; + + virtual bool RecvFirstIdle() override; + + virtual bool RecvAudioChannelChangeDefVolChannel(const int32_t& aChannel, + const bool& aHidden) override; + + virtual bool RecvAudioChannelServiceStatus(const bool& aTelephonyChannel, + const bool& aContentOrNormalChannel, + const bool& aAnyChannel) override; + + virtual bool RecvGetLookAndFeelCache(nsTArray<LookAndFeelInt>* aLookAndFeelIntCache) override; + + virtual bool RecvSpeakerManagerGetSpeakerStatus(bool* aValue) override; + + virtual bool RecvSpeakerManagerForceSpeaker(const bool& aEnable) override; + + virtual bool RecvCreateFakeVolume(const nsString& aFsName, + const nsString& aMountPoint) override; + + virtual bool RecvSetFakeVolumeState(const nsString& aFsName, + const int32_t& aFsState) override; + + virtual bool RecvRemoveFakeVolume(const nsString& fsName) override; + + virtual bool RecvKeywordToURI(const nsCString& aKeyword, + nsString* aProviderName, + OptionalInputStreamParams* aPostData, + OptionalURIParams* aURI) override; + + virtual bool RecvNotifyKeywordSearchLoading(const nsString &aProvider, + const nsString &aKeyword) override; + + virtual bool RecvCopyFavicon(const URIParams& aOldURI, + const URIParams& aNewURI, + const IPC::Principal& aLoadingPrincipal, + const bool& aInPrivateBrowsing) override; + + virtual void ProcessingError(Result aCode, const char* aMsgName) override; + + virtual bool RecvAllocateLayerTreeId(const ContentParentId& aCpId, + const TabId& aTabId, + uint64_t* aId) override; + + virtual bool RecvDeallocateLayerTreeId(const uint64_t& aId) override; + + virtual bool RecvGetGraphicsFeatureStatus(const int32_t& aFeature, + int32_t* aStatus, + nsCString* aFailureId, + bool* aSuccess) override; + + virtual bool RecvGraphicsError(const nsCString& aError) override; + + virtual bool + RecvBeginDriverCrashGuard(const uint32_t& aGuardType, + bool* aOutCrashed) override; + + virtual bool RecvEndDriverCrashGuard(const uint32_t& aGuardType) override; + + virtual bool RecvAddIdleObserver(const uint64_t& observerId, + const uint32_t& aIdleTimeInS) override; + + virtual bool RecvRemoveIdleObserver(const uint64_t& observerId, + const uint32_t& aIdleTimeInS) override; + + virtual bool + RecvBackUpXResources(const FileDescriptor& aXSocketFd) override; + + virtual bool + RecvOpenAnonymousTemporaryFile(FileDescOrError* aFD) override; + + virtual bool + RecvKeygenProcessValue(const nsString& oldValue, const nsString& challenge, + const nsString& keytype, const nsString& keyparams, + nsString* newValue) override; + + virtual bool + RecvKeygenProvideContent(nsString* aAttribute, + nsTArray<nsString>* aContent) override; + + virtual PFileDescriptorSetParent* + AllocPFileDescriptorSetParent(const mozilla::ipc::FileDescriptor&) override; + + virtual bool + DeallocPFileDescriptorSetParent(PFileDescriptorSetParent*) override; + + virtual PWebrtcGlobalParent* AllocPWebrtcGlobalParent() override; + virtual bool DeallocPWebrtcGlobalParent(PWebrtcGlobalParent *aActor) override; + + + virtual bool RecvUpdateDropEffect(const uint32_t& aDragAction, + const uint32_t& aDropEffect) override; + + virtual bool RecvProfile(const nsCString& aProfile) override; + + virtual bool RecvGetGraphicsDeviceInitData(ContentDeviceData* aOut) override; + + void StartProfiler(nsIProfilerStartParams* aParams); + + virtual bool RecvGetAndroidSystemInfo(AndroidSystemInfo* aInfo) override; + + virtual bool RecvNotifyBenchmarkResult(const nsString& aCodecName, + const uint32_t& aDecodeFPS) override; + + virtual bool RecvNotifyPushObservers(const nsCString& aScope, + const IPC::Principal& aPrincipal, + const nsString& aMessageId) override; + + virtual bool RecvNotifyPushObserversWithData(const nsCString& aScope, + const IPC::Principal& aPrincipal, + const nsString& aMessageId, + InfallibleTArray<uint8_t>&& aData) override; + + virtual bool RecvNotifyPushSubscriptionChangeObservers(const nsCString& aScope, + const IPC::Principal& aPrincipal) override; + + virtual bool RecvNotifyPushSubscriptionModifiedObservers(const nsCString& aScope, + const IPC::Principal& aPrincipal) override; + + virtual bool RecvNotifyLowMemory() override; + + virtual bool RecvGetFilesRequest(const nsID& aID, + const nsString& aDirectoryPath, + const bool& aRecursiveFlag) override; + + virtual bool RecvDeleteGetFilesRequest(const nsID& aID) override; + + virtual bool RecvAccumulateChildHistogram( + InfallibleTArray<Accumulation>&& aAccumulations) override; + virtual bool RecvAccumulateChildKeyedHistogram( + InfallibleTArray<KeyedAccumulation>&& aAccumulations) override; +public: + void SendGetFilesResponseAndForget(const nsID& aID, + const GetFilesResponseResult& aResult); + +private: + + // If you add strong pointers to cycle collected objects here, be sure to + // release these objects in ShutDownProcess. See the comment there for more + // details. + + GeckoChildProcessHost* mSubprocess; + ContentParent* mOpener; + + ContentParentId mChildID; + int32_t mGeolocationWatchID; + + nsString mAppManifestURL; + + nsCString mKillHardAnnotation; + + /** + * We cache mAppName instead of looking it up using mAppManifestURL when we + * need it because it turns out that getting an app from the apps service is + * expensive. + */ + nsString mAppName; + + // After we initiate shutdown, we also start a timer to ensure + // that even content processes that are 100% blocked (say from + // SIGSTOP), are still killed eventually. This task enforces that + // timer. + nsCOMPtr<nsITimer> mForceKillTimer; + // How many tabs we're waiting to finish their destruction + // sequence. Precisely, how many TabParents have called + // NotifyTabDestroying() but not called NotifyTabDestroyed(). + int32_t mNumDestroyingTabs; + // True only while this is ready to be used to host remote tabs. + // This must not be used for new purposes after mIsAlive goes to + // false, but some previously scheduled IPC traffic may still pass + // through. + bool mIsAlive; + + // True only the if process is already a browser or app or has + // been transformed into one. + bool mMetamorphosed; + + bool mSendPermissionUpdates; + bool mIsForBrowser; + + // These variables track whether we've called Close() and KillHard() on our + // channel. + bool mCalledClose; + bool mCalledKillHard; + bool mCreatedPairedMinidumps; + bool mShutdownPending; + bool mIPCOpen; + + friend class CrashReporterParent; + + RefPtr<nsConsoleService> mConsoleService; + nsConsoleService* GetConsoleService(); + + nsTArray<nsCOMPtr<nsIObserver>> mIdleListeners; + +#ifdef MOZ_X11 + // Dup of child's X socket, used to scope its resources to this + // object instead of the child process's lifetime. + ScopedClose mChildXSocketFdDup; +#endif + + PProcessHangMonitorParent* mHangMonitorActor; + +#ifdef MOZ_ENABLE_PROFILER_SPS + RefPtr<mozilla::ProfileGatherer> mGatherer; +#endif + nsCString mProfile; + + UniquePtr<gfx::DriverCrashGuard> mDriverCrashGuard; + +#if defined(XP_LINUX) && defined(MOZ_CONTENT_SANDBOX) + mozilla::UniquePtr<SandboxBroker> mSandboxBroker; + static mozilla::UniquePtr<SandboxBrokerPolicyFactory> + sSandboxBrokerPolicyFactory; +#endif + +#ifdef NS_PRINTING + RefPtr<embedding::PrintingParent> mPrintingParent; +#endif + + // This hashtable is used to run GetFilesHelper objects in the parent process. + // GetFilesHelper can be aborted by receiving RecvDeleteGetFilesRequest. + nsRefPtrHashtable<nsIDHashKey, GetFilesHelper> mGetFilesPendingRequests; + + nsTArray<nsCString> mBlobURLs; + bool mLargeAllocationProcess; +}; + +} // namespace dom +} // namespace mozilla + +class ParentIdleListener : public nsIObserver +{ + friend class mozilla::dom::ContentParent; + +public: + NS_DECL_ISUPPORTS + NS_DECL_NSIOBSERVER + + ParentIdleListener(mozilla::dom::ContentParent* aParent, + uint64_t aObserver, uint32_t aTime) + : mParent(aParent), mObserver(aObserver), mTime(aTime) + {} + +private: + virtual ~ParentIdleListener() {} + + RefPtr<mozilla::dom::ContentParent> mParent; + uint64_t mObserver; + uint32_t mTime; +}; + +#endif // mozilla_dom_ContentParent_h |