diff options
Diffstat (limited to 'netwerk/ipc/SocketProcessHost.h')
-rw-r--r-- | netwerk/ipc/SocketProcessHost.h | 150 |
1 files changed, 150 insertions, 0 deletions
diff --git a/netwerk/ipc/SocketProcessHost.h b/netwerk/ipc/SocketProcessHost.h new file mode 100644 index 0000000000..44648b7fe7 --- /dev/null +++ b/netwerk/ipc/SocketProcessHost.h @@ -0,0 +1,150 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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_net_SocketProcessHost_h +#define mozilla_net_SocketProcessHost_h + +#include "mozilla/Maybe.h" +#include "mozilla/UniquePtr.h" +#include "mozilla/ipc/GeckoChildProcessHost.h" +#include "mozilla/MemoryReportingProcess.h" +#include "mozilla/ipc/TaskFactory.h" + +namespace mozilla { + +#if defined(XP_LINUX) && defined(MOZ_SANDBOX) +class SandboxBroker; +#endif + +namespace net { + +class SocketProcessParent; + +// SocketProcessHost is the "parent process" container for a subprocess handle +// and IPC connection. It owns the parent process IPDL actor, which in this +// case, is a SocketProcessParent. +// SocketProcessHost is allocated and managed by nsIOService in parent process. +class SocketProcessHost final : public mozilla::ipc::GeckoChildProcessHost { + friend class SocketProcessParent; + + public: + class Listener { + public: + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(Listener) + + // Called when the process of launching the process is complete. + virtual void OnProcessLaunchComplete(SocketProcessHost* aHost, + bool aSucceeded) = 0; + + // Called when the channel is closed but Shutdown() is not invoked. + virtual void OnProcessUnexpectedShutdown(SocketProcessHost* aHost) = 0; + + protected: + virtual ~Listener() = default; + }; + + explicit SocketProcessHost(Listener* listener); + + // Launch the socket process asynchronously. + // The OnProcessLaunchComplete listener callback will be invoked + // either when a connection has been established, or if a connection + // could not be established due to an asynchronous error. + bool Launch(); + + // Inform the socket process that it should clean up its resources and shut + // down. This initiates an asynchronous shutdown sequence. After this method + // returns, it is safe for the caller to forget its pointer to the + // SocketProcessHost. + void Shutdown(); + + // Return the actor for the top-level actor of the process. Return null if + // the process is not connected. + SocketProcessParent* GetActor() const { + MOZ_ASSERT(NS_IsMainThread()); + + return mSocketProcessParent.get(); + } + + bool IsConnected() const { + MOZ_ASSERT(NS_IsMainThread()); + + return !!mSocketProcessParent; + } + + // Called on the IO thread. + void OnChannelConnected(base::ProcessId peer_pid) override; + +#if defined(XP_MACOSX) && defined(MOZ_SANDBOX) + // Return the sandbox type to be used with this process type. + static MacSandboxType GetMacSandboxType(); +#endif + + private: + ~SocketProcessHost(); + + // Called on the main thread. + void OnChannelConnectedTask(); + + // Called on the main thread after a connection has been established. + void InitAfterConnect(bool aSucceeded); + + // Called on the main thread when the mSocketParent actor is shutting down. + void OnChannelClosed(); + + void DestroyProcess(); + +#if defined(XP_MACOSX) && defined(MOZ_SANDBOX) + static bool sLaunchWithMacSandbox; + + // Sandbox the Socket process at launch for all instances + bool IsMacSandboxLaunchEnabled() override { return sLaunchWithMacSandbox; } + + // Override so we can turn on Socket process-specific sandbox logging + bool FillMacSandboxInfo(MacSandboxInfo& aInfo) override; +#endif + + DISALLOW_COPY_AND_ASSIGN(SocketProcessHost); + + RefPtr<Listener> mListener; + mozilla::Maybe<mozilla::ipc::TaskFactory<SocketProcessHost>> mTaskFactory; + + enum class LaunchPhase { Unlaunched, Waiting, Complete }; + LaunchPhase mLaunchPhase; + + RefPtr<SocketProcessParent> mSocketProcessParent; + // mShutdownRequested is set to true only when Shutdown() is called. + // If mShutdownRequested is false and the IPC channel is closed, + // OnProcessUnexpectedShutdown will be invoked. + bool mShutdownRequested; + bool mChannelClosed; + +#if defined(XP_LINUX) && defined(MOZ_SANDBOX) + UniquePtr<SandboxBroker> mSandboxBroker; +#endif +}; + +class SocketProcessMemoryReporter : public MemoryReportingProcess { + public: + NS_INLINE_DECL_THREADSAFE_REFCOUNTING(SocketProcessMemoryReporter, override) + + SocketProcessMemoryReporter() = default; + + bool IsAlive() const override; + + bool SendRequestMemoryReport( + const uint32_t& aGeneration, const bool& aAnonymize, + const bool& aMinimizeMemoryUsage, + const Maybe<mozilla::ipc::FileDescriptor>& aDMDFile) override; + + int32_t Pid() const override; + + protected: + virtual ~SocketProcessMemoryReporter() = default; +}; + +} // namespace net +} // namespace mozilla + +#endif // mozilla_net_SocketProcessHost_h |