gpu: Remove Echo and SwapCompletion GL interfacess

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 644 matching lines @@
     IPC_MESSAGE_HANDLER(GpuChannelMsg_DevToolsStartEventsRecording,
                         OnDevToolsStartEventsRecording)
     IPC_MESSAGE_HANDLER(GpuChannelMsg_DevToolsStopEventsRecording,
                         OnDevToolsStopEventsRecording)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled) << msg.type();
   return handled;
 }
 
-size_t GpuChannel::MatchSwapBufferMessagesPattern(
-    IPC::Message* current_message) {
+size_t GpuChannel::MatchRetireSyncPointPattern(IPC::Message* current_message) {
   DCHECK(current_message);
   if (deferred_messages_.empty() || !current_message)
     return 0;
   // 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();
 
   // Fetch the first message and move index to point to the second message.
   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.

[jbauman, 2014/10/01 02:15:38]

Change this comment.

[jbauman, 2014/10/01 02:20:59]

Although, to keep the logic working in a similar way you should probably check
for the AsyncFlush, RetireSyncPoint, SignalSyncPoint sequence (and
subsequences). Look at https://codereview.chromium.org/564903002/ to see how
that might be handled.

-  if (current_message->type() == GpuCommandBufferMsg_AsyncFlush::ID &&
-      first_message->type() == GpuCommandBufferMsg_Echo::ID &&
+  if (first_message->type() == GpuCommandBufferMsg_RetireSyncPoint::ID &&
       first_message->routing_id() == routing_id) {
     return 1;
   }
 
   // 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;
   bool should_handle_swapbuffer_msgs_immediate = false;
   IPC::Message* m = NULL;
   GpuCommandBufferStub* stub = NULL;
 
   do {
     m = deferred_messages_.front();
     stub = stubs_.Lookup(m->routing_id());
     if (stub) {
       if (!stub->IsScheduled())
         return;
+      // TODO: We might want to still retire sync points, and mostly
+      // care about preempting flushes here.
       if (stub->IsPreempted()) {
         OnScheduled();
         return;
       }
     }
 
     scoped_ptr<IPC::Message> message(m);
     deferred_messages_.pop_front();
     bool message_processed = true;
 
@@ skipping 24 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 AsyncFlush->Echo sequence.
+    // the pattern of Flush followed by Insert/RetireSyncPoint since
+    // sync points imply a Flush.
     //
     // 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.
+    // of being blocked by other channels, and signal clients or unblock waiting
+    // contexts 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());
+      // Start from the current processing message to match RetireSyncPoint
+      // pattern.
+      matched_messages_num = MatchRetireSyncPointPattern(message.get());
       should_handle_swapbuffer_msgs_immediate =
           matched_messages_num > 0 && stub;
     } else {
       DCHECK_GT(matched_messages_num, 0u);
       --matched_messages_num;
       if (!stub || matched_messages_num == 0)
         should_handle_swapbuffer_msgs_immediate = false;
     }
   } while (should_handle_swapbuffer_msgs_immediate);
 
@@ skipping 94 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