1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #ifndef CONTENT_BROWSER_GPU_GPU_PROCESS_HOST_H_
6 #define CONTENT_BROWSER_GPU_GPU_PROCESS_HOST_H_
13 #include "base/callback.h"
14 #include "base/containers/hash_tables.h"
15 #include "base/memory/weak_ptr.h"
16 #include "base/threading/non_thread_safe.h"
17 #include "base/time/time.h"
18 #include "content/browser/gpu/gpu_surface_tracker.h"
19 #include "content/common/content_export.h"
20 #include "content/common/gpu/gpu_memory_uma_stats.h"
21 #include "content/common/gpu/gpu_process_launch_causes.h"
22 #include "content/public/browser/browser_child_process_host_delegate.h"
23 #include "content/public/browser/gpu_data_manager.h"
24 #include "gpu/command_buffer/common/constants.h"
25 #include "gpu/config/gpu_info.h"
26 #include "ipc/ipc_channel_proxy.h"
27 #include "ipc/ipc_sender.h"
28 #include "ui/gfx/native_widget_types.h"
29 #include "ui/gfx/size.h"
32 struct GPUCreateCommandBufferConfig;
33 struct GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params;
34 struct GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params;
35 struct GpuHostMsg_AcceleratedSurfaceRelease_Params;
42 class BrowserChildProcessHostImpl;
44 class RenderWidgetHostViewFrameSubscriber;
45 class ShaderDiskCache;
47 typedef base::Thread* (*GpuMainThreadFactoryFunction)(const std::string& id);
49 class GpuProcessHost : public BrowserChildProcessHostDelegate,
51 public base::NonThreadSafe {
54 GPU_PROCESS_KIND_UNSANDBOXED,
55 GPU_PROCESS_KIND_SANDBOXED,
56 GPU_PROCESS_KIND_COUNT
59 typedef base::Callback<void(const IPC::ChannelHandle&, const gpu::GPUInfo&)>
60 EstablishChannelCallback;
62 typedef base::Callback<void(int32)> CreateCommandBufferCallback;
64 typedef base::Callback<void(const gfx::Size)> CreateImageCallback;
66 static bool gpu_enabled() { return gpu_enabled_; }
68 // Creates a new GpuProcessHost or gets an existing one, resulting in the
69 // launching of a GPU process if required. Returns null on failure. It
70 // is not safe to store the pointer once control has returned to the message
71 // loop as it can be destroyed. Instead store the associated GPU host ID.
72 // This could return NULL if GPU access is not allowed (blacklisted).
73 CONTENT_EXPORT static GpuProcessHost* Get(GpuProcessKind kind,
74 CauseForGpuLaunch cause);
76 // Retrieves a list of process handles for all gpu processes.
77 static void GetProcessHandles(
78 const GpuDataManager::GetGpuProcessHandlesCallback& callback);
80 // Helper function to send the given message to the GPU process on the IO
81 // thread. Calls Get and if a host is returned, sends it. Can be called from
82 // any thread. Deletes the message if it cannot be sent.
83 CONTENT_EXPORT static void SendOnIO(GpuProcessKind kind,
84 CauseForGpuLaunch cause,
85 IPC::Message* message);
87 CONTENT_EXPORT static void RegisterGpuMainThreadFactory(
88 GpuMainThreadFactoryFunction create);
90 // Get the GPU process host for the GPU process with the given ID. Returns
91 // null if the process no longer exists.
92 static GpuProcessHost* FromID(int host_id);
93 int host_id() const { return host_id_; }
95 // IPC::Sender implementation.
96 virtual bool Send(IPC::Message* msg) OVERRIDE;
98 // Adds a message filter to the GpuProcessHost's channel.
99 CONTENT_EXPORT void AddFilter(IPC::ChannelProxy::MessageFilter* filter);
101 // Tells the GPU process to create a new channel for communication with a
102 // client. Once the GPU process responds asynchronously with the IPC handle
103 // and GPUInfo, we call the callback.
104 void EstablishGpuChannel(int client_id,
106 const EstablishChannelCallback& callback);
108 // Tells the GPU process to create a new command buffer that draws into the
110 void CreateViewCommandBuffer(
111 const gfx::GLSurfaceHandle& compositing_surface,
114 const GPUCreateCommandBufferConfig& init_params,
115 const CreateCommandBufferCallback& callback);
117 // Tells the GPU process to create a new image using the given window.
119 gfx::PluginWindowHandle window,
122 const CreateImageCallback& callback);
124 // Tells the GPU process to delete image.
125 void DeleteImage(int client_id, int image_id, int sync_point);
127 // What kind of GPU process, e.g. sandboxed or unsandboxed.
128 GpuProcessKind kind();
130 void ForceShutdown();
132 void BeginFrameSubscription(
134 base::WeakPtr<RenderWidgetHostViewFrameSubscriber> subscriber);
135 void EndFrameSubscription(int surface_id);
136 void LoadedShader(const std::string& key, const std::string& data);
139 static bool ValidateHost(GpuProcessHost* host);
141 GpuProcessHost(int host_id, GpuProcessKind kind);
142 virtual ~GpuProcessHost();
146 // Post an IPC message to the UI shim's message handler on the UI thread.
147 void RouteOnUIThread(const IPC::Message& message);
149 // BrowserChildProcessHostDelegate implementation.
150 virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
151 virtual void OnChannelConnected(int32 peer_pid) OVERRIDE;
152 virtual void OnProcessLaunched() OVERRIDE;
153 virtual void OnProcessCrashed(int exit_code) OVERRIDE;
156 void OnInitialized(bool result, const gpu::GPUInfo& gpu_info);
157 void OnChannelEstablished(const IPC::ChannelHandle& channel_handle);
158 void OnCommandBufferCreated(const int32 route_id);
159 void OnDestroyCommandBuffer(int32 surface_id);
160 void OnImageCreated(const gfx::Size size);
161 void OnDidCreateOffscreenContext(const GURL& url);
162 void OnDidLoseContext(bool offscreen,
163 gpu::error::ContextLostReason reason,
165 void OnDidDestroyOffscreenContext(const GURL& url);
166 void OnGpuMemoryUmaStatsReceived(const GPUMemoryUmaStats& stats);
167 #if defined(OS_MACOSX)
168 void OnAcceleratedSurfaceBuffersSwapped(
169 const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params);
171 // Note: Different implementations depending on USE_AURA.
173 void OnAcceleratedSurfaceBuffersSwapped(
174 const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params);
175 void OnAcceleratedSurfacePostSubBuffer(
176 const GpuHostMsg_AcceleratedSurfacePostSubBuffer_Params& params);
177 void OnAcceleratedSurfaceSuspend(int32 surface_id);
178 void OnAcceleratedSurfaceRelease(
179 const GpuHostMsg_AcceleratedSurfaceRelease_Params& params);
182 void CreateChannelCache(int32 client_id);
183 void OnDestroyChannel(int32 client_id);
184 void OnCacheShader(int32 client_id, const std::string& key,
185 const std::string& shader);
187 bool LaunchGpuProcess(const std::string& channel_id);
189 void SendOutstandingReplies();
191 void BlockLiveOffscreenContexts();
193 std::string GetShaderPrefixKey();
195 // The serial number of the GpuProcessHost / GpuProcessHostUIShim pair.
198 // These are the channel requests that we have already sent to
199 // the GPU process, but haven't heard back about yet.
200 std::queue<EstablishChannelCallback> channel_requests_;
202 // The pending create command buffer requests we need to reply to.
203 std::queue<CreateCommandBufferCallback> create_command_buffer_requests_;
205 // The pending create image requests we need to reply to.
206 std::queue<CreateImageCallback> create_image_requests_;
209 // Qeueud messages to send when the process launches.
210 std::queue<IPC::Message*> queued_messages_;
212 // Whether the GPU process is valid, set to false after Send() failed.
215 // Whether we are running a GPU thread inside the browser process instead
216 // of a separate GPU process.
219 bool swiftshader_rendering_;
220 GpuProcessKind kind_;
222 scoped_ptr<base::Thread> in_process_gpu_thread_;
224 // Whether we actually launched a GPU process.
225 bool process_launched_;
227 // Whether the GPU process successfully initialized.
230 // Time Init started. Used to log total GPU process startup time to UMA.
231 base::TimeTicks init_start_time_;
233 // Master switch for enabling/disabling GPU acceleration for the current
234 // browser session. It does not change the acceleration settings for
235 // existing tabs, just the future ones.
236 static bool gpu_enabled_;
238 static bool hardware_gpu_enabled_;
240 scoped_ptr<BrowserChildProcessHostImpl> process_;
242 // Track the URLs of the pages which have live offscreen contexts,
243 // assumed to be associated with untrusted content such as WebGL.
244 // For best robustness, when any context lost notification is
245 // received, assume all of these URLs are guilty, and block
246 // automatic execution of 3D content from those domains.
247 std::multiset<GURL> urls_with_live_offscreen_contexts_;
249 // Statics kept around to send to UMA histograms on GPU process lost.
250 bool uma_memory_stats_received_;
251 GPUMemoryUmaStats uma_memory_stats_;
253 // This map of frame subscribers are listening for frame presentation events.
254 // The key is the surface id and value is the subscriber.
255 typedef base::hash_map<int,
256 base::WeakPtr<RenderWidgetHostViewFrameSubscriber> >
258 FrameSubscriberMap frame_subscribers_;
260 typedef std::map<int32, scoped_refptr<ShaderDiskCache> >
261 ClientIdToShaderCacheMap;
262 ClientIdToShaderCacheMap client_id_to_shader_cache_;
264 std::string shader_prefix_key_;
266 // Keep an extra reference to the SurfaceRef stored in the GpuSurfaceTracker
267 // in this map so that we don't destroy it whilst the GPU process is
269 typedef std::multimap<int, scoped_refptr<GpuSurfaceTracker::SurfaceRef> >
271 SurfaceRefMap surface_refs_;
273 DISALLOW_COPY_AND_ASSIGN(GpuProcessHost);
276 } // namespace content
278 #endif // CONTENT_BROWSER_GPU_GPU_PROCESS_HOST_H_