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

ppapi/proxy/ppb_context_3d_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 "ppapi/proxy/ppb_context_3d_proxy.h"
 
 #include "base/hash_tables.h"
 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
 #include "gpu/command_buffer/client/gles2_implementation.h"
 #include "ppapi/c/pp_errors.h"
@@ skipping 137 matching lines @@
 }
 
 gpu::CommandBuffer::State GPUStateFromPPState(
     const PP_Context3DTrustedState& s) {
   gpu::CommandBuffer::State state;
   state.num_entries = s.num_entries;
   state.get_offset = s.get_offset;
   state.put_offset = s.put_offset;
   state.token = s.token;
   state.error = static_cast<gpu::error::Error>(s.error);
+  state.generation = s.generation;
   return state;
 }
 
 // Size of the transfer buffer.
 const int32 kCommandBufferSize = 1024 * 1024;
 const int32 kTransferBufferSize = 1024 * 1024;
 
 InterfaceProxy* CreateContext3DProxy(Dispatcher* dispatcher,
                                      const void* target_interface) {
   return new PPB_Context3D_Proxy(dispatcher, target_interface);
 }
 
 }  // namespace
 
 class PepperCommandBuffer : public gpu::CommandBuffer {
  public:
   PepperCommandBuffer(const HostResource& resource,
                       PluginDispatcher* dispatcher);
   virtual ~PepperCommandBuffer();
 
   // CommandBuffer implementation:
   virtual bool Initialize(int32 size);
   virtual bool Initialize(base::SharedMemory* buffer, int32 size);
   virtual gpu::Buffer GetRingBuffer();
   virtual State GetState();
   virtual void Flush(int32 put_offset);
-  virtual State FlushSync(int32 put_offset);
+  virtual State FlushSync(int32 put_offset, int32 last_known_get);
   virtual void SetGetOffset(int32 get_offset);
   virtual int32 CreateTransferBuffer(size_t size, int32 id_request);
   virtual int32 RegisterTransferBuffer(base::SharedMemory* shared_memory,
                                        size_t size,
                                        int32 id_request);
   virtual void DestroyTransferBuffer(int32 id);
   virtual gpu::Buffer GetTransferBuffer(int32 handle);
   virtual void SetToken(int32 token);
   virtual void SetParseError(gpu::error::Error error);
 
  private:
   bool Send(IPC::Message* msg);
+  void UpdateState(const gpu::CommandBuffer::State& state);
 
   int32 num_entries_;
   scoped_ptr<base::SharedMemory> ring_buffer_;
 
   typedef base::hash_map<int32, gpu::Buffer> TransferBufferMap;
   TransferBufferMap transfer_buffers_;
 
   State last_state_;
 
   HostResource resource_;
@@ skipping 54 matching lines @@
   gpu::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 PepperCommandBuffer::GetState() {
   // Send will flag state with lost context if IPC fails.
   if (last_state_.error == gpu::error::kNoError) {
-    Send(new PpapiHostMsg_PPBContext3D_GetState(
-        INTERFACE_ID_PPB_CONTEXT_3D, resource_, &last_state_));
+    gpu::CommandBuffer::State state;
+    if (Send(new PpapiHostMsg_PPBContext3D_GetState(
+             INTERFACE_ID_PPB_CONTEXT_3D, resource_, &state)))
+      UpdateState(state);
   }
 
   return last_state_;
 }
 
 void PepperCommandBuffer::Flush(int32 put_offset) {
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   IPC::Message* message = new PpapiHostMsg_PPBContext3D_AsyncFlush(
       INTERFACE_ID_PPB_CONTEXT_3D, resource_, 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);
   Send(message);
 }
 
-gpu::CommandBuffer::State PepperCommandBuffer::FlushSync(int32 put_offset) {
-  // Send will flag state with lost context if IPC fails.
-  if (last_state_.error == gpu::error::kNoError) {
-    Send(new PpapiHostMsg_PPBContext3D_Flush(
-        INTERFACE_ID_PPB_CONTEXT_3D, resource_, put_offset, &last_state_));
+gpu::CommandBuffer::State PepperCommandBuffer::FlushSync(
+    int32 put_offset, int32 last_known_get) {
+  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 PpapiHostMsg_PPBContext3D_Flush(
+              INTERFACE_ID_PPB_CONTEXT_3D, resource_, put_offset,
+              last_known_get, &state)))
+        UpdateState(state);
+    }
+  } else {
+    Flush(put_offset);
   }
 
   return last_state_;
 }
 
 void PepperCommandBuffer::SetGetOffset(int32 get_offset) {
   // Not implemented in proxy.
   NOTREACHED();
 }
 
@@ skipping 86 matching lines @@
 bool PepperCommandBuffer::Send(IPC::Message* msg) {
   DCHECK(last_state_.error == gpu::error::kNoError);
 
   if (dispatcher_->Send(msg))
     return true;
 
   last_state_.error = gpu::error::kLostContext;
   return false;
 }
 
+void PepperCommandBuffer::UpdateState(const gpu::CommandBuffer::State& state) {
+  // 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;
+}
+
 Context3D::Context3D(const HostResource& resource)
     : PluginResource(resource),
       draw_(NULL),
       read_(NULL),
       transfer_buffer_id_(0) {
 }
 
 Context3D::~Context3D() {
   if (draw_)
     draw_->set_context(NULL);
@@ skipping 151 matching lines @@
 
 void PPB_Context3D_Proxy::OnMsgGetState(const HostResource& context,
                                         gpu::CommandBuffer::State* state) {
   PP_Context3DTrustedState pp_state =
       ppb_context_3d_trusted()->GetState(context.host_resource());
   *state = GPUStateFromPPState(pp_state);
 }
 
 void PPB_Context3D_Proxy::OnMsgFlush(const HostResource& context,
                                      int32 put_offset,
+                                     int32 last_known_get,
                                      gpu::CommandBuffer::State* state) {
-  PP_Context3DTrustedState pp_state =
-      ppb_context_3d_trusted()->FlushSync(context.host_resource(), put_offset);
+  PP_Context3DTrustedState pp_state = ppb_context_3d_trusted()->FlushSyncFast(
+      context.host_resource(), put_offset, last_known_get);
   *state = GPUStateFromPPState(pp_state);
 }
 
 void PPB_Context3D_Proxy::OnMsgAsyncFlush(const HostResource& context,
                                           int32 put_offset) {
   ppb_context_3d_trusted()->Flush(context.host_resource(), put_offset);
 }
 
 void PPB_Context3D_Proxy::OnMsgCreateTransferBuffer(
     const HostResource& context,
@@ skipping 22 matching lines @@
                                                    &shm_handle,
                                                    &shm_size)) {
     return;
   }
   *transfer_buffer = TransportSHMHandleFromInt(dispatcher(), shm_handle);
   *size = shm_size;
 }
 
 }  // namespace proxy
 }  // namespace pp