forked from mirrors/gecko-dev
4a72a442c0
Now that we've simplified the startup process somewhat, it is easier to clean up IPC channel creation for NodeChannel connections. This stops having GeckoChildProcessHost inherit from IPC::Channel::Listener, as it would never receive most of the relevant callbacks, and instead implements the one callback it would receive directly as a method on that type. Differential Revision: https://phabricator.services.mozilla.com/D181282
150 lines
4.6 KiB
C++
150 lines
4.6 KiB
C++
/* -*- 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
|