147 lines
4.3 KiB
C++
147 lines
4.3 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
* vim: sts=8 sw=2 ts=2 tw=99 et :
|
|
* 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 _include_mozilla_gfx_ipc_GPUProcessHost_h_
|
|
#define _include_mozilla_gfx_ipc_GPUProcessHost_h_
|
|
|
|
#include "mozilla/Function.h"
|
|
#include "mozilla/Maybe.h"
|
|
#include "mozilla/UniquePtr.h"
|
|
#include "mozilla/ipc/GeckoChildProcessHost.h"
|
|
#include "mozilla/ipc/ProtocolUtils.h"
|
|
#include "mozilla/ipc/TaskFactory.h"
|
|
|
|
class nsITimer;
|
|
|
|
namespace mozilla {
|
|
namespace gfx {
|
|
|
|
class GPUChild;
|
|
|
|
// GPUProcessHost 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 GPUChild.
|
|
//
|
|
// GPUProcessHosts are allocated and managed by GPUProcessManager. For all
|
|
// intents and purposes it is a singleton, though more than one may be allocated
|
|
// at a time due to its shutdown being asynchronous.
|
|
class GPUProcessHost final : public ipc::GeckoChildProcessHost
|
|
{
|
|
friend class GPUChild;
|
|
|
|
public:
|
|
class Listener {
|
|
public:
|
|
virtual void OnProcessLaunchComplete(GPUProcessHost* aHost)
|
|
{}
|
|
|
|
// The GPUProcessHost has unexpectedly shutdown or had its connection
|
|
// severed. This is not called if an error occurs after calling
|
|
// Shutdown().
|
|
virtual void OnProcessUnexpectedShutdown(GPUProcessHost* aHost)
|
|
{}
|
|
|
|
virtual void OnProcessDeviceReset(GPUProcessHost* aHost)
|
|
{}
|
|
};
|
|
|
|
public:
|
|
explicit GPUProcessHost(Listener* listener);
|
|
~GPUProcessHost();
|
|
|
|
// Launch the subprocess asynchronously. On failure, false is returned.
|
|
// Otherwise, true is returned, and the OnLaunchComplete 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();
|
|
|
|
// If the process is being launched, block until it has launched and
|
|
// connected. If a launch task is pending, it will fire immediately.
|
|
//
|
|
// Returns true if the process is successfully connected; false otherwise.
|
|
bool WaitForLaunch();
|
|
|
|
// Inform the 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 GPUProcessHost.
|
|
//
|
|
// After this returns, the attached Listener is no longer used.
|
|
void Shutdown();
|
|
|
|
// Return the actor for the top-level actor of the process. If the process
|
|
// has not connected yet, this returns null.
|
|
GPUChild* GetActor() const {
|
|
return mGPUChild.get();
|
|
}
|
|
|
|
// Return a unique id for this process, guaranteed not to be shared with any
|
|
// past or future instance of GPUProcessHost.
|
|
uint64_t GetProcessToken() const;
|
|
|
|
bool IsConnected() const {
|
|
return !!mGPUChild;
|
|
}
|
|
|
|
// Return the time stamp for when we tried to launch the GPU process. This is
|
|
// currently used for Telemetry so that we can determine how long GPU processes
|
|
// take to spin up. Note this doesn't denote a successful launch, just when we
|
|
// attempted launch.
|
|
TimeStamp GetLaunchTime() const {
|
|
return mLaunchTime;
|
|
}
|
|
|
|
// Called on the IO thread.
|
|
void OnChannelConnected(int32_t peer_pid) override;
|
|
void OnChannelError() override;
|
|
|
|
void SetListener(Listener* aListener);
|
|
|
|
// Used for tests and diagnostics
|
|
void KillProcess();
|
|
|
|
private:
|
|
// Called on the main thread.
|
|
void OnChannelConnectedTask();
|
|
void OnChannelErrorTask();
|
|
|
|
// Called on the main thread after a connection has been established.
|
|
void InitAfterConnect(bool aSucceeded);
|
|
|
|
// Called on the main thread when the mGPUChild actor is shutting down.
|
|
void OnChannelClosed();
|
|
|
|
// Kill the remote process, triggering IPC shutdown.
|
|
void KillHard(const char* aReason);
|
|
|
|
void DestroyProcess();
|
|
|
|
private:
|
|
DISALLOW_COPY_AND_ASSIGN(GPUProcessHost);
|
|
|
|
Listener* mListener;
|
|
ipc::TaskFactory<GPUProcessHost> mTaskFactory;
|
|
|
|
enum class LaunchPhase {
|
|
Unlaunched,
|
|
Waiting,
|
|
Complete
|
|
};
|
|
LaunchPhase mLaunchPhase;
|
|
|
|
UniquePtr<GPUChild> mGPUChild;
|
|
uint64_t mProcessToken;
|
|
|
|
bool mShutdownRequested;
|
|
bool mChannelClosed;
|
|
|
|
TimeStamp mLaunchTime;
|
|
};
|
|
|
|
} // namespace gfx
|
|
} // namespace mozilla
|
|
|
|
#endif // _include_mozilla_gfx_ipc_GPUProcessHost_h_
|