Implemented new fence syncs which replaces the old sync points.

content/common/gpu/gpu_command_buffer_stub.h

 // Copyright (c) 2012 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 CONTENT_COMMON_GPU_GPU_COMMAND_BUFFER_STUB_H_
 #define CONTENT_COMMON_GPU_GPU_COMMAND_BUFFER_STUB_H_
 
 #include <deque>
+#include <functional>
+#include <queue>
 #include <string>
 #include <vector>
 
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "content/common/content_export.h"
 #include "content/common/gpu/gpu_memory_manager.h"
 #include "content/common/gpu/gpu_memory_manager_client.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/command_buffer/common/gpu_memory_allocation.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
 #include "gpu/command_buffer/service/context_group.h"
+#include "gpu/command_buffer/service/fence_sync_manager.h"
 #include "gpu/command_buffer/service/gpu_scheduler.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_sender.h"
 #include "media/base/video_decoder_config.h"
 #include "ui/events/latency_info.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/gpu_memory_buffer.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/swap_result.h"
 #include "ui/gl/gl_surface.h"
@@ skipping 76 matching lines @@
   // If the command buffer is pre-empted and cannot process commands.
   bool IsPreempted() const {
     return scheduler_.get() && scheduler_->IsPreempted();
   }
 
   // Whether there are commands in the buffer that haven't been processed.
   bool HasUnprocessedCommands();
 
   gpu::gles2::GLES2Decoder* decoder() const { return decoder_.get(); }
   gpu::GpuScheduler* scheduler() const { return scheduler_.get(); }
+  gpu::FenceSyncManager* fence_sync_manager() const {
+    return fence_sync_manager_.get();
+  }
   GpuChannel* channel() const { return channel_; }
 
   // Identifies the target surface.
   int32 surface_id() const { return surface_id_; }
 
   // Identifies the various GpuCommandBufferStubs in the GPU process belonging
   // to the same renderer process.
   int32 route_id() const { return route_id_; }
 
   // Identifies the stream for this command buffer.
@@ skipping 14 matching lines @@
   void RemoveDestructionObserver(DestructionObserver* observer);
 
   // Associates a sync point to this stub. When the stub is destroyed, it will
   // retire all sync points that haven't been previously retired.
   void AddSyncPoint(uint32 sync_point);
 
   void SetPreemptByFlag(scoped_refptr<gpu::PreemptionFlag> flag);
 
   void SetLatencyInfoCallback(const LatencyInfoCallback& callback);
 
+  // Make sure fence sync is released by the time the order number is processed.
+  void ValidateFenceSyncRelease(uint32_t max_order_number, uint32_t release);
+
   void MarkContextLost();
 
   const gpu::gles2::FeatureInfo* GetFeatureInfo() const;
 
   void SendSwapBuffersCompleted(
       const std::vector<ui::LatencyInfo>& latency_info,
       gfx::SwapResult result);
   void SendUpdateVSyncParameters(base::TimeTicks timebase,
                                  base::TimeDelta interval);
 
  private:
+  typedef std::pair<uint32_t, uint32_t> OrderFenceSync;
+  typedef std::priority_queue<OrderFenceSync,
+                              std::vector<OrderFenceSync>,
+                              std::greater<OrderFenceSync>> OrderFenceQueue;
+
   GpuMemoryManager* GetMemoryManager() const;
 
   void Destroy();
 
   bool MakeCurrent();
 
   // Cleans up and sends reply if OnInitialize failed.
   void OnInitializeFailed(IPC::Message* reply_message);
 
   // Message handlers:
@@ skipping 31 matching lines @@
 
   void OnEnsureBackbuffer();
 
   void OnRetireSyncPoint(uint32 sync_point);
   bool OnWaitSyncPoint(uint32 sync_point);
   void OnWaitSyncPointCompleted(uint32 sync_point);
   void OnSignalSyncPoint(uint32 sync_point, uint32 id);
   void OnSignalSyncPointAck(uint32 id);
   void OnSignalQuery(uint32 query, uint32 id);
 
+  void OnFenceSenceRelease(uint32_t release);
+  bool OnWaitFenceSync(int channel_client_id,
+                       uint32_t route_id,
+                       uint32_t release);
+  void OnWaitFenceSyncCompleted(int channel_client_id,
+                                uint32_t route_id,
+                                uint32_t release);
+  void OnOrderNumberReached(uint32_t order_number);
+
   void OnSetClientHasMemoryAllocationChangedCallback(bool has_callback);
 
   void OnCreateImage(int32 id,
                      gfx::GpuMemoryBufferHandle handle,
                      gfx::Size size,
                      gfx::BufferFormat format,
                      uint32 internalformat);
   void OnDestroyImage(int32 id);
 
   void OnCommandProcessed();
   void OnParseError();
   void OnCreateStreamTexture(
       uint32 texture_id, int32 stream_id, bool* succeeded);
 
   void ReportState();
 
   // Wrapper for GpuScheduler::PutChanged that sets the crash report URL.
   void PutChanged();
 
   // Poll the command buffer to execute work.
   void PollWork();
 
   // Whether this command buffer needs to be polled again in the future.
   bool HasMoreWork();
 
   void ScheduleDelayedWork(int64 delay);
 
   bool CheckContextLost();
   void CheckCompleteWaits();
-  void PullTextureUpdates(uint32 sync_point);
+  void PullTextureUpdates(int channel_id, uint32_t route_id, uint32 release);
 
   // The lifetime of objects of this class is managed by a GpuChannel. The
   // GpuChannels destroy all the GpuCommandBufferStubs that they own when they
   // are destroyed. So a raw pointer is safe.
   GpuChannel* channel_;
 
   // Task runner for main thread.
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   // The group of contexts that share namespaces with this context.
   scoped_refptr<gpu::gles2::ContextGroup> context_group_;
 
   bool initialized_;
   gfx::GLSurfaceHandle handle_;
   gfx::Size initial_size_;
   gpu::gles2::DisallowedFeatures disallowed_features_;
   std::vector<int32> requested_attribs_;
   gfx::GpuPreference gpu_preference_;
   bool use_virtualized_gl_context_;
   const int32 stream_id_;
   const int32 route_id_;
   const int32 surface_id_;
   bool software_;
   uint32 last_flush_count_;
 
   scoped_ptr<gpu::CommandBufferService> command_buffer_;
   scoped_ptr<gpu::gles2::GLES2Decoder> decoder_;
   scoped_ptr<gpu::GpuScheduler> scheduler_;
+  scoped_ptr<gpu::FenceSyncManager> fence_sync_manager_;
   scoped_refptr<gfx::GLSurface> surface_;
 
   scoped_ptr<GpuMemoryManagerClientState> memory_manager_client_state_;
   // The last memory allocation received from the GpuMemoryManager (used to
   // elide redundant work).
   bool last_memory_allocation_valid_;
   gpu::MemoryAllocation last_memory_allocation_;
 
   GpuWatchdog* watchdog_;
 
@@ skipping 11 matching lines @@
 
   LatencyInfoCallback latency_info_callback_;
 
   GURL active_url_;
   size_t active_url_hash_;
 
   size_t total_gpu_memory_;
   scoped_ptr<WaitForCommandState> wait_for_token_;
   scoped_ptr<WaitForCommandState> wait_for_get_offset_;
 
+  // In situations where we are waiting on fence syncs that do not exist, we
+  // validate the channel which the fence sync should have occurred by making
+  // sure the order number of that channel does not pass the order number which
+  // the wait command was issued. If that channel's order number reaches the
+  // wait command's order, we should automatically release up to the expected
+  // release count. Note that this also releases other lower release counts,
+  // so a single misbehaved fence sync is enough to invalidate/signal all
+  // previous fence syncs.
+  OrderFenceQueue order_fence_queue_;
+
   DISALLOW_COPY_AND_ASSIGN(GpuCommandBufferStub);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_GPU_COMMAND_BUFFER_STUB_H_