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

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/process_util.h"
 #include "base/shared_memory.h"
 #include "build/build_config.h"
@@ skipping 36 matching lines @@
       parent_(
           parent ? parent->AsWeakPtr() : base::WeakPtr<GpuCommandBufferStub>()),
       initial_size_(size),
       disallowed_extensions_(disallowed_extensions),
       allowed_extensions_(allowed_extensions),
       requested_attribs_(attribs),
       parent_texture_id_(parent_texture_id),
       route_id_(route_id),
       renderer_id_(renderer_id),
       render_view_id_(render_view_id),
-      watchdog_(watchdog) {
+      watchdog_(watchdog),
+      task_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 GpuCommandBufferStub::~GpuCommandBufferStub() {
   if (scheduler_.get()) {
     scheduler_->Destroy();
   }
 
   GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
   gpu_channel_manager->Send(new GpuHostMsg_DestroyCommandBuffer(
       handle_, renderer_id_, render_view_id_));
 }
 
 bool GpuCommandBufferStub::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuCommandBufferStub, message)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_Initialize, OnInitialize);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_GetState, OnGetState);
-    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_AsyncGetState, OnAsyncGetState);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_Flush, OnFlush);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_AsyncFlush, OnAsyncFlush);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_CreateTransferBuffer,
                         OnCreateTransferBuffer);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_RegisterTransferBuffer,
                         OnRegisterTransferBuffer);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_DestroyTransferBuffer,
                         OnDestroyTransferBuffer);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_GetTransferBuffer,
                         OnGetTransferBuffer);
@@ skipping 42 matching lines @@
     if (scheduler_->Initialize(
         handle_,
         initial_size_,
         disallowed_extensions_,
         allowed_extensions_.c_str(),
         requested_attribs_,
         parent_processor,
         parent_texture_id_)) {
       command_buffer_->SetPutOffsetChangeCallback(
           NewCallback(scheduler_.get(),
-                      &gpu::GpuScheduler::ProcessCommands));
+                      &gpu::GpuScheduler::PutChanged));
       scheduler_->SetSwapBuffersCallback(
           NewCallback(this, &GpuCommandBufferStub::OnSwapBuffers));
       scheduler_->SetLatchCallback(base::Bind(
           &GpuChannel::OnLatchCallback, base::Unretained(channel_), route_id_));
       if (watchdog_)
         scheduler_->SetCommandProcessedCallback(
             NewCallback(this, &GpuCommandBufferStub::OnCommandProcessed));
 
 #if defined(OS_MACOSX)
       if (handle_) {
@@ skipping 20 matching lines @@
   }
 }
 
 void GpuCommandBufferStub::OnCommandProcessed() {
   if (watchdog_)
     watchdog_->CheckArmed();
 }
 
 void GpuCommandBufferStub::OnGetState(gpu::CommandBuffer::State* state) {
   *state = command_buffer_->GetState();
-}
-
-void GpuCommandBufferStub::OnAsyncGetState() {
-  gpu::CommandBuffer::State state = command_buffer_->GetState();
-  Send(new GpuCommandBufferMsg_UpdateState(route_id_, state));
+  if (state->error == gpu::error::kLostContext &&
+      gfx::GLContext::LosesAllContextsOnContextLost())
+    channel_->LoseAllContexts();
 }
 
 void GpuCommandBufferStub::OnFlush(int32 put_offset,
+                                   int32 last_known_get,
                                    gpu::CommandBuffer::State* state) {
   GPU_TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnFlush");
-  *state = command_buffer_->FlushSync(put_offset);
+  *state = command_buffer_->FlushSync(put_offset, last_known_get);
   if (state->error == gpu::error::kLostContext &&
       gfx::GLContext::LosesAllContextsOnContextLost())
     channel_->LoseAllContexts();
 }
 
 void GpuCommandBufferStub::OnAsyncFlush(int32 put_offset) {
   GPU_TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnAsyncFlush");
-  gpu::CommandBuffer::State state = command_buffer_->FlushSync(put_offset);
-  if (state.error == gpu::error::kLostContext &&
-      gfx::GLContext::LosesAllContextsOnContextLost())
-    channel_->LoseAllContexts();
-  else
-    Send(new GpuCommandBufferMsg_UpdateState(route_id_, state));
+  command_buffer_->Flush(put_offset);
+  // TODO(piman): Do this everytime the scheduler finishes processing a batch of
+  // commands.
+  MessageLoop::current()->PostTask(FROM_HERE,
+      task_factory_.NewRunnableMethod(&GpuCommandBufferStub::ReportState));
 }
 
 void GpuCommandBufferStub::OnCreateTransferBuffer(int32 size,
                                                   int32 id_request,
                                                   int32* id) {
   *id = command_buffer_->CreateTransferBuffer(size, id_request);
 }
 
 void GpuCommandBufferStub::OnRegisterTransferBuffer(
     base::SharedMemoryHandle transfer_buffer,
@@ skipping 126 matching lines @@
   gfx::GLContext* context = scheduler_->decoder()->GetGLContext();
   context->ReleaseCurrent();
   gfx::GLSurface* surface = context->GetSurface();
   if (surface) {
     surface->Destroy();
     surface->Initialize();
   }
 #endif
 }
 
+void GpuCommandBufferStub::ReportState() {
+  gpu::CommandBuffer::State state = command_buffer_->GetState();
+  if (state.error == gpu::error::kLostContext &&
+      gfx::GLContext::LosesAllContextsOnContextLost())
+    channel_->LoseAllContexts();
+  else {

[brettw, 2011/04/28 21:21:05]

Need {} for the top arm since you use them for the bottom.

[piman, 2011/04/28 21:31:13]

Done.

+    IPC::Message* msg = new GpuCommandBufferMsg_UpdateState(route_id_, state);
+    msg->set_unblock(true);
+    Send(msg);
+  }
+}
+
 #endif  // defined(ENABLE_GPU)