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 38 matching lines @@
       disallowed_extensions_(disallowed_extensions),
       allowed_extensions_(allowed_extensions),
       requested_attribs_(attribs),
       parent_texture_id_(parent_texture_id),
       route_id_(route_id),
 #if defined(OS_WIN)
       compositor_window_(NULL),
 #endif  // defined(OS_WIN)
       renderer_id_(renderer_id),
       render_view_id_(render_view_id),
-      watchdog_(watchdog) {
+      watchdog_(watchdog),
+      task_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 #if defined(OS_WIN)
 static LRESULT CALLBACK CompositorWindowProc(
     HWND hwnd,
     UINT message,
     WPARAM wparam,
     LPARAM lparam) {
   switch (message) {
     case WM_ERASEBKGND:
@@ skipping 179 matching lines @@
     if (scheduler_->Initialize(
         output_window_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 24 matching lines @@
   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));
+  IPC::Message* msg = new GpuCommandBufferMsg_UpdateState(route_id_, state);
+  msg->set_unblock(true);
+  Send(msg);
 }
 
 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();

[apatrick_chromium, 2011/04/27 22:52:44]

Why did you remove this?

[piman, 2011/04/27 23:44:29]

Since we're not waiting on any command to execute, it doesn't really make sense
anymore here.
I meant to put it back into OnAsyncGetState, but missed it. It's there now
(renamed "ReportState"). I also added it to OnGetState, it makes sense there
too.

-  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::OnAsyncGetState));
 }
 
 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 108 matching lines @@
 #elif defined(OS_WIN)
     HWND hwnd = static_cast<HWND>(compositor_window_);
     UINT swp_flags = SWP_NOSENDCHANGING | SWP_NOOWNERZORDER | SWP_NOCOPYBITS |
       SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_DEFERERASE;
     SetWindowPos(hwnd, NULL, 0, 0, size.width(), size.height(), swp_flags);
 #endif  // defined(OS_LINUX)
   }
 }
 
 #endif  // defined(ENABLE_GPU)