Implement proper synchronization between HW video decode IPC and CommandBuffer.

content/common/gpu/gpu_command_buffer_stub.cc

 // Copyright (c) 2011 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/callback.h"
 #include "base/debug/trace_event.h"
 #include "base/process_util.h"
 #include "base/shared_memory.h"
 #include "build/build_config.h"
 #include "content/common/child_thread.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_messages.h"
 #include "content/common/gpu/gpu_watchdog.h"
@@ skipping 127 matching lines @@
           NewCallback(scheduler_.get(),
                       &gpu::GpuScheduler::PutChanged));
       command_buffer_->SetParseErrorCallback(
           NewCallback(this, &GpuCommandBufferStub::OnParseError));
       scheduler_->SetSwapBuffersCallback(
           NewCallback(this, &GpuCommandBufferStub::OnSwapBuffers));
       scheduler_->SetLatchCallback(base::Bind(
           &GpuChannel::OnLatchCallback, base::Unretained(channel_), route_id_));
       scheduler_->SetScheduledCallback(
           NewCallback(this, &GpuCommandBufferStub::OnScheduled));
+      scheduler_->SetTokenCallback(base::Bind(
+          &GpuCommandBufferStub::OnSetToken, base::Unretained(this)));
       if (watchdog_)
         scheduler_->SetCommandProcessedCallback(
             NewCallback(this, &GpuCommandBufferStub::OnCommandProcessed));
 
 #if defined(OS_MACOSX) || defined(TOUCH_UI)
       if (handle_) {
         // This context conceptually puts its output directly on the
         // screen, rendered by the accelerated plugin layer in
         // RenderWidgetHostViewMac. Set up a pathway to notify the
         // browser process when its contents change.
@@ skipping 316 matching lines @@
   // the stub, this method allows us to cleanup and unblock pending messages.
   if (scheduler_.get()) {
     while (!scheduler_->IsScheduled())
       scheduler_->SetScheduled(true);
   }
   // Handle any deferred messages now that the scheduler is not blocking
   // message handling.
   HandleDeferredMessages();
 }
 
+void GpuCommandBufferStub::AddSetTokenCallback(
+    const base::Callback<void(int32)>& callback) {
+  set_token_callbacks_.push_back(callback);
+}
+
+void GpuCommandBufferStub::OnSetToken(int32 token) {
+  for (size_t i = 0; i < set_token_callbacks_.size(); ++i)
+    set_token_callbacks_[i].Run(token);
+}
+
 void GpuCommandBufferStub::ResizeCallback(gfx::Size size) {
   if (handle_ == gfx::kNullPluginWindow) {
     scheduler_->decoder()->ResizeOffscreenFrameBuffer(size);
     scheduler_->decoder()->UpdateOffscreenFrameBufferSize();
   } else {
 #if defined(TOOLKIT_USES_GTK) && !defined(TOUCH_UI) || defined(OS_WIN)
     GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
     gpu_channel_manager->Send(
         new GpuHostMsg_ResizeView(renderer_id_,
                                   render_view_id_,
@@ skipping 53 matching lines @@
       gfx::GLContext::LosesAllContextsOnContextLost()) {
     channel_->LoseAllContexts();
   } else {
     IPC::Message* msg = new GpuCommandBufferMsg_UpdateState(route_id_, state);
     msg->set_unblock(true);
     Send(msg);
   }
 }
 
 #endif  // defined(ENABLE_GPU)