Make echo message per-command-buffer

content/common/gpu/gpu_channel.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(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "content/common/gpu/gpu_channel.h"
 
@@ skipping 55 matching lines @@
 #endif
 }
 
 bool GpuChannel::OnMessageReceived(const IPC::Message& message) {
   if (log_messages_) {
     DVLOG(1) << "received message @" << &message << " on channel @" << this
              << " with type " << message.type();
   }
 
   // Control messages are not deferred and can be handled out of order with
-  // respect to routed ones. Except for Echo, which must be deferred in order
-  // to respect the asynchronous Mac SwapBuffers.
-  if (message.routing_id() == MSG_ROUTING_CONTROL &&
-      message.type() != GpuChannelMsg_Echo::ID)
+  // respect to routed ones.
+  if (message.routing_id() == MSG_ROUTING_CONTROL)
     return OnControlMessageReceived(message);
 
   if (message.type() == GpuCommandBufferMsg_GetStateFast::ID) {
     if (processed_get_state_fast_) {
       // Require a non-GetStateFast message in between two GetStateFast
       // messages, to ensure progress is made.
       std::deque<IPC::Message*>::iterator point = deferred_messages_.begin();
 
       while (point != deferred_messages_.end() &&
              (*point)->type() == GpuCommandBufferMsg_GetStateFast::ID) {
@@ skipping 132 matching lines @@
 bool GpuChannel::OnControlMessageReceived(const IPC::Message& msg) {
   // 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(GpuChannel, msg)
     IPC_MESSAGE_HANDLER(GpuChannelMsg_Initialize, OnInitialize)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuChannelMsg_CreateOffscreenCommandBuffer,
                                     OnCreateOffscreenCommandBuffer)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuChannelMsg_DestroyCommandBuffer,
                                     OnDestroyCommandBuffer)
-    IPC_MESSAGE_HANDLER(GpuChannelMsg_Echo, OnEcho);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuChannelMsg_WillGpuSwitchOccur,
                                     OnWillGpuSwitchOccur)
     IPC_MESSAGE_HANDLER(GpuChannelMsg_CloseChannel, OnCloseChannel)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled) << msg.type();
   return handled;
 }
 
 void GpuChannel::HandleMessage() {
   handle_messages_scheduled_ = false;
   if (!IsScheduled())
       return;
 
   if (!deferred_messages_.empty()) {
     scoped_ptr<IPC::Message> message(deferred_messages_.front());
     deferred_messages_.pop_front();
     processed_get_state_fast_ =
         (message->type() == GpuCommandBufferMsg_GetStateFast::ID);
     // Handle deferred control messages.
-    if (message->routing_id() == MSG_ROUTING_CONTROL)
-      OnControlMessageReceived(*message);
-    else if (!router_.RouteMessage(*message)) {
+    if (!router_.RouteMessage(*message)) {
       // Respond to sync messages even if router failed to route.
       if (message->is_sync()) {
         IPC::Message* reply = IPC::SyncMessage::GenerateReply(&*message);
         reply->set_reply_error();
         Send(reply);
       }
     } else {
       // If the channel becomes unscheduled as a result of handling the message
       // or has more work to do, synthesize an IPC message to flush the command
       // buffer that became unscheduled.
@@ skipping 101 matching lines @@
     if (need_reschedule)
       OnScheduled();
     DidDestroyCommandBuffer(gpu_preference);
   }
 #endif
 
   if (reply_message)
     Send(reply_message);
 }
 
-void GpuChannel::OnEcho(const IPC::Message& message) {
-  TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnEcho");
-  Send(new IPC::Message(message));
-}
 
 void GpuChannel::OnWillGpuSwitchOccur(bool is_creating_context,
                                       gfx::GpuPreference gpu_preference,
                                       IPC::Message* reply_message) {
   TRACE_EVENT0("gpu", "GpuChannel::OnWillGpuSwitchOccur");
 
   bool will_switch_occur = false;
 
   if (gpu_preference == gfx::PreferDiscreteGpu &&
       gfx::GLContext::SupportsDualGpus()) {
@@ skipping 49 matching lines @@
 
 #if defined(OS_POSIX)
 int GpuChannel::TakeRendererFileDescriptor() {
   if (!channel_.get()) {
     NOTREACHED();
     return -1;
   }
   return channel_->TakeClientFileDescriptor();
 }
 #endif  // defined(OS_POSIX)