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