summaryrefslogtreecommitdiffstats
path: root/gfx/ipc/GPUProcessHost.h
diff options
context:
space:
mode:
Diffstat (limited to 'gfx/ipc/GPUProcessHost.h')
-rw-r--r--gfx/ipc/GPUProcessHost.h146
1 files changed, 146 insertions, 0 deletions
diff --git a/gfx/ipc/GPUProcessHost.h b/gfx/ipc/GPUProcessHost.h
new file mode 100644
index 000000000..d5c19f35d
--- /dev/null
+++ b/gfx/ipc/GPUProcessHost.h
@@ -0,0 +1,146 @@
+/* -*- 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_