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_sender.h"
27 #include "ipc/message_filter.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;
38 struct GpuMemoryBufferHandle;
46 class BrowserChildProcessHostImpl;
48 class RenderWidgetHostViewFrameSubscriber;
49 class ShaderDiskCache;
51 typedef base::Thread* (*GpuMainThreadFactoryFunction)(const std::string& id);
53 class GpuProcessHost : public BrowserChildProcessHostDelegate,
55 public base::NonThreadSafe {
58 GPU_PROCESS_KIND_UNSANDBOXED,
59 GPU_PROCESS_KIND_SANDBOXED,
60 GPU_PROCESS_KIND_COUNT
63 typedef base::Callback<void(const IPC::ChannelHandle&, const gpu::GPUInfo&)>
64 EstablishChannelCallback;
66 typedef base::Callback<void(bool)> CreateCommandBufferCallback;
68 typedef base::Callback<void(const gfx::Size)> CreateImageCallback;
70 typedef base::Callback<void(const gfx::GpuMemoryBufferHandle& handle)>
71 CreateGpuMemoryBufferCallback;
73 static bool gpu_enabled() { return gpu_enabled_; }
75 // Creates a new GpuProcessHost or gets an existing one, resulting in the
76 // launching of a GPU process if required. Returns null on failure. It
77 // is not safe to store the pointer once control has returned to the message
78 // loop as it can be destroyed. Instead store the associated GPU host ID.
79 // This could return NULL if GPU access is not allowed (blacklisted).
80 CONTENT_EXPORT static GpuProcessHost* Get(GpuProcessKind kind,
81 CauseForGpuLaunch cause);
83 // Retrieves a list of process handles for all gpu processes.
84 static void GetProcessHandles(
85 const GpuDataManager::GetGpuProcessHandlesCallback& callback);
87 // Helper function to send the given message to the GPU process on the IO
88 // thread. Calls Get and if a host is returned, sends it. Can be called from
89 // any thread. Deletes the message if it cannot be sent.
90 CONTENT_EXPORT static void SendOnIO(GpuProcessKind kind,
91 CauseForGpuLaunch cause,
92 IPC::Message* message);
94 CONTENT_EXPORT static void RegisterGpuMainThreadFactory(
95 GpuMainThreadFactoryFunction create);
97 // Get the GPU process host for the GPU process with the given ID. Returns
98 // null if the process no longer exists.
99 static GpuProcessHost* FromID(int host_id);
100 int host_id() const { return host_id_; }
102 // IPC::Sender implementation.
103 virtual bool Send(IPC::Message* msg) OVERRIDE;
105 // Adds a message filter to the GpuProcessHost's channel.
106 void AddFilter(IPC::MessageFilter* filter);
108 // Tells the GPU process to create a new channel for communication with a
109 // client. Once the GPU process responds asynchronously with the IPC handle
110 // and GPUInfo, we call the callback.
111 void EstablishGpuChannel(int client_id,
113 const EstablishChannelCallback& callback);
115 // Tells the GPU process to create a new command buffer that draws into the
117 void CreateViewCommandBuffer(
118 const gfx::GLSurfaceHandle& compositing_surface,
121 const GPUCreateCommandBufferConfig& init_params,
123 const CreateCommandBufferCallback& callback);
125 // Tells the GPU process to create a new image using the given window.
127 gfx::PluginWindowHandle window,
130 const CreateImageCallback& callback);
132 // Tells the GPU process to delete image.
133 void DeleteImage(int client_id, int image_id, int sync_point);
135 void CreateGpuMemoryBuffer(const gfx::GpuMemoryBufferHandle& handle,
136 const gfx::Size& size,
137 unsigned internalformat,
139 const CreateGpuMemoryBufferCallback& callback);
140 void DestroyGpuMemoryBuffer(const gfx::GpuMemoryBufferHandle& handle,
143 // What kind of GPU process, e.g. sandboxed or unsandboxed.
144 GpuProcessKind kind();
146 void ForceShutdown();
148 void BeginFrameSubscription(
150 base::WeakPtr<RenderWidgetHostViewFrameSubscriber> subscriber);
151 void EndFrameSubscription(int surface_id);
152 void LoadedShader(const std::string& key, const std::string& data);
155 static bool ValidateHost(GpuProcessHost* host);
157 GpuProcessHost(int host_id, GpuProcessKind kind);
158 virtual ~GpuProcessHost();
162 // Post an IPC message to the UI shim's message handler on the UI thread.
163 void RouteOnUIThread(const IPC::Message& message);
165 // BrowserChildProcessHostDelegate implementation.
166 virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
167 virtual void OnChannelConnected(int32 peer_pid) OVERRIDE;
168 virtual void OnProcessLaunched() OVERRIDE;
169 virtual void OnProcessCrashed(int exit_code) OVERRIDE;
172 void OnInitialized(bool result, const gpu::GPUInfo& gpu_info);
173 void OnChannelEstablished(const IPC::ChannelHandle& channel_handle);
174 void OnCommandBufferCreated(bool succeeded);
175 void OnDestroyCommandBuffer(int32 surface_id);
176 void OnImageCreated(const gfx::Size size);
177 void OnGpuMemoryBufferCreated(const gfx::GpuMemoryBufferHandle& handle);
178 void OnDidCreateOffscreenContext(const GURL& url);
179 void OnDidLoseContext(bool offscreen,
180 gpu::error::ContextLostReason reason,
182 void OnDidDestroyOffscreenContext(const GURL& url);
183 void OnGpuMemoryUmaStatsReceived(const GPUMemoryUmaStats& stats);
184 #if defined(OS_MACOSX)
185 void OnAcceleratedSurfaceBuffersSwapped(
186 const GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params& params);
189 void CreateChannelCache(int32 client_id);
190 void OnDestroyChannel(int32 client_id);
191 void OnCacheShader(int32 client_id, const std::string& key,
192 const std::string& shader);
194 bool LaunchGpuProcess(const std::string& channel_id);
196 void SendOutstandingReplies();
198 void BlockLiveOffscreenContexts();
200 std::string GetShaderPrefixKey();
202 // The serial number of the GpuProcessHost / GpuProcessHostUIShim pair.
205 // These are the channel requests that we have already sent to
206 // the GPU process, but haven't heard back about yet.
207 std::queue<EstablishChannelCallback> channel_requests_;
209 // The pending create command buffer requests we need to reply to.
210 std::queue<CreateCommandBufferCallback> create_command_buffer_requests_;
212 // The pending create image requests we need to reply to.
213 std::queue<CreateImageCallback> create_image_requests_;
215 // The pending create gpu memory buffer requests we need to reply to.
216 std::queue<CreateGpuMemoryBufferCallback> create_gpu_memory_buffer_requests_;
218 // Qeueud messages to send when the process launches.
219 std::queue<IPC::Message*> queued_messages_;
221 // Whether the GPU process is valid, set to false after Send() failed.
224 // Whether we are running a GPU thread inside the browser process instead
225 // of a separate GPU process.
228 bool swiftshader_rendering_;
229 GpuProcessKind kind_;
231 scoped_ptr<base::Thread> in_process_gpu_thread_;
233 // Whether we actually launched a GPU process.
234 bool process_launched_;
236 // Whether the GPU process successfully initialized.
239 // Time Init started. Used to log total GPU process startup time to UMA.
240 base::TimeTicks init_start_time_;
242 // Master switch for enabling/disabling GPU acceleration for the current
243 // browser session. It does not change the acceleration settings for
244 // existing tabs, just the future ones.
245 static bool gpu_enabled_;
247 static bool hardware_gpu_enabled_;
249 scoped_ptr<BrowserChildProcessHostImpl> process_;
251 // Track the URLs of the pages which have live offscreen contexts,
252 // assumed to be associated with untrusted content such as WebGL.
253 // For best robustness, when any context lost notification is
254 // received, assume all of these URLs are guilty, and block
255 // automatic execution of 3D content from those domains.
256 std::multiset<GURL> urls_with_live_offscreen_contexts_;
258 // Statics kept around to send to UMA histograms on GPU process lost.
259 bool uma_memory_stats_received_;
260 GPUMemoryUmaStats uma_memory_stats_;
262 // This map of frame subscribers are listening for frame presentation events.
263 // The key is the surface id and value is the subscriber.
264 typedef base::hash_map<int,
265 base::WeakPtr<RenderWidgetHostViewFrameSubscriber> >
267 FrameSubscriberMap frame_subscribers_;
269 typedef std::map<int32, scoped_refptr<ShaderDiskCache> >
270 ClientIdToShaderCacheMap;
271 ClientIdToShaderCacheMap client_id_to_shader_cache_;
273 std::string shader_prefix_key_;
275 // Keep an extra reference to the SurfaceRef stored in the GpuSurfaceTracker
276 // in this map so that we don't destroy it whilst the GPU process is
278 typedef std::multimap<int, scoped_refptr<GpuSurfaceTracker::SurfaceRef> >
280 SurfaceRefMap surface_refs_;
282 DISALLOW_COPY_AND_ASSIGN(GpuProcessHost);
285 } // namespace content
287 #endif // CONTENT_BROWSER_GPU_GPU_PROCESS_HOST_H_