Implemented new fence syncs which replaces the old sync points.

gpu/command_buffer/service/in_process_command_buffer.h

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef GPU_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_
 
 #include <map>
 #include <vector>
 
@@ skipping 112 matching lines @@
   void RetireSyncPoint(uint32 sync_point) override;
   void SignalSyncPoint(uint32 sync_point,
                        const base::Closure& callback) override;
   void SignalQuery(uint32 query_id, const base::Closure& callback) override;
   void SetSurfaceVisible(bool visible) override;
   uint32 CreateStreamTexture(uint32 texture_id) override;
   void SetLock(base::Lock*) override;
   bool IsGpuChannelLost() override;
   CommandBufferNamespace GetNamespaceID() const override;
   uint64_t GetCommandBufferID() const override;
+  uint32_t GenerateFenceSyncRelease() override;
+  bool IsFenceSyncRelease(uint32_t release) override;
+  bool IsFenceSyncFlushed(uint32_t release) override;
 
   // The serializer interface to the GPU service (i.e. thread).
   class Service {
    public:
     Service();
     virtual ~Service();
 
     virtual void AddRef() const = 0;
     virtual void Release() const = 0;
 
@@ skipping 65 matching lines @@
   uint32 CreateStreamTextureOnGpuThread(uint32 client_texture_id);
   bool MakeCurrent();
   base::Closure WrapCallback(const base::Closure& callback);
   State GetStateFast();
   void QueueTask(const base::Closure& task) { service_->ScheduleTask(task); }
   void CheckSequencedThread();
   void RetireSyncPointOnGpuThread(uint32 sync_point);
   void SignalSyncPointOnGpuThread(uint32 sync_point,
                                   const base::Closure& callback);
   bool WaitSyncPointOnGpuThread(uint32 sync_point);
+  void FenceSyncReleaseOnGpuThread(uint32_t release);
+  bool WaitFenceSyncOnGpuThread(gpu::CommandBufferNamespace namespace_id,
+                                uint64_t command_buffer_id,
+                                uint32_t release);
   void SignalQueryOnGpuThread(unsigned query_id, const base::Closure& callback);
   void DestroyTransferBufferOnGpuThread(int32 id);
   void CreateImageOnGpuThread(int32 id,
                               const gfx::GpuMemoryBufferHandle& handle,
                               const gfx::Size& size,
                               gfx::BufferFormat format,
                               uint32 internalformat);
   void DestroyImageOnGpuThread(int32 id);
   void SetGetBufferOnGpuThread(int32 shm_id, base::WaitableEvent* completion);
 
@@ skipping 19 matching lines @@
   base::Closure context_lost_callback_;
   bool delayed_work_pending_;  // Used to throttle PerformDelayedWork.
   ImageFactory* image_factory_;
 
   // Members accessed on the client thread:
   State last_state_;
   int32 last_put_offset_;
   gpu::Capabilities capabilities_;
   GpuMemoryBufferManager* gpu_memory_buffer_manager_;
   base::AtomicSequenceNumber next_image_id_;
+  uint32_t next_fence_sync_release_;
+  uint32_t flushed_fence_sync_release_;
 
   // Accessed on both threads:
   scoped_ptr<CommandBufferServiceBase> command_buffer_;
   base::Lock command_buffer_lock_;
   base::WaitableEvent flush_event_;
   scoped_refptr<Service> service_;
   State state_after_last_flush_;
   base::Lock state_after_last_flush_lock_;
   scoped_refptr<gfx::GLShareGroup> gl_share_group_;
+  base::WaitableEvent fence_sync_wait_event_;
 
 #if defined(OS_ANDROID)
   scoped_ptr<StreamTextureManagerInProcess> stream_texture_manager_;
 #endif
 
   // Only used with explicit scheduling and the gpu thread is the same as
   // the client thread.
   scoped_ptr<base::SequenceChecker> sequence_checker_;
 
   base::WeakPtr<InProcessCommandBuffer> gpu_thread_weak_ptr_;
@@ skipping 28 matching lines @@
   SyncPointManager* sync_point_manager_;  // Non-owning.
   scoped_refptr<gpu::gles2::ShaderTranslatorCache> shader_translator_cache_;
   scoped_refptr<gpu::gles2::FramebufferCompletenessCache>
       framebuffer_completeness_cache_;
   DISALLOW_COPY_AND_ASSIGN(GpuInProcessThread);
 };
 
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_IN_PROCESS_COMMAND_BUFFER_H_