Rework FlushSync to return early if commands have been processed since the last update

content/renderer/command_buffer_proxy.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/command_buffer_proxy.h"
 
 #include "base/logging.h"
 #include "base/process_util.h"
 #include "base/shared_memory.h"
 #include "base/task.h"
@@ skipping 122 matching lines @@
   // Return locally cached ring buffer.
   Buffer buffer;
   buffer.ptr = ring_buffer_->memory();
   buffer.size = num_entries_ * sizeof(gpu::CommandBufferEntry);
   buffer.shared_memory = ring_buffer_.get();
   return buffer;
 }
 
 gpu::CommandBuffer::State CommandBufferProxy::GetState() {
   // Send will flag state with lost context if IPC fails.
-  if (last_state_.error == gpu::error::kNoError)
-    Send(new GpuCommandBufferMsg_GetState(route_id_, &last_state_));
+  if (last_state_.error == gpu::error::kNoError) {
+    gpu::CommandBuffer::State state;
+    if (Send(new GpuCommandBufferMsg_GetState(route_id_, &state)))
+      OnUpdateState(state);
+  }
 
   return last_state_;
 }
 
 void CommandBufferProxy::Flush(int32 put_offset) {
-  AsyncFlush(put_offset, NULL);
+  if (last_state_.error != gpu::error::kNoError)
+    return;
+
+  Send(new GpuCommandBufferMsg_AsyncFlush(route_id_, put_offset));
 }
 
-gpu::CommandBuffer::State CommandBufferProxy::FlushSync(int32 put_offset) {
+gpu::CommandBuffer::State CommandBufferProxy::FlushSync(int32 put_offset,
+                                                        int32 last_known_get) {
   GPU_TRACE_EVENT0("gpu", "CommandBufferProxy::FlushSync");
-  // Send will flag state with lost context if IPC fails.
-  if (last_state_.error == gpu::error::kNoError) {
-    Send(new GpuCommandBufferMsg_Flush(route_id_,
-                                       put_offset,
-                                       &last_state_));
+  if (last_known_get == last_state_.get_offset) {
+    // Send will flag state with lost context if IPC fails.
+    if (last_state_.error == gpu::error::kNoError) {
+      gpu::CommandBuffer::State state;
+      if (Send(new GpuCommandBufferMsg_Flush(route_id_,
+                                             put_offset,
+                                             last_known_get,
+                                             &state)))
+        OnUpdateState(state);
+    }
+  } else {
+    Flush(put_offset);
   }
 
   return last_state_;
 }
 
 void CommandBufferProxy::SetGetOffset(int32 get_offset) {
   // Not implemented in proxy.
   NOTREACHED();
 }
 
@@ skipping 168 matching lines @@
 
 #if defined(OS_MACOSX)
 void CommandBufferProxy::SetWindowSize(const gfx::Size& size) {
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   Send(new GpuCommandBufferMsg_SetWindowSize(route_id_, size));
 }
 #endif
 
-void CommandBufferProxy::AsyncGetState(Task* completion_task) {
-  if (last_state_.error != gpu::error::kNoError)
-    return;
-
-  IPC::Message* message = new GpuCommandBufferMsg_AsyncGetState(route_id_);
-
-  // Do not let a synchronous flush hold up this message. If this handler is
-  // deferred until after the synchronous flush completes, it will overwrite the
-  // cached last_state_ with out-of-date data.
-  message->set_unblock(true);
-
-  if (Send(message))
-    pending_async_flush_tasks_.push(linked_ptr<Task>(completion_task));
-}
-
-void CommandBufferProxy::AsyncFlush(int32 put_offset, Task* completion_task) {
-  if (last_state_.error != gpu::error::kNoError)
-    return;
-
-  IPC::Message* message = new GpuCommandBufferMsg_AsyncFlush(route_id_,
-                                                          put_offset);
-
-  // Do not let a synchronous flush hold up this message. If this handler is
-  // deferred until after the synchronous flush completes, it will overwrite the
-  // cached last_state_ with out-of-date data.
-  message->set_unblock(true);
-
-  if (Send(message))
-    pending_async_flush_tasks_.push(linked_ptr<Task>(completion_task));
-}
-
 bool CommandBufferProxy::Send(IPC::Message* msg) {
   // Caller should not intentionally send a message if the context is lost.
   DCHECK(last_state_.error == gpu::error::kNoError);
 
   if (channel_) {
     if (channel_->Send(msg)) {
       return true;
     } else {
       // Flag the command buffer as lost. Defer deleting the channel until
       // OnChannelError is called after returning to the message loop in case
       // it is referenced elsewhere.
       last_state_.error = gpu::error::kLostContext;
       return false;
     }
   }
 
   // Callee takes ownership of message, regardless of whether Send is
   // successful. See IPC::Message::Sender.
   delete msg;
   return false;
 }
 
 void CommandBufferProxy::OnUpdateState(const gpu::CommandBuffer::State& state) {
-  last_state_ = state;
-
-  linked_ptr<Task> task = pending_async_flush_tasks_.front();
-  pending_async_flush_tasks_.pop();
-
-  if (task.get()) {
-    // Although we need need to update last_state_ while potentially waiting
-    // for a synchronous flush to complete, we do not need to invoke the
-    // callback synchonously. Also, post it as a non nestable task so it is
-    // always invoked by the outermost message loop.
-    MessageLoop::current()->PostNonNestableTask(FROM_HERE, task.release());
-  }
+  // Handle wraparound. It works as long as we don't have more than 2B state
+  // updates in flight across which reordering occurs.
+  if (state.generation - last_state_.generation < 0x80000000U)
+    last_state_ = state;
 }