Added GPU process "echo" IPC message.

content/renderer/gpu/command_buffer_proxy.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.
 
 #include "content/renderer/gpu/command_buffer_proxy.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/process_util.h"
 #include "base/shared_memory.h"
+#include "base/stl_util.h"
 #include "base/task.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/plugin_messages.h"
 #include "content/common/view_messages.h"
 #include "content/renderer/gpu/gpu_channel_host.h"
 #include "content/renderer/plugin_channel_host.h"
 #include "content/renderer/render_thread.h"
 #include "gpu/command_buffer/common/cmd_buffer_common.h"
 #include "ui/gfx/size.h"
 
@@ skipping 17 matching lines @@
     delete it->second.shared_memory;
     it->second.shared_memory = NULL;
   }
 }
 
 bool CommandBufferProxy::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(CommandBufferProxy, message)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_UpdateState, OnUpdateState);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_Destroyed, OnDestroyed);
-    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SwapBuffers, OnSwapBuffers);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_NotifyRepaint,
                         OnNotifyRepaint);
+    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_EchoAck, OnEchoAck);
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   DCHECK(handled);
   return handled;
 }
 
 void CommandBufferProxy::OnChannelError() {
   for (Decoders::iterator it = video_decoder_hosts_.begin();
        it != video_decoder_hosts_.end(); ++it) {
@@ skipping 11 matching lines @@
   last_state_.error = gpu::error::kLostContext;
   last_state_.context_lost_reason = reason;
 
   if (channel_error_callback_.get()) {
     channel_error_callback_->Run();
     // Avoid calling the error callback more than once.
     channel_error_callback_.reset();
   }
 }
 
+void CommandBufferProxy::OnEchoAck() {
+  DCHECK(!echo_tasks_.empty());
+  Task* task = echo_tasks_.front().release();
+  echo_tasks_.pop();
+  task->Run();
+}
+
 void CommandBufferProxy::SetChannelErrorCallback(Callback0::Type* callback) {
   channel_error_callback_.reset(callback);
 }
 
 bool CommandBufferProxy::Initialize(int32 size) {
   DCHECK(!ring_buffer_.get());
 
   RenderThread* render_thread = RenderThread::current();
   if (!render_thread)
     return false;
@@ skipping 245 matching lines @@
   // Not implemented in proxy.
   NOTREACHED();
 }
 
 void CommandBufferProxy::SetContextLostReason(
     gpu::error::ContextLostReason reason) {
   // Not implemented in proxy.
   NOTREACHED();
 }
 
-void CommandBufferProxy::OnSwapBuffers() {
-  if (swap_buffers_callback_.get())
-    swap_buffers_callback_->Run();
+bool CommandBufferProxy::Echo(Task* task) {
+  if (last_state_.error != gpu::error::kNoError) {
+    delete task;
+    return false;
+  }
+
+  if (!Send(new GpuChannelMsg_Echo(GpuCommandBufferMsg_EchoAck(route_id_)))) {
+    delete task;
+    return false;
+  }
+
+  echo_tasks_.push(linked_ptr<Task>(task));
+
+  return true;
 }
 
 bool CommandBufferProxy::SetParent(CommandBufferProxy* parent_command_buffer,
                                    uint32 parent_texture_id) {
   if (last_state_.error != gpu::error::kNoError)
     return false;
 
   bool result;
   if (parent_command_buffer) {
     if (!Send(new GpuCommandBufferMsg_SetParent(
         route_id_,
         parent_command_buffer->route_id_,
         parent_texture_id,
         &result))) {
       return false;
     }
   } else {
     if (!Send(new GpuCommandBufferMsg_SetParent(
         route_id_,
         MSG_ROUTING_NONE,
         0,
         &result))) {
       return false;
     }
   }
 
   return result;
 }
 
-void CommandBufferProxy::SetSwapBuffersCallback(Callback0::Type* callback) {
-  swap_buffers_callback_.reset(callback);
-}
-
 void CommandBufferProxy::SetNotifyRepaintTask(Task* task) {
   notify_repaint_task_.reset(task);
 }
 
 scoped_refptr<GpuVideoDecodeAcceleratorHost>
 CommandBufferProxy::CreateVideoDecoder(
     const std::vector<int32>& configs,
     media::VideoDecodeAccelerator::Client* client) {
   int decoder_route_id;
   if (!Send(new GpuCommandBufferMsg_CreateVideoDecoder(route_id_, configs,
@@ skipping 34 matching lines @@
   delete msg;
   return false;
 }
 
 void CommandBufferProxy::OnUpdateState(const gpu::CommandBuffer::State& state) {
   // Handle wraparound. It works as long as we don't have more than 2B state
   // updates in flight across which reordering occurs.
   if (state.generation - last_state_.generation < 0x80000000U)
     last_state_ = state;
 }