blob: 105af0e96201319525e919261d61b9085d859648 [file] [log] [blame]
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <stdint.h>
#include <map>
#include <memory>
#include <set>
#include <string>
#include "base/atomicops.h"
#include "base/callback.h"
#include "base/containers/hash_tables.h"
#include "base/containers/queue.h"
#include "base/macros.h"
#include "base/memory/weak_ptr.h"
#include "base/sequence_checker.h"
#include "base/time/time.h"
#include "build/build_config.h"
#include "components/viz/host/gpu_host_impl.h"
#include "content/common/content_export.h"
#include "content/public/browser/browser_child_process_host_delegate.h"
#include "content/public/browser/gpu_data_manager.h"
#include "gpu/command_buffer/common/activity_flags.h"
#include "gpu/command_buffer/common/constants.h"
#include "gpu/config/gpu_feature_info.h"
#include "gpu/config/gpu_info.h"
#include "gpu/config/gpu_mode.h"
#include "gpu/ipc/common/surface_handle.h"
#include "ipc/ipc_sender.h"
#include "mojo/public/cpp/bindings/binding.h"
#include "services/viz/privileged/interfaces/compositing/frame_sink_manager.mojom.h"
#include "services/viz/privileged/interfaces/gl/gpu_host.mojom.h"
#include "services/viz/privileged/interfaces/gl/gpu_service.mojom.h"
#include "services/viz/privileged/interfaces/viz_main.mojom.h"
#include "url/gurl.h"
#if defined(USE_VIZ_DEVTOOLS)
#include "content/browser/gpu/viz_devtools_connector.h"
namespace base {
class Thread;
namespace content {
class BrowserChildProcessHostImpl;
#if defined(OS_MACOSX)
class CATransactionGPUCoordinator;
class GpuProcessHost : public BrowserChildProcessHostDelegate,
public IPC::Sender,
public viz::GpuHostImpl::Delegate {
enum GpuProcessKind {
GPU_PROCESS_KIND_UNSANDBOXED_NO_GL, // Unsandboxed, no init GL bindings.
static int GetGpuCrashCount();
// Creates a new GpuProcessHost (if |force_create| is turned on) or gets an
// existing one, resulting in the launching of a GPU process if required.
// Returns null on failure. It is not safe to store the pointer once control
// has returned to the message loop as it can be destroyed. Instead store the
// associated GPU host ID. This could return NULL if GPU access is not
// allowed (blacklisted).
CONTENT_EXPORT static GpuProcessHost* Get(
bool force_create = true);
// Returns whether there is an active GPU process or not.
static void GetHasGpuProcess(base::OnceCallback<void(bool)> callback);
// Helper function to run a callback on the IO thread. The callback receives
// the appropriate GpuProcessHost instance. Note that the callback can be
// called with a null host (e.g. when |force_create| is false, and no
// GpuProcessHost instance exists).
CONTENT_EXPORT static void CallOnIO(
GpuProcessKind kind,
bool force_create,
const base::Callback<void(GpuProcessHost*)>& callback);
// Get the GPU process host for the GPU process with the given ID. Returns
// null if the process no longer exists.
static GpuProcessHost* FromID(int host_id);
int host_id() const { return host_id_; }
base::ProcessId process_id() const { return process_id_; }
// IPC::Sender implementation.
bool Send(IPC::Message* msg) override;
// What kind of GPU process, e.g. sandboxed or unsandboxed.
GpuProcessKind kind();
// Forcefully terminates the GPU process.
void ForceShutdown();
CONTENT_EXPORT viz::mojom::GpuService* gpu_service();
CONTENT_EXPORT int GetIDForTesting() const;
viz::GpuHostImpl* gpu_host() { return gpu_host_.get(); }
class ConnectionFilterImpl;
enum class GpuTerminationOrigin {
kUnknownOrigin = 0,
kOzoneWaylandProxy = 1,
kMax = 2,
static bool ValidateHost(GpuProcessHost* host);
// Increments |crash_count| by one. Before incrementing |crash_count|, for
// each |forgive_minutes| that has passed since the previous crash remove one
// old crash.
static void IncrementCrashCount(int forgive_minutes, int* crash_count);
GpuProcessHost(int host_id, GpuProcessKind kind);
~GpuProcessHost() override;
bool Init();
// BrowserChildProcessHostDelegate implementation.
bool OnMessageReceived(const IPC::Message& message) override;
void OnChannelConnected(int32_t peer_pid) override;
void OnProcessLaunched() override;
void OnProcessLaunchFailed(int error_code) override;
void OnProcessCrashed(int exit_code) override;
// viz::GpuHostImpl::Delegate:
gpu::GPUInfo GetGPUInfo() const override;
gpu::GpuFeatureInfo GetGpuFeatureInfo() const override;
void DidInitialize(
const gpu::GPUInfo& gpu_info,
const gpu::GpuFeatureInfo& gpu_feature_info,
const base::Optional<gpu::GPUInfo>& gpu_info_for_hardware_gpu,
const base::Optional<gpu::GpuFeatureInfo>&
gpu_feature_info_for_hardware_gpu) override;
void DidFailInitialize() override;
void DidCreateContextSuccessfully() override;
void BlockDomainFrom3DAPIs(const GURL& url, gpu::DomainGuilt guilt) override;
void DisableGpuCompositing() override;
bool GpuAccessAllowed() const override;
gpu::ShaderCacheFactory* GetShaderCacheFactory() override;
void RecordLogMessage(int32_t severity,
const std::string& header,
const std::string& message) override;
void BindDiscardableMemoryRequest(
discardable_memory::mojom::DiscardableSharedMemoryManagerRequest request)
void BindInterface(const std::string& interface_name,
mojo::ScopedMessagePipeHandle interface_pipe) override;
#if defined(USE_OZONE)
void TerminateGpuProcess(const std::string& message) override;
void SendGpuProcessMessage(IPC::Message* message) override;
// Message handlers.
void OnFieldTrialActivated(const std::string& trial_name);
bool LaunchGpuProcess();
void SendOutstandingReplies();
void BlockLiveOffscreenContexts();
// Update GPU crash counters. Disable GPU if crash limit is reached.
void RecordProcessCrash();
// The serial number of the GpuProcessHost / GpuProcessHostUIShim pair.
int host_id_;
// GPU process id in case GPU is not in-process.
base::ProcessId process_id_ = base::kNullProcessId;
// Qeueud messages to send when the process launches.
base::queue<IPC::Message*> queued_messages_;
// Whether the GPU process is valid, set to false after Send() failed.
bool valid_;
// Whether we are running a GPU thread inside the browser process instead
// of a separate GPU process.
bool in_process_;
GpuProcessKind kind_;
gpu::GpuMode mode_ = gpu::GpuMode::UNKNOWN;
// Whether we actually launched a GPU process.
bool process_launched_;
GpuTerminationOrigin termination_origin_ =
// Time Init started. Used to log total GPU process startup time to UMA.
base::TimeTicks init_start_time_;
int connection_filter_id_;
// The GPU process reported failure to initialize.
bool did_fail_initialize_ = false;
// The total number of GPU process crashes.
static base::subtle::Atomic32 gpu_crash_count_;
static bool crashed_before_;
static int hardware_accelerated_recent_crash_count_;
static int swiftshader_recent_crash_count_;
static int display_compositor_recent_crash_count_;
// Here the bottom-up destruction order matters:
// The GPU thread depends on its host so stop the host last.
// Otherwise, under rare timings when the thread is still in Init(),
// it could crash as it fails to find a message pipe to the host.
std::unique_ptr<BrowserChildProcessHostImpl> process_;
std::unique_ptr<base::Thread> in_process_gpu_thread_;
#if defined(OS_MACOSX)
scoped_refptr<CATransactionGPUCoordinator> ca_transaction_gpu_coordinator_;
// Track the URLs of the pages which have live offscreen contexts,
// assumed to be associated with untrusted content such as WebGL.
// For best robustness, when any context lost notification is
// received, assume all of these URLs are guilty, and block
// automatic execution of 3D content from those domains.
std::multiset<GURL> urls_with_live_offscreen_contexts_;
std::unique_ptr<viz::GpuHostImpl> gpu_host_;
#if defined(USE_VIZ_DEVTOOLS)
std::unique_ptr<VizDevToolsConnector> devtools_connector_;
base::WeakPtrFactory<GpuProcessHost> weak_ptr_factory_;
} // namespace content