• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 <map>
9 #include <vector>
10 
11 #include "base/callback.h"
12 #include "base/compiler_specific.h"
13 #include "base/containers/scoped_ptr_hash_map.h"
14 #include "base/memory/ref_counted.h"
15 #include "base/memory/scoped_ptr.h"
16 #include "base/memory/weak_ptr.h"
17 #include "base/synchronization/lock.h"
18 #include "base/synchronization/waitable_event.h"
19 #include "gpu/command_buffer/client/gpu_control.h"
20 #include "gpu/command_buffer/common/command_buffer.h"
21 #include "gpu/gpu_export.h"
22 #include "ui/gfx/gpu_memory_buffer.h"
23 #include "ui/gfx/native_widget_types.h"
24 #include "ui/gl/gl_surface.h"
25 #include "ui/gl/gpu_preference.h"
26 
27 namespace base {
28 class SequenceChecker;
29 }
30 
31 namespace gfx {
32 class GLContext;
33 class GLShareGroup;
34 class GLSurface;
35 class Size;
36 }
37 
38 #if defined(OS_ANDROID)
39 namespace gfx {
40 class SurfaceTexture;
41 }
42 namespace gpu {
43 class StreamTextureManagerInProcess;
44 }
45 #endif
46 
47 namespace gpu {
48 
49 namespace gles2 {
50 class GLES2Decoder;
51 class MailboxManager;
52 class ShaderTranslatorCache;
53 }
54 
55 class CommandBufferServiceBase;
56 class GpuScheduler;
57 class TransferBufferManagerInterface;
58 
59 // TODO(reveman): Remove this interface when InProcessCommandBuffer doesn't need
60 // a custom factory interface and android_webview implementation of GPU memory
61 // buffers can use the same mechanism for buffer allocation as what's used for
62 // out of process GPU service.
63 class GPU_EXPORT InProcessGpuMemoryBufferFactory {
64  public:
65   virtual scoped_ptr<gfx::GpuMemoryBuffer> AllocateGpuMemoryBuffer(
66       size_t width,
67       size_t height,
68       unsigned internalformat,
69       unsigned usage) = 0;
70   virtual scoped_refptr<gfx::GLImage> CreateImageForGpuMemoryBuffer(
71       const gfx::GpuMemoryBufferHandle& handle,
72       const gfx::Size& size,
73       unsigned internalformat) = 0;
74 
75  protected:
~InProcessGpuMemoryBufferFactory()76   virtual ~InProcessGpuMemoryBufferFactory() {}
77 };
78 
79 // This class provides a thread-safe interface to the global GPU service (for
80 // example GPU thread) when being run in single process mode.
81 // However, the behavior for accessing one context (i.e. one instance of this
82 // class) from different client threads is undefined.
83 class GPU_EXPORT InProcessCommandBuffer : public CommandBuffer,
84                                           public GpuControl {
85  public:
86   class Service;
87   explicit InProcessCommandBuffer(const scoped_refptr<Service>& service);
88   virtual ~InProcessCommandBuffer();
89 
90   static void SetGpuMemoryBufferFactory(
91       InProcessGpuMemoryBufferFactory* factory);
92 
93   // If |surface| is not NULL, use it directly; in this case, the command
94   // buffer gpu thread must be the same as the client thread. Otherwise create
95   // a new GLSurface.
96   bool Initialize(scoped_refptr<gfx::GLSurface> surface,
97                   bool is_offscreen,
98                   gfx::AcceleratedWidget window,
99                   const gfx::Size& size,
100                   const std::vector<int32>& attribs,
101                   gfx::GpuPreference gpu_preference,
102                   const base::Closure& context_lost_callback,
103                   InProcessCommandBuffer* share_group);
104   void Destroy();
105 
106   // CommandBuffer implementation:
107   virtual bool Initialize() OVERRIDE;
108   virtual State GetLastState() OVERRIDE;
109   virtual int32 GetLastToken() OVERRIDE;
110   virtual void Flush(int32 put_offset) OVERRIDE;
111   virtual void WaitForTokenInRange(int32 start, int32 end) OVERRIDE;
112   virtual void WaitForGetOffsetInRange(int32 start, int32 end) OVERRIDE;
113   virtual void SetGetBuffer(int32 shm_id) OVERRIDE;
114   virtual scoped_refptr<gpu::Buffer> CreateTransferBuffer(size_t size,
115                                                           int32* id) OVERRIDE;
116   virtual void DestroyTransferBuffer(int32 id) OVERRIDE;
117   virtual gpu::error::Error GetLastError() OVERRIDE;
118 
119   // GpuControl implementation:
120   virtual gpu::Capabilities GetCapabilities() OVERRIDE;
121   virtual gfx::GpuMemoryBuffer* CreateGpuMemoryBuffer(size_t width,
122                                                       size_t height,
123                                                       unsigned internalformat,
124                                                       unsigned usage,
125                                                       int32* id) OVERRIDE;
126   virtual void DestroyGpuMemoryBuffer(int32 id) OVERRIDE;
127   virtual uint32 InsertSyncPoint() OVERRIDE;
128   virtual uint32 InsertFutureSyncPoint() OVERRIDE;
129   virtual void RetireSyncPoint(uint32 sync_point) OVERRIDE;
130   virtual void SignalSyncPoint(uint32 sync_point,
131                                const base::Closure& callback) OVERRIDE;
132   virtual void SignalQuery(uint32 query_id,
133                            const base::Closure& callback) OVERRIDE;
134   virtual void SetSurfaceVisible(bool visible) OVERRIDE;
135   virtual void Echo(const base::Closure& callback) OVERRIDE;
136   virtual uint32 CreateStreamTexture(uint32 texture_id) OVERRIDE;
137 
138   // The serializer interface to the GPU service (i.e. thread).
139   class Service {
140    public:
141     Service();
142     virtual ~Service();
143 
144     virtual void AddRef() const = 0;
145     virtual void Release() const = 0;
146 
147     // Queues a task to run as soon as possible.
148     virtual void ScheduleTask(const base::Closure& task) = 0;
149 
150     // Schedules |callback| to run at an appropriate time for performing idle
151     // work.
152     virtual void ScheduleIdleWork(const base::Closure& task) = 0;
153 
154     virtual bool UseVirtualizedGLContexts() = 0;
155     virtual scoped_refptr<gles2::ShaderTranslatorCache>
156         shader_translator_cache() = 0;
157     scoped_refptr<gles2::MailboxManager> mailbox_manager();
158 
159    private:
160     scoped_refptr<gles2::MailboxManager> mailbox_manager_;
161   };
162 
163 #if defined(OS_ANDROID)
164   scoped_refptr<gfx::SurfaceTexture> GetSurfaceTexture(
165       uint32 stream_id);
166 #endif
167 
168  private:
169   struct InitializeOnGpuThreadParams {
170     bool is_offscreen;
171     gfx::AcceleratedWidget window;
172     const gfx::Size& size;
173     const std::vector<int32>& attribs;
174     gfx::GpuPreference gpu_preference;
175     gpu::Capabilities* capabilities;  // Ouptut.
176     InProcessCommandBuffer* context_group;
177 
InitializeOnGpuThreadParamsInitializeOnGpuThreadParams178     InitializeOnGpuThreadParams(bool is_offscreen,
179                                 gfx::AcceleratedWidget window,
180                                 const gfx::Size& size,
181                                 const std::vector<int32>& attribs,
182                                 gfx::GpuPreference gpu_preference,
183                                 gpu::Capabilities* capabilities,
184                                 InProcessCommandBuffer* share_group)
185         : is_offscreen(is_offscreen),
186           window(window),
187           size(size),
188           attribs(attribs),
189           gpu_preference(gpu_preference),
190           capabilities(capabilities),
191           context_group(share_group) {}
192   };
193 
194   bool InitializeOnGpuThread(const InitializeOnGpuThreadParams& params);
195   bool DestroyOnGpuThread();
196   void FlushOnGpuThread(int32 put_offset);
197   void ScheduleIdleWorkOnGpuThread();
198   uint32 CreateStreamTextureOnGpuThread(uint32 client_texture_id);
199   bool MakeCurrent();
200   base::Closure WrapCallback(const base::Closure& callback);
201   State GetStateFast();
QueueTask(const base::Closure & task)202   void QueueTask(const base::Closure& task) { service_->ScheduleTask(task); }
203   void CheckSequencedThread();
204   void RetireSyncPointOnGpuThread(uint32 sync_point);
205   void SignalSyncPointOnGpuThread(uint32 sync_point,
206                                   const base::Closure& callback);
207   bool WaitSyncPointOnGpuThread(uint32 sync_point);
208   void SignalQueryOnGpuThread(unsigned query_id, const base::Closure& callback);
209   void DestroyTransferBufferOnGpuThread(int32 id);
210   void RegisterGpuMemoryBufferOnGpuThread(
211       int32 id,
212       const gfx::GpuMemoryBufferHandle& handle,
213       size_t width,
214       size_t height,
215       unsigned internalformat);
216   void UnregisterGpuMemoryBufferOnGpuThread(int32 id);
217 
218   // Callbacks:
219   void OnContextLost();
220   void OnResizeView(gfx::Size size, float scale_factor);
221   bool GetBufferChanged(int32 transfer_buffer_id);
222   void PumpCommands();
223   void PerformIdleWork();
224 
225   static scoped_refptr<Service> GetDefaultService();
226 
227   // Members accessed on the gpu thread (possibly with the exception of
228   // creation):
229   bool context_lost_;
230   scoped_ptr<TransferBufferManagerInterface> transfer_buffer_manager_;
231   scoped_ptr<GpuScheduler> gpu_scheduler_;
232   scoped_ptr<gles2::GLES2Decoder> decoder_;
233   scoped_refptr<gfx::GLContext> context_;
234   scoped_refptr<gfx::GLSurface> surface_;
235   base::Closure context_lost_callback_;
236   bool idle_work_pending_;  // Used to throttle PerformIdleWork.
237 
238   // Members accessed on the client thread:
239   State last_state_;
240   int32 last_put_offset_;
241   gpu::Capabilities capabilities_;
242   typedef base::ScopedPtrHashMap<int32, gfx::GpuMemoryBuffer>
243       GpuMemoryBufferMap;
244   GpuMemoryBufferMap gpu_memory_buffers_;
245 
246   // Accessed on both threads:
247   scoped_ptr<CommandBufferServiceBase> command_buffer_;
248   base::Lock command_buffer_lock_;
249   base::WaitableEvent flush_event_;
250   scoped_refptr<Service> service_;
251   State state_after_last_flush_;
252   base::Lock state_after_last_flush_lock_;
253   scoped_refptr<gfx::GLShareGroup> gl_share_group_;
254 
255 #if defined(OS_ANDROID)
256   scoped_ptr<StreamTextureManagerInProcess> stream_texture_manager_;
257 #endif
258 
259   // Only used with explicit scheduling and the gpu thread is the same as
260   // the client thread.
261   scoped_ptr<base::SequenceChecker> sequence_checker_;
262 
263   base::WeakPtr<InProcessCommandBuffer> gpu_thread_weak_ptr_;
264   base::WeakPtrFactory<InProcessCommandBuffer> gpu_thread_weak_ptr_factory_;
265 
266   DISALLOW_COPY_AND_ASSIGN(InProcessCommandBuffer);
267 };
268 
269 }  // namespace gpu
270 
271 #endif  // GPU_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_
272