in_process_command_buffer.h revision 1e9bf3e0803691d0a228da41fc608347b6db4340 
1// Copyright 2013 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 GPU_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_
6#define GPU_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_
7
8#include <vector>
9
10#include "base/callback.h"
11#include "base/compiler_specific.h"
12#include "base/memory/ref_counted.h"
13#include "base/memory/scoped_ptr.h"
14#include "base/memory/weak_ptr.h"
15#include "base/synchronization/lock.h"
16#include "base/synchronization/waitable_event.h"
17#include "gpu/command_buffer/common/command_buffer.h"
18#include "gpu/command_buffer/common/gpu_control.h"
19#include "gpu/gpu_export.h"
20#include "ui/gfx/gpu_memory_buffer.h"
21#include "ui/gfx/native_widget_types.h"
22#include "ui/gl/gl_surface.h"
23#include "ui/gl/gpu_preference.h"
24
25namespace base {
26class SequenceChecker;
27}
28
29namespace gfx {
30class GLContext;
31class GLSurface;
32class Size;
33}
34
35#if defined(OS_ANDROID)
36namespace gfx {
37class SurfaceTexture;
38}
39namespace gpu {
40class StreamTextureManagerInProcess;
41}
42#endif
43
44namespace gpu {
45
46namespace gles2 {
47class GLES2Decoder;
48}
49
50class GpuMemoryBufferFactory;
51class GpuScheduler;
52class TransferBufferManagerInterface;
53
54// This class provides a thread-safe interface to the global GPU service (for
55// example GPU thread) when being run in single process mode.
56// However, the behavior for accessing one context (i.e. one instance of this
57// class) from different client threads is undefined.
58class GPU_EXPORT InProcessCommandBuffer : public CommandBuffer,
59                                          public GpuControl {
60 public:
61  InProcessCommandBuffer();
62  virtual ~InProcessCommandBuffer();
63
64  // Used to override the GPU thread with explicit scheduling.
65  // (By default an internal GPU thread will be spawned to handle all GL work
66  // and the two functions are unused.)
67  // The callback will be called from different client threads. After the
68  // callback is issued, the client is expected to eventually call
69  // ProcessGpuWorkOnCurrentThread(). The latter cannot be called from different
70  // threads.
71  // The callback needs to be set before any context is created.
72  static void SetScheduleCallback(const base::Closure& callback);
73  static void ProcessGpuWorkOnCurrentThread();
74
75  static void EnableVirtualizedContext();
76  static void SetGpuMemoryBufferFactory(GpuMemoryBufferFactory* factory);
77
78  // If |surface| is not NULL, use it directly; in this case, the command
79  // buffer gpu thread must be the same as the client thread. Otherwise create
80  // a new GLSurface.
81  bool Initialize(scoped_refptr<gfx::GLSurface> surface,
82                  bool is_offscreen,
83                  bool share_resources,
84                  gfx::AcceleratedWidget window,
85                  const gfx::Size& size,
86                  const std::vector<int32>& attribs,
87                  gfx::GpuPreference gpu_preference,
88                  const base::Closure& context_lost_callback,
89                  unsigned int share_group_id);
90  void Destroy();
91
92  // CommandBuffer implementation:
93  virtual bool Initialize() OVERRIDE;
94  virtual State GetState() OVERRIDE;
95  virtual State GetLastState() OVERRIDE;
96  virtual int32 GetLastToken() OVERRIDE;
97  virtual void Flush(int32 put_offset) OVERRIDE;
98  virtual State FlushSync(int32 put_offset, int32 last_known_get) OVERRIDE;
99  virtual void SetGetBuffer(int32 shm_id) OVERRIDE;
100  virtual void SetGetOffset(int32 get_offset) OVERRIDE;
101  virtual gpu::Buffer CreateTransferBuffer(size_t size, int32* id) OVERRIDE;
102  virtual void DestroyTransferBuffer(int32 id) OVERRIDE;
103  virtual gpu::Buffer GetTransferBuffer(int32 id) OVERRIDE;
104  virtual void SetToken(int32 token) OVERRIDE;
105  virtual void SetParseError(gpu::error::Error error) OVERRIDE;
106  virtual void SetContextLostReason(
107      gpu::error::ContextLostReason reason) OVERRIDE;
108  virtual gpu::error::Error GetLastError() OVERRIDE;
109
110  // GpuControl implementation:
111  virtual bool SupportsGpuMemoryBuffer() OVERRIDE;
112  virtual gfx::GpuMemoryBuffer* CreateGpuMemoryBuffer(
113      size_t width,
114      size_t height,
115      unsigned internalformat,
116      int32* id) OVERRIDE;
117  virtual void DestroyGpuMemoryBuffer(int32 id) OVERRIDE;
118  virtual bool GenerateMailboxNames(unsigned num,
119                                    std::vector<gpu::Mailbox>* names) OVERRIDE;
120  virtual uint32 InsertSyncPoint() OVERRIDE;
121  virtual void SignalSyncPoint(uint32 sync_point,
122                               const base::Closure& callback) OVERRIDE;
123  virtual void SignalQuery(uint32 query,
124                           const base::Closure& callback) OVERRIDE;
125  virtual void SendManagedMemoryStats(const gpu::ManagedMemoryStats& stats)
126      OVERRIDE;
127
128  // The serializer interface to the GPU service (i.e. thread).
129  class SchedulerClient {
130   public:
131     virtual ~SchedulerClient() {}
132
133     // Queues a task to run as soon as possible.
134     virtual void QueueTask(const base::Closure& task) = 0;
135
136     // Schedules |callback| to run at an appropriate time for performing idle
137     // work.
138     virtual void ScheduleIdleWork(const base::Closure& task) = 0;
139  };
140
141#if defined(OS_ANDROID)
142  scoped_refptr<gfx::SurfaceTexture> GetSurfaceTexture(
143      uint32 stream_id);
144#endif
145
146 private:
147  bool InitializeOnGpuThread(bool is_offscreen,
148                             gfx::AcceleratedWidget window,
149                             const gfx::Size& size,
150                             const std::vector<int32>& attribs,
151                             gfx::GpuPreference gpu_preference);
152  bool DestroyOnGpuThread();
153  void FlushOnGpuThread(int32 put_offset);
154  bool MakeCurrent();
155  bool IsContextLost();
156  base::Closure WrapCallback(const base::Closure& callback);
157  State GetStateFast();
158  void QueueTask(const base::Closure& task) { queue_->QueueTask(task); }
159  void CheckSequencedThread();
160
161  // Callbacks:
162  void OnContextLost();
163  void OnResizeView(gfx::Size size, float scale_factor);
164  bool GetBufferChanged(int32 transfer_buffer_id);
165  void PumpCommands();
166  void ScheduleMoreIdleWork();
167
168  // Members accessed on the gpu thread (possibly with the exception of
169  // creation):
170  bool context_lost_;
171  bool share_resources_;
172  scoped_ptr<TransferBufferManagerInterface> transfer_buffer_manager_;
173  scoped_ptr<GpuScheduler> gpu_scheduler_;
174  scoped_ptr<gles2::GLES2Decoder> decoder_;
175  scoped_refptr<gfx::GLContext> context_;
176  scoped_refptr<gfx::GLSurface> surface_;
177  base::Closure context_lost_callback_;
178  unsigned int share_group_id_;
179
180  // Members accessed on the client thread:
181  State last_state_;
182  int32 last_put_offset_;
183  bool supports_gpu_memory_buffer_;
184
185  // Accessed on both threads:
186  scoped_ptr<CommandBuffer> command_buffer_;
187  base::Lock command_buffer_lock_;
188  base::WaitableEvent flush_event_;
189  scoped_ptr<SchedulerClient> queue_;
190  State state_after_last_flush_;
191  base::Lock state_after_last_flush_lock_;
192  scoped_ptr<GpuControl> gpu_control_;
193
194#if defined(OS_ANDROID)
195  scoped_refptr<StreamTextureManagerInProcess> stream_texture_manager_;
196#endif
197
198  // Only used with explicit scheduling and the gpu thread is the same as
199  // the client thread.
200  scoped_ptr<base::SequenceChecker> sequence_checker_;
201
202  base::WeakPtr<InProcessCommandBuffer> gpu_thread_weak_ptr_;
203  base::WeakPtrFactory<InProcessCommandBuffer> gpu_thread_weak_ptr_factory_;
204
205  DISALLOW_COPY_AND_ASSIGN(InProcessCommandBuffer);
206};
207
208}  // namespace gpu
209
210#endif  // GPU_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_
211