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