List sync points to wait on in AsyncFlush message

gpu/command_buffer/service/in_process_command_buffer.cc

 // 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.
 
 #include "gpu/command_buffer/service/in_process_command_buffer.h"
 
 #include <queue>
 #include <set>
 #include <utility>
 
@@ skipping 115 matching lines @@
 class SyncPointManager {
  public:
   SyncPointManager();
   ~SyncPointManager();
 
   uint32 GenerateSyncPoint();
   void RetireSyncPoint(uint32 sync_point);
 
   bool IsSyncPointPassed(uint32 sync_point);
   void WaitSyncPoint(uint32 sync_point);
+  bool WasSyncPointGenerated(uint32 sync_point);
 
 private:
   // This lock protects access to pending_sync_points_ and next_sync_point_ and
   // is used with the ConditionVariable to signal when a sync point is retired.
   base::Lock lock_;
   std::set<uint32> pending_sync_points_;
   uint32 next_sync_point_;
   base::ConditionVariable cond_var_;
 };
 
@@ skipping 23 matching lines @@
   return pending_sync_points_.count(sync_point) == 0;
 }
 
 void SyncPointManager::WaitSyncPoint(uint32 sync_point) {
   base::AutoLock lock(lock_);
   while (pending_sync_points_.count(sync_point)) {
     cond_var_.Wait();
   }
 }
 
+bool SyncPointManager::WasSyncPointGenerated(uint32 sync_point) {
+  base::AutoLock lock(lock_);
+  return next_sync_point_ - 1 - sync_point < 0x80000000;
+}
+
 base::LazyInstance<SyncPointManager> g_sync_point_manager =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // anonyous namespace
 
 InProcessCommandBuffer::Service::Service() {}
 
 InProcessCommandBuffer::Service::~Service() {}
 
 scoped_refptr<gles2::MailboxManager>
@@ skipping 229 matching lines @@
     LOG(ERROR) << "Could not initialize decoder.";
     DestroyOnGpuThread();
     return false;
   }
   *params.capabilities = decoder_->GetCapabilities();
 
   if (!params.is_offscreen) {
     decoder_->SetResizeCallback(base::Bind(
         &InProcessCommandBuffer::OnResizeView, gpu_thread_weak_ptr_));
   }
-  decoder_->SetWaitSyncPointCallback(
-      base::Bind(&InProcessCommandBuffer::WaitSyncPointOnGpuThread,
-                 base::Unretained(this)));
 
   image_factory_ = params.image_factory;
   params.capabilities->image = params.capabilities->image && image_factory_;
 
   return true;
 }
 
 void InProcessCommandBuffer::Destroy() {
   CheckSequencedThread();
 
@@ skipping 53 matching lines @@
   CheckSequencedThread();
   return last_state_;
 }
 
 int32 InProcessCommandBuffer::GetLastToken() {
   CheckSequencedThread();
   GetStateFast();
   return last_state_.token;
 }
 
-void InProcessCommandBuffer::FlushOnGpuThread(int32 put_offset) {
+void InProcessCommandBuffer::FlushOnGpuThread(
+    int32 put_offset,
+    const std::vector<uint32>& sync_points) {
   CheckSequencedThread();
+  for (uint32 sync_point : sync_points) {
+    WaitSyncPointOnGpuThread(sync_point);
+  }
   ScopedEvent handle_flush(&flush_event_);
   base::AutoLock lock(command_buffer_lock_);
-  command_buffer_->Flush(put_offset);
+  command_buffer_->Flush(put_offset, sync_points);
   {
     // Update state before signaling the flush event.
     base::AutoLock lock(state_after_last_flush_lock_);
     state_after_last_flush_ = command_buffer_->GetLastState();
   }
   DCHECK((!error::IsError(state_after_last_flush_.error) && !context_lost_) ||
          (error::IsError(state_after_last_flush_.error) && context_lost_));
 
   // If we've processed all pending commands but still have pending queries,
   // pump idle work until the query is passed.
@@ skipping 16 matching lines @@
 void InProcessCommandBuffer::ScheduleIdleWorkOnGpuThread() {
   CheckSequencedThread();
   if (idle_work_pending_)
     return;
   idle_work_pending_ = true;
   service_->ScheduleIdleWork(
       base::Bind(&InProcessCommandBuffer::PerformIdleWork,
                  gpu_thread_weak_ptr_));
 }
 
-void InProcessCommandBuffer::Flush(int32 put_offset) {
+void InProcessCommandBuffer::Flush(int32 put_offset,
+                                   const std::vector<uint32>& sync_points) {
   CheckSequencedThread();
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   if (last_put_offset_ == put_offset)
     return;
 
   last_put_offset_ = put_offset;
-  base::Closure task = base::Bind(&InProcessCommandBuffer::FlushOnGpuThread,
-                                  gpu_thread_weak_ptr_,
-                                  put_offset);
+  std::vector<uint32> sanitized_sync_points;
+  for (const int& sync_point : sync_points) {
+    if (g_sync_point_manager.Get().WasSyncPointGenerated(sync_point))
+      sanitized_sync_points.push_back(sync_point);
+  }
+
+  base::Closure task =
+      base::Bind(&InProcessCommandBuffer::FlushOnGpuThread,
+                 gpu_thread_weak_ptr_, put_offset, sanitized_sync_points);
   QueueTask(task);
 }
 
 void InProcessCommandBuffer::WaitForTokenInRange(int32 start, int32 end) {
   CheckSequencedThread();
   while (!InRange(start, end, GetLastToken()) &&
          last_state_.error == gpu::error::kNoError)
     flush_event_.Wait();
 }
 
@@ skipping 301 matching lines @@
 
 #if defined(OS_ANDROID)
 scoped_refptr<gfx::SurfaceTexture>
 InProcessCommandBuffer::GetSurfaceTexture(uint32 stream_id) {
   DCHECK(stream_texture_manager_);
   return stream_texture_manager_->GetSurfaceTexture(stream_id);
 }
 #endif
 
 }  // namespace gpu