Allow FlushSyncs to short circuit

content/common/gpu/gpu_command_buffer_stub.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.
 
 #if defined(ENABLE_GPU)
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/shared_memory.h"
@@ skipping 72 matching lines @@
 
   // 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(GpuCommandBufferStub, message)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_Initialize,
                                     OnInitialize);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_SetParent,
                                     OnSetParent);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_GetState, OnGetState);
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_Flush, OnFlush);
+    IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_GetStateFast,
+                                    OnGetStateFast);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_AsyncFlush, OnAsyncFlush);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_Rescheduled, OnRescheduled);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_CreateTransferBuffer,
                                     OnCreateTransferBuffer);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_RegisterTransferBuffer,
                                     OnRegisterTransferBuffer);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_DestroyTransferBuffer,
                                     OnDestroyTransferBuffer);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_GetTransferBuffer,
                                     OnGetTransferBuffer);
@@ skipping 197 matching lines @@
 
 void GpuCommandBufferStub::OnParseError() {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnParseError");
   gpu::CommandBuffer::State state = command_buffer_->GetState();
   IPC::Message* msg = new GpuCommandBufferMsg_Destroyed(
       route_id_, state.context_lost_reason);
   msg->set_unblock(true);
   Send(msg);
 }
 
-void GpuCommandBufferStub::OnFlush(int32 put_offset,
-                                   int32 last_known_get,
-                                   uint32 flush_count,
-                                   IPC::Message* reply_message) {
-  TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnFlush");
+void GpuCommandBufferStub::OnGetStateFast(IPC::Message* reply_message) {
+  TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnGetStateFast");
   gpu::CommandBuffer::State state = command_buffer_->GetState();
-  if (flush_count - last_flush_count_ >= 0x8000000U) {
-    // We received this message out-of-order. This should not happen but is here
-    // to catch regressions. Ignore the message.
-    NOTREACHED() << "Received an AsyncFlush message out-of-order";
-    GpuCommandBufferMsg_Flush::WriteReplyParams(reply_message, state);
-    Send(reply_message);
-  } else {
-    last_flush_count_ = flush_count;
+  if (state.error == gpu::error::kLostContext &&
+      gfx::GLContext::LosesAllContextsOnContextLost())
+    channel_->LoseAllContexts();
 
-    // Reply immediately if the client was out of date with the current get
-    // offset.
-    bool reply_immediately = state.get_offset != last_known_get;
-    if (reply_immediately) {
-      GpuCommandBufferMsg_Flush::WriteReplyParams(reply_message, state);
-      Send(reply_message);
-    }
-
-    // Process everything up to the put offset.
-    state = command_buffer_->FlushSync(put_offset, last_known_get);
-
-    // Lose all contexts if the context was lost.
-    if (state.error == gpu::error::kLostContext &&
-        gfx::GLContext::LosesAllContextsOnContextLost()) {
-      channel_->LoseAllContexts();
-    }
-
-    // Then if the client was up-to-date with the get offset, reply to the
-    // synchronpous IPC only after processing all commands are processed. This
-    // prevents the client from "spinning" when it fills up the command buffer.
-    // Otherwise, since the state has changed since the immediate reply, send
-    // an asyncronous state update back to the client.
-    if (!reply_immediately) {
-      GpuCommandBufferMsg_Flush::WriteReplyParams(reply_message, state);
-      Send(reply_message);
-    } else {
-      ReportState();
-    }
-  }
+  GpuCommandBufferMsg_GetStateFast::WriteReplyParams(reply_message, state);
+  Send(reply_message);
 }
 
-void GpuCommandBufferStub::OnAsyncFlush(int32 put_offset, uint32 flush_count) {
-  TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnAsyncFlush");
+void GpuCommandBufferStub::OnAsyncFlush(int32 put_offset,
+                                        uint32 flush_count) {
+  TRACE_EVENT1("gpu", "GpuCommandBufferStub::OnAsyncFlush",
+               "put_offset", put_offset);
   if (flush_count - last_flush_count_ < 0x8000000U) {
     last_flush_count_ = flush_count;
     command_buffer_->Flush(put_offset);
   } else {
     // We received this message out-of-order. This should not happen but is here
     // to catch regressions. Ignore the message.
     NOTREACHED() << "Received a Flush message out-of-order";
   }
 
   ReportState();
@@ skipping 154 matching lines @@
   channel_->AddRoute(decoder_route_id, decoder);
   decoder->Initialize(profile, reply_message);
 }
 
 void GpuCommandBufferStub::OnDestroyVideoDecoder(int decoder_route_id) {
   channel_->RemoveRoute(decoder_route_id);
   video_decoders_.Remove(decoder_route_id);
 }
 
 #endif  // defined(ENABLE_GPU)