GPU: Adding sync points for cross-channel synchronization

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.
 
 #if defined(ENABLE_GPU)
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/shared_memory.h"
 #include "base/time.h"
 #include "build/build_config.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/gpu_channel_manager.h"
 #include "content/common/gpu/gpu_command_buffer_stub.h"
 #include "content/common/gpu/gpu_memory_manager.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/gpu/gpu_watchdog.h"
 #include "content/common/gpu/image_transport_surface.h"
+#include "content/common/gpu/sync_point_manager.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_switches.h"
 
 #if defined(OS_WIN)
 #include "content/public/common/sandbox_init.h"
 #endif
 
 GpuCommandBufferStub::SurfaceState::SurfaceState(int32 surface_id,
@@ skipping 93 matching lines @@
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_CreateVideoDecoder,
                                     OnCreateVideoDecoder)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_DestroyVideoDecoder,
                         OnDestroyVideoDecoder)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SetSurfaceVisible,
                         OnSetSurfaceVisible)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_DiscardBackbuffer,
                         OnDiscardBackbuffer)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_EnsureBackbuffer,
                         OnEnsureBackbuffer)
+    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_RetireSyncPoint,
+                        OnRetireSyncPoint)
+    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_WaitSyncPoint,
+                        OnWaitSyncPoint)
     IPC_MESSAGE_HANDLER(
         GpuCommandBufferMsg_SetClientHasMemoryAllocationChangedCallback,
         OnSetClientHasMemoryAllocationChangedCallback)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   DCHECK(handled);
   return handled;
 }
 
@@ skipping 49 matching lines @@
     scoped_ptr<IPC::Message> message(delayed_echos_.front());
     delayed_echos_.pop_front();
 
     OnMessageReceived(*message);
   }
 
   channel_->OnScheduled();
 }
 
 void GpuCommandBufferStub::Destroy() {
+  while (!sync_points_.empty())
+    OnRetireSyncPoint(sync_points_.front());
+
   // The scheduler has raw references to the decoder and the command buffer so
   // destroy it before those.
   scheduler_.reset();
 
   while (!delayed_echos_.empty()) {
     delete delayed_echos_.front();
     delayed_echos_.pop_front();
   }
 
   if (decoder_.get())
@@ skipping 388 matching lines @@
   surface_->SetBackbufferAllocation(false);
 }
 
 void GpuCommandBufferStub::OnEnsureBackbuffer() {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnEnsureBackbuffer");
   if (!surface_)
     return;
   surface_->SetBackbufferAllocation(true);
 }
 
+void GpuCommandBufferStub::AddSyncPoint(uint32 sync_point) {
+  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);
+}
+
+void GpuCommandBufferStub::OnWaitSyncPoint(uint32 sync_point) {
+  if (!scheduler_.get())
+    return;
+  scheduler_->SetScheduled(false);
+  GpuChannelManager* manager = channel_->gpu_channel_manager();
+  manager->sync_point_manager()->AddSyncPointCallback(
+      sync_point,
+      base::Bind(&GpuCommandBufferStub::OnSyncPointRetired,
+                 this->AsWeakPtr()));
+}
+
+void GpuCommandBufferStub::OnSyncPointRetired() {
+  if (!scheduler_.get())
+    return;
+  scheduler_->SetScheduled(true);
+}
+
 void GpuCommandBufferStub::OnSetClientHasMemoryAllocationChangedCallback(
     bool has_callback) {
   TRACE_EVENT0(
       "gpu",
       "GpuCommandBufferStub::OnSetClientHasMemoryAllocationChangedCallback");
   client_has_memory_allocation_changed_callback_ = has_callback;
   channel_->gpu_channel_manager()->gpu_memory_manager()->ScheduleManage();
 }
 
 void GpuCommandBufferStub::SendConsoleMessage(
@@ skipping 47 matching lines @@
 
 void GpuCommandBufferStub::SetMemoryAllocation(
     const GpuMemoryAllocation& allocation) {
   Send(new GpuCommandBufferMsg_SetMemoryAllocation(route_id_, allocation));
   if (!surface_)
     return;
   surface_->SetFrontbufferAllocation(allocation.suggest_have_frontbuffer);
 }
 
 #endif  // defined(ENABLE_GPU)