Added GPU process "echo" IPC message.

content/renderer/gpu/renderer_gl_context.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/renderer_gl_context.h"
 
 #include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 174 matching lines @@
   uint32 texture_id = 0;
   gles2_implementation_->GenTextures(1, &texture_id);
   gles2_implementation_->Flush();
   return texture_id;
 }
 
 void RendererGLContext::DeleteParentTexture(uint32 texture) {
   gles2_implementation_->DeleteTextures(1, &texture);
 }
 
-void RendererGLContext::SetSwapBuffersCallback(Callback0::Type* callback) {
-  swap_buffers_callback_.reset(callback);
-}
-
 void RendererGLContext::SetContextLostCallback(
     Callback1<ContextLostReason>::Type* callback) {
   context_lost_callback_.reset(callback);
 }
 
 bool RendererGLContext::MakeCurrent(RendererGLContext* context) {
   if (context) {
     gles2::SetGLContext(context->gles2_implementation_);
 
     // Don't request latest error status from service. Just use the locally
@@ skipping 13 matching lines @@
 bool RendererGLContext::SwapBuffers() {
   TRACE_EVENT1("gpu", "RendererGLContext::SwapBuffers", "frame", frame_number_);
   frame_number_++;
 
   // Don't request latest error status from service. Just use the locally cached
   // information from the last flush.
   if (command_buffer_->GetLastState().error != gpu::error::kNoError)
     return false;
 
   gles2_implementation_->SwapBuffers();
+
   return true;
 }
 
+bool RendererGLContext::Echo(Task* task) {
+  return command_buffer_->Echo(task);
+}
+
 scoped_refptr<TransportTextureHost>
 RendererGLContext::CreateTransportTextureHost() {
   return channel_->transport_texture_service()->CreateTransportTextureHost(
       this, command_buffer_->route_id());
 }
 
 RendererGLContext::Error RendererGLContext::GetError() {
   gpu::CommandBuffer::State state = command_buffer_->GetState();
   if (state.error == gpu::error::kNoError) {
     Error old_error = last_error_;
@@ skipping 116 matching lines @@
   {
     TRACE_EVENT0("gpu",
                  "RendererGLContext::Initialize::InitializeCommandBuffer");
     // Initiaize the command buffer.
     if (!command_buffer_->Initialize(kCommandBufferSize)) {
       Destroy();
       return false;
     }
   }
 
-  command_buffer_->SetSwapBuffersCallback(
-      NewCallback(this, &RendererGLContext::OnSwapBuffers));
-
   command_buffer_->SetChannelErrorCallback(
       NewCallback(this, &RendererGLContext::OnContextLost));
 
   // Create the GLES2 helper, which writes the command buffer protocol.
   gles2_helper_ = new gpu::gles2::GLES2CmdHelper(command_buffer_);
   if (!gles2_helper_->Initialize(kCommandBufferSize)) {
     Destroy();
     return false;
   }
 
@@ skipping 54 matching lines @@
   gles2_helper_ = NULL;
 
   if (channel_ && command_buffer_) {
     channel_->DestroyCommandBuffer(command_buffer_);
     command_buffer_ = NULL;
   }
 
   channel_ = NULL;
 }
 
-void RendererGLContext::OnSwapBuffers() {
-  if (swap_buffers_callback_.get())
-    swap_buffers_callback_->Run();
-}
-
 void RendererGLContext::OnContextLost() {
   if (context_lost_callback_.get()) {
     RendererGLContext::ContextLostReason reason = kUnknown;
     if (command_buffer_) {
       reason = ConvertReason(
           command_buffer_->GetLastState().context_lost_reason);
     }
     context_lost_callback_->Run(reason);
   }
 }