List sync points to wait on in AsyncFlush message

content/common/gpu/gpu_command_buffer_stub.cc

 // 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.
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/hash.h"
 #include "base/json/json_writer.h"
@@ skipping 204 matching lines @@
 bool GpuCommandBufferStub::OnMessageReceived(const IPC::Message& message) {
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"),
                "GPUTask",
                "data",
                DevToolsChannelData::CreateForChannel(channel()));
   // TODO(yurys): remove devtools_gpu_instrumentation call once DevTools
   // Timeline migrates to tracing crbug.com/361045.
   devtools_gpu_instrumentation::ScopedGpuTask task(channel());
   FastSetActiveURL(active_url_, active_url_hash_);
 
-  bool have_context = false;
   // Ensure the appropriate GL context is current before handling any IPC
   // messages directed at the command buffer. This ensures that the message
   // handler can assume that the context is current (not necessary for
   // RetireSyncPoint or WaitSyncPoint).
   if (decoder_.get() &&
       message.type() != GpuCommandBufferMsg_SetGetBuffer::ID &&
       message.type() != GpuCommandBufferMsg_WaitForTokenInRange::ID &&
       message.type() != GpuCommandBufferMsg_WaitForGetOffsetInRange::ID &&
       message.type() != GpuCommandBufferMsg_RegisterTransferBuffer::ID &&
       message.type() != GpuCommandBufferMsg_DestroyTransferBuffer::ID &&
       message.type() != GpuCommandBufferMsg_RetireSyncPoint::ID &&
       message.type() != GpuCommandBufferMsg_SignalSyncPoint::ID &&
+      message.type() != GpuCommandBufferMsg_AsyncFlush::ID &&
       message.type() !=
           GpuCommandBufferMsg_SetClientHasMemoryAllocationChangedCallback::ID) {
     if (!MakeCurrent())
       return false;
-    have_context = true;
   }
 
   // Always use IPC_MESSAGE_HANDLER_DELAY_REPLY for synchronous message handlers
   // here. This is so the reply can be delayed if the scheduler is unscheduled.
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuCommandBufferStub, message)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_Initialize,
                                     OnInitialize);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_SetGetBuffer,
                                     OnSetGetBuffer);
@@ skipping 26 matching lines @@
         OnSetClientHasMemoryAllocationChangedCallback)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_CreateImage, OnCreateImage);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_DestroyImage, OnDestroyImage);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_CreateStreamTexture,
                         OnCreateStreamTexture)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   CheckCompleteWaits();
 
-  if (have_context) {
-    // Ensure that any delayed work that was created will be handled.
-    ScheduleDelayedWork(kHandleMoreWorkPeriodMs);
-  }
+  // Ensure that any delayed work that was created will be handled.
+  ScheduleDelayedWork(kHandleMoreWorkPeriodMs);
 
   DCHECK(handled);
   return handled;
 }
 
 bool GpuCommandBufferStub::Send(IPC::Message* message) {
   return channel_->Send(message);
 }
 
 bool GpuCommandBufferStub::IsScheduled() {
@@ skipping 273 matching lines @@
       switches::kEnableGPUServiceLogging)) {
     decoder_->set_log_commands(true);
   }
 
   decoder_->GetLogger()->SetMsgCallback(
       base::Bind(&GpuCommandBufferStub::SendConsoleMessage,
                  base::Unretained(this)));
   decoder_->SetShaderCacheCallback(
       base::Bind(&GpuCommandBufferStub::SendCachedShader,
                  base::Unretained(this)));
-  decoder_->SetWaitSyncPointCallback(
-      base::Bind(&GpuCommandBufferStub::OnWaitSyncPoint,
-                 base::Unretained(this)));
 
   command_buffer_->SetPutOffsetChangeCallback(
       base::Bind(&GpuCommandBufferStub::PutChanged, base::Unretained(this)));
   command_buffer_->SetGetBufferChangeCallback(
       base::Bind(&gpu::GpuScheduler::SetGetBuffer,
                  base::Unretained(scheduler_.get())));
   command_buffer_->SetParseErrorCallback(
       base::Bind(&GpuCommandBufferStub::OnParseError, base::Unretained(this)));
   scheduler_->SetSchedulingChangedCallback(
       base::Bind(&GpuChannel::StubSchedulingChanged,
@@ skipping 143 matching lines @@
           wait_for_get_offset_->reply.get(), state);
       Send(wait_for_get_offset_->reply.release());
       wait_for_get_offset_.reset();
     }
   }
 }
 
 void GpuCommandBufferStub::OnAsyncFlush(
     int32 put_offset,
     uint32 flush_count,
+    const std::vector<uint32>& sync_points,
     const std::vector<ui::LatencyInfo>& latency_info) {
   TRACE_EVENT1(
       "gpu", "GpuCommandBufferStub::OnAsyncFlush", "put_offset", put_offset);
 
   if (ui::LatencyInfo::Verify(latency_info,
                               "GpuCommandBufferStub::OnAsyncFlush") &&
       !latency_info_callback_.is_null()) {
     latency_info_callback_.Run(latency_info);
   }
+  for (uint32 sync_point : sync_points) {
+    WaitSyncPoint(sync_point);
+  }
+  if (scheduler_->IsScheduled())
+    MakeCurrent();
   DCHECK(command_buffer_.get());
   if (flush_count - last_flush_count_ < 0x8000000U) {
     last_flush_count_ = flush_count;
-    command_buffer_->Flush(put_offset);
+    command_buffer_->Flush(put_offset, sync_points);
   } else {
     // We received this message out-of-order. This should not happen but is here
     // to catch regressions. Ignore the message.
     NOTREACHED() << "Received a Flush message out-of-order";
   }
 
   ReportState();
 }
 
 void GpuCommandBufferStub::OnRescheduled() {
   gpu::CommandBuffer::State pre_state = command_buffer_->GetLastState();
-  command_buffer_->Flush(command_buffer_->GetPutOffset());
+  command_buffer_->Flush(command_buffer_->GetPutOffset(),
+                         std::vector<uint32>());
   gpu::CommandBuffer::State post_state = command_buffer_->GetLastState();
 
   if (pre_state.get_offset != post_state.get_offset)
     ReportState();
 }
 
 void GpuCommandBufferStub::OnRegisterTransferBuffer(
     int32 id,
     base::SharedMemoryHandle transfer_buffer,
     uint32 size) {
@@ skipping 74 matching lines @@
   sync_points_.push_back(sync_point);
 }
 
 void GpuCommandBufferStub::OnRetireSyncPoint(uint32 sync_point) {
   DCHECK(!sync_points_.empty() && sync_points_.front() == sync_point);
   sync_points_.pop_front();
   GpuChannelManager* manager = channel_->gpu_channel_manager();
   manager->sync_point_manager()->RetireSyncPoint(sync_point);
 }
 
-bool GpuCommandBufferStub::OnWaitSyncPoint(uint32 sync_point) {
+void GpuCommandBufferStub::WaitSyncPoint(uint32 sync_point) {
   if (!sync_point)
-    return true;
+    return;
   GpuChannelManager* manager = channel_->gpu_channel_manager();
   if (manager->sync_point_manager()->IsSyncPointRetired(sync_point))
-    return true;
+    return;
 
   if (sync_point_wait_count_ == 0) {
     TRACE_EVENT_ASYNC_BEGIN1("gpu", "WaitSyncPoint", this,
                              "GpuCommandBufferStub", this);
   }
   scheduler_->SetScheduled(false);
   ++sync_point_wait_count_;
   manager->sync_point_manager()->AddSyncPointCallback(
       sync_point,
       base::Bind(&GpuCommandBufferStub::OnSyncPointRetired,
                  this->AsWeakPtr()));
-  return scheduler_->IsScheduled();
 }
 
 void GpuCommandBufferStub::OnSyncPointRetired() {
   --sync_point_wait_count_;
   if (sync_point_wait_count_ == 0) {
     TRACE_EVENT_ASYNC_END1("gpu", "WaitSyncPoint", this,
                            "GpuCommandBufferStub", this);
   }
   scheduler_->SetScheduled(true);
 }
@@ skipping 184 matching lines @@
 uint64 GpuCommandBufferStub::GetMemoryUsage() const {
   return GetMemoryManager()->GetClientMemoryUsage(this);
 }
 
 void GpuCommandBufferStub::SwapBuffersCompleted(
     const std::vector<ui::LatencyInfo>& latency_info) {
   Send(new GpuCommandBufferMsg_SwapBuffersCompleted(route_id_, latency_info));
 }
 
 }  // namespace content