Merge GpuCommandBufferMsg_SetLatencyInfo into GpuCommandBufferMsg_AsyncFlush

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 649 matching lines @@
   IPC_END_MESSAGE_MAP()
   DCHECK(handled) << msg.type();
   return handled;
 }
 
 size_t GpuChannel::MatchSwapBufferMessagesPattern(
     IPC::Message* current_message) {
   DCHECK(current_message);
   if (deferred_messages_.empty() || !current_message)
     return 0;
-  // Only care about SetLatencyInfo and AsyncFlush message.
-  if (current_message->type() != GpuCommandBufferMsg_SetLatencyInfo::ID &&
-      current_message->type() != GpuCommandBufferMsg_AsyncFlush::ID)
+  // Only care about AsyncFlush message.
+  if (current_message->type() != GpuCommandBufferMsg_AsyncFlush::ID)
     return 0;
 
   size_t index = 0;
   int32 routing_id = current_message->routing_id();
 
-  // In case of the current message is SetLatencyInfo, we try to look ahead one
-  // more deferred messages.
-  IPC::Message *first_message = NULL;
-  IPC::Message *second_message = NULL;
-
   // Fetch the first message and move index to point to the second message.
-  first_message = deferred_messages_[index++];
+  IPC::Message* first_message = deferred_messages_[index++];
 
   // If the current message is AsyncFlush, the expected message sequence for
   // SwapBuffer should be AsyncFlush->Echo. We only try to match Echo message.
   if (current_message->type() == GpuCommandBufferMsg_AsyncFlush::ID &&
       first_message->type() == GpuCommandBufferMsg_Echo::ID &&
       first_message->routing_id() == routing_id) {
     return 1;
   }
 
-  // If the current message is SetLatencyInfo, the expected message sequence
-  // for SwapBuffer should be SetLatencyInfo->AsyncFlush->Echo (optional).
-  if (current_message->type() == GpuCommandBufferMsg_SetLatencyInfo::ID &&
-      first_message->type() == GpuCommandBufferMsg_AsyncFlush::ID &&
-      first_message->routing_id() == routing_id) {
-    if (deferred_messages_.size() >= 2)
-      second_message = deferred_messages_[index];
-    if (!second_message)
-      return 1;
-    if (second_message->type() == GpuCommandBufferMsg_Echo::ID &&
-        second_message->routing_id() == routing_id) {
-      return 2;
-    }
-  }
   // No matched message is found.
   return 0;
 }
 
 void GpuChannel::HandleMessage() {
   handle_messages_scheduled_ = false;
   if (deferred_messages_.empty())
     return;
 
   size_t matched_messages_num = 0;
@@ skipping 46 matching lines @@
     }
     if (message_processed)
       MessageProcessed();
 
     if (deferred_messages_.empty())
       break;
 
     // We process the pending messages immediately if these messages matches
     // the pattern of SwapBuffers, for example, GLRenderer always issues
     // SwapBuffers calls with a specific IPC message patterns, for example,
-    // it should be SetLatencyInfo->AsyncFlush->Echo sequence.
+    // it should be AsyncFlush->Echo sequence.
     //
     // Instead of posting a task to message loop, it could avoid the possibility
     // of being blocked by other channels, and make SwapBuffers executed as soon
     // as possible.
     if (!should_handle_swapbuffer_msgs_immediate) {
       // Start from the current processing message to match SwapBuffer pattern.
       matched_messages_num = MatchSwapBufferMessagesPattern(message.get());
       should_handle_swapbuffer_msgs_immediate =
           matched_messages_num > 0 && stub;
     } else {
@@ skipping 101 matching lines @@
 uint64 GpuChannel::GetMemoryUsage() {
   uint64 size = 0;
   for (StubMap::Iterator<GpuCommandBufferStub> it(&stubs_);
        !it.IsAtEnd(); it.Advance()) {
     size += it.GetCurrentValue()->GetMemoryUsage();
   }
   return size;
 }
 
 }  // namespace content