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. 4 5 #ifndef CONTENT_COMMON_GPU_CLIENT_GPU_CHANNEL_HOST_H_ 6 #define CONTENT_COMMON_GPU_CLIENT_GPU_CHANNEL_HOST_H_ 7 8 #include <string> 9 #include <vector> 10 11 #include "base/atomic_sequence_num.h" 12 #include "base/containers/hash_tables.h" 13 #include "base/memory/ref_counted.h" 14 #include "base/memory/scoped_ptr.h" 15 #include "base/memory/weak_ptr.h" 16 #include "base/process/process.h" 17 #include "base/synchronization/lock.h" 18 #include "content/common/content_export.h" 19 #include "content/common/gpu/gpu_process_launch_causes.h" 20 #include "content/common/gpu/gpu_result_codes.h" 21 #include "content/common/message_router.h" 22 #include "gpu/config/gpu_info.h" 23 #include "ipc/ipc_channel_handle.h" 24 #include "ipc/ipc_sync_channel.h" 25 #include "ipc/message_filter.h" 26 #include "ui/gfx/gpu_memory_buffer.h" 27 #include "ui/gfx/native_widget_types.h" 28 #include "ui/gfx/size.h" 29 #include "ui/gl/gpu_preference.h" 30 31 class GURL; 32 class TransportTextureService; 33 struct GPUCreateCommandBufferConfig; 34 35 namespace base { 36 class MessageLoop; 37 class MessageLoopProxy; 38 class WaitableEvent; 39 } 40 41 namespace IPC { 42 class SyncMessageFilter; 43 } 44 45 namespace media { 46 class VideoDecodeAccelerator; 47 class VideoEncodeAccelerator; 48 } 49 50 namespace content { 51 class CommandBufferProxyImpl; 52 class GpuChannelHost; 53 54 struct GpuListenerInfo { 55 GpuListenerInfo(); 56 ~GpuListenerInfo(); 57 58 base::WeakPtr<IPC::Listener> listener; 59 scoped_refptr<base::MessageLoopProxy> loop; 60 }; 61 62 class CONTENT_EXPORT GpuChannelHostFactory { 63 public: 64 typedef base::Callback<void(const gfx::Size)> CreateImageCallback; 65 ~GpuChannelHostFactory()66 virtual ~GpuChannelHostFactory() {} 67 68 virtual bool IsMainThread() = 0; 69 virtual base::MessageLoop* GetMainLoop() = 0; 70 virtual scoped_refptr<base::MessageLoopProxy> GetIOLoopProxy() = 0; 71 virtual scoped_ptr<base::SharedMemory> AllocateSharedMemory(size_t size) = 0; 72 virtual CreateCommandBufferResult CreateViewCommandBuffer( 73 int32 surface_id, 74 const GPUCreateCommandBufferConfig& init_params, 75 int32 route_id) = 0; 76 virtual void CreateImage( 77 gfx::PluginWindowHandle window, 78 int32 image_id, 79 const CreateImageCallback& callback) = 0; 80 virtual void DeleteImage(int32 image_id, int32 sync_point) = 0; 81 virtual scoped_ptr<gfx::GpuMemoryBuffer> AllocateGpuMemoryBuffer( 82 size_t width, 83 size_t height, 84 unsigned internalformat, 85 unsigned usage) = 0; 86 }; 87 88 // Encapsulates an IPC channel between the client and one GPU process. 89 // On the GPU process side there's a corresponding GpuChannel. 90 // Every method can be called on any thread with a message loop, except for the 91 // IO thread. 92 class GpuChannelHost : public IPC::Sender, 93 public base::RefCountedThreadSafe<GpuChannelHost> { 94 public: 95 // Must be called on the main thread (as defined by the factory). 96 static scoped_refptr<GpuChannelHost> Create( 97 GpuChannelHostFactory* factory, 98 const gpu::GPUInfo& gpu_info, 99 const IPC::ChannelHandle& channel_handle, 100 base::WaitableEvent* shutdown_event); 101 102 // Returns true if |handle| is a valid GpuMemoryBuffer handle that 103 // can be shared to the GPU process. 104 static bool IsValidGpuMemoryBuffer(gfx::GpuMemoryBufferHandle handle); 105 IsLost()106 bool IsLost() const { 107 DCHECK(channel_filter_.get()); 108 return channel_filter_->IsLost(); 109 } 110 111 // The GPU stats reported by the GPU process. gpu_info()112 const gpu::GPUInfo& gpu_info() const { return gpu_info_; } 113 114 // IPC::Sender implementation: 115 virtual bool Send(IPC::Message* msg) OVERRIDE; 116 117 // Create and connect to a command buffer in the GPU process. 118 CommandBufferProxyImpl* CreateViewCommandBuffer( 119 int32 surface_id, 120 CommandBufferProxyImpl* share_group, 121 const std::vector<int32>& attribs, 122 const GURL& active_url, 123 gfx::GpuPreference gpu_preference); 124 125 // Create and connect to a command buffer in the GPU process. 126 CommandBufferProxyImpl* CreateOffscreenCommandBuffer( 127 const gfx::Size& size, 128 CommandBufferProxyImpl* share_group, 129 const std::vector<int32>& attribs, 130 const GURL& active_url, 131 gfx::GpuPreference gpu_preference); 132 133 // Creates a video decoder in the GPU process. 134 scoped_ptr<media::VideoDecodeAccelerator> CreateVideoDecoder( 135 int command_buffer_route_id); 136 137 // Creates a video encoder in the GPU process. 138 scoped_ptr<media::VideoEncodeAccelerator> CreateVideoEncoder( 139 int command_buffer_route_id); 140 141 // Destroy a command buffer created by this channel. 142 void DestroyCommandBuffer(CommandBufferProxyImpl* command_buffer); 143 144 // Add a route for the current message loop. 145 void AddRoute(int route_id, base::WeakPtr<IPC::Listener> listener); 146 void RemoveRoute(int route_id); 147 factory()148 GpuChannelHostFactory* factory() const { return factory_; } 149 150 // Returns a handle to the shared memory that can be sent via IPC to the 151 // GPU process. The caller is responsible for ensuring it is closed. Returns 152 // an invalid handle on failure. 153 base::SharedMemoryHandle ShareToGpuProcess( 154 base::SharedMemoryHandle source_handle); 155 156 // Reserve one unused transfer buffer ID. 157 int32 ReserveTransferBufferId(); 158 159 // Returns a GPU memory buffer handle to the buffer that can be sent via 160 // IPC to the GPU process. The caller is responsible for ensuring it is 161 // closed. Returns an invalid handle on failure. 162 gfx::GpuMemoryBufferHandle ShareGpuMemoryBufferToGpuProcess( 163 gfx::GpuMemoryBufferHandle source_handle); 164 165 // Reserve one unused gpu memory buffer ID. 166 int32 ReserveGpuMemoryBufferId(); 167 168 // Generate a route ID guaranteed to be unique for this channel. 169 int32 GenerateRouteID(); 170 171 private: 172 friend class base::RefCountedThreadSafe<GpuChannelHost>; 173 GpuChannelHost(GpuChannelHostFactory* factory, 174 const gpu::GPUInfo& gpu_info); 175 virtual ~GpuChannelHost(); 176 void Connect(const IPC::ChannelHandle& channel_handle, 177 base::WaitableEvent* shutdown_event); 178 179 // A filter used internally to route incoming messages from the IO thread 180 // to the correct message loop. It also maintains some shared state between 181 // all the contexts. 182 class MessageFilter : public IPC::MessageFilter { 183 public: 184 MessageFilter(); 185 186 // Called on the IO thread. 187 void AddRoute(int route_id, 188 base::WeakPtr<IPC::Listener> listener, 189 scoped_refptr<base::MessageLoopProxy> loop); 190 // Called on the IO thread. 191 void RemoveRoute(int route_id); 192 193 // IPC::MessageFilter implementation 194 // (called on the IO thread): 195 virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE; 196 virtual void OnChannelError() OVERRIDE; 197 198 // The following methods can be called on any thread. 199 200 // Whether the channel is lost. 201 bool IsLost() const; 202 203 private: 204 virtual ~MessageFilter(); 205 206 // Threading notes: |listeners_| is only accessed on the IO thread. Every 207 // other field is protected by |lock_|. 208 typedef base::hash_map<int, GpuListenerInfo> ListenerMap; 209 ListenerMap listeners_; 210 211 // Protects all fields below this one. 212 mutable base::Lock lock_; 213 214 // Whether the channel has been lost. 215 bool lost_; 216 }; 217 218 // Threading notes: all fields are constant during the lifetime of |this| 219 // except: 220 // - |next_transfer_buffer_id_|, atomic type 221 // - |next_gpu_memory_buffer_id_|, atomic type 222 // - |next_route_id_|, atomic type 223 // - |proxies_|, protected by |context_lock_| 224 GpuChannelHostFactory* const factory_; 225 226 const gpu::GPUInfo gpu_info_; 227 228 scoped_ptr<IPC::SyncChannel> channel_; 229 scoped_refptr<MessageFilter> channel_filter_; 230 231 // A filter for sending messages from thread other than the main thread. 232 scoped_refptr<IPC::SyncMessageFilter> sync_filter_; 233 234 // Transfer buffer IDs are allocated in sequence. 235 base::AtomicSequenceNumber next_transfer_buffer_id_; 236 237 // Gpu memory buffer IDs are allocated in sequence. 238 base::AtomicSequenceNumber next_gpu_memory_buffer_id_; 239 240 // Route IDs are allocated in sequence. 241 base::AtomicSequenceNumber next_route_id_; 242 243 // Protects proxies_. 244 mutable base::Lock context_lock_; 245 // Used to look up a proxy from its routing id. 246 typedef base::hash_map<int, CommandBufferProxyImpl*> ProxyMap; 247 ProxyMap proxies_; 248 249 DISALLOW_COPY_AND_ASSIGN(GpuChannelHost); 250 }; 251 252 } // namespace content 253 254 #endif // CONTENT_COMMON_GPU_CLIENT_GPU_CHANNEL_HOST_H_ 255