WebGraphicsContext3DCommandBufferImpl cleanup, Canvas2D thottling fix, GpuScheduler fix.

gpu/command_buffer/service/gpu_scheduler.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 "gpu/command_buffer/service/gpu_scheduler.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
+#include "base/time.h"
 #include "ui/gfx/gl/gl_context.h"
 #include "ui/gfx/gl/gl_bindings.h"
 #include "ui/gfx/gl/gl_surface.h"
 #include "ui/gfx/gl/gl_switches.h"
 
 using ::base::SharedMemory;
 
+namespace {
+const int kMinimumSchedulerQuantumMicros = 2000;
+} // namespace
+
 namespace gpu {
 
 GpuScheduler::GpuScheduler(CommandBuffer* command_buffer,
                            SurfaceManager* surface_manager,
                            gles2::ContextGroup* group)
     : command_buffer_(command_buffer),
       commands_per_update_(100),
       unscheduled_count_(0),
 #if defined(OS_MACOSX)
       swap_buffers_count_(0),
@@ skipping 100 matching lines @@
   parser_.reset();
 }
 
 #if defined(OS_MACOSX)
 namespace {
 const unsigned int kMaxOutstandingSwapBuffersCallsPerOnscreenContext = 1;
 }
 #endif
 
 void GpuScheduler::PutChanged(bool sync) {
+  TRACE_EVENT0("gpu", "GpuScheduler:PutChanged");
   CommandBuffer::State state = command_buffer_->GetState();
   parser_->set_put(state.put_offset);
 
   if (sync)
     ProcessCommands();
   else
     ScheduleProcessCommands();
 }
 
 void GpuScheduler::ProcessCommands() {
   TRACE_EVENT0("gpu", "GpuScheduler:ProcessCommands");
   CommandBuffer::State state = command_buffer_->GetState();
   if (state.error != error::kNoError)
     return;
 
-  if (unscheduled_count_ > 0)
+  if (unscheduled_count_ > 0) {
+    TRACE_EVENT1("gpu", "EarlyOut_Unscheduled",
+                 "unscheduled_count_", unscheduled_count_);
     return;
+  }
 
   if (decoder_.get()) {
     if (!decoder_->MakeCurrent()) {
       LOG(ERROR) << "Context lost because MakeCurrent failed.";
       command_buffer_->SetParseError(error::kLostContext);
       return;
     }
   }
 
 #if defined(OS_MACOSX)
   bool do_rate_limiting = surface_.get() != NULL;
   // Don't swamp the browser process with SwapBuffers calls it can't handle.
   if (do_rate_limiting &&
       swap_buffers_count_ - acknowledged_swap_buffers_count_ >=
       kMaxOutstandingSwapBuffersCallsPerOnscreenContext) {
     // Stop doing work on this command buffer. In the GPU process,
     // receipt of the GpuMsg_AcceleratedSurfaceBuffersSwappedACK
     // message causes ProcessCommands to be scheduled again.
     return;
   }
 #endif
 
+  base::TimeTicks start_time = base::TimeTicks::Now();
+  base::TimeDelta elapsed;
+  bool is_break = false;
   error::Error error = error::kNoError;
-  int commands_processed = 0;
-  while (commands_processed < commands_per_update_ &&
-         !parser_->IsEmpty()) {
-    error = parser_->ProcessCommand();
+  do {
+    int commands_processed = 0;
+    while (commands_processed < commands_per_update_ &&
+           !parser_->IsEmpty()) {
+      error = parser_->ProcessCommand();
 
-    // TODO(piman): various classes duplicate various pieces of state, leading
-    // to needlessly complex update logic. It should be possible to simply share
-    // the state across all of them.
-    command_buffer_->SetGetOffset(static_cast<int32>(parser_->get()));
+      // TODO(piman): various classes duplicate various pieces of state, leading
+      // to needlessly complex update logic. It should be possible to simply
+      // share the state across all of them.
+      command_buffer_->SetGetOffset(static_cast<int32>(parser_->get()));
 
-    if (error == error::kWaiting || error == error::kYield) {
-      break;
-    } else if (error::IsError(error)) {
-      command_buffer_->SetParseError(error);
-      return;
+      if (error == error::kWaiting || error == error::kYield) {
+        is_break = true;
+        break;
+      } else if (error::IsError(error)) {
+        command_buffer_->SetParseError(error);
+        return;
+      }
+
+      if (unscheduled_count_ > 0) {
+        is_break = true;
+        break;
+      }
+
+      ++commands_processed;
+      if (command_processed_callback_.get()) {
+        command_processed_callback_->Run();
+      }
     }
-
-    if (unscheduled_count_ > 0)
-      break;
-
-    ++commands_processed;
-    if (command_processed_callback_.get()) {
-      command_processed_callback_->Run();
-    }
-  }
+    elapsed = base::TimeTicks::Now() - start_time;
+  } while(!is_break &&
+          !parser_->IsEmpty() &&
+          elapsed.InMicroseconds() < kMinimumSchedulerQuantumMicros);
 
   if (unscheduled_count_ == 0 &&
       error != error::kWaiting &&
       !parser_->IsEmpty()) {
     ScheduleProcessCommands();
   }
 }
 
 void GpuScheduler::SetScheduled(bool scheduled) {
+  TRACE_EVENT2("gpu", "GpuScheduler:SetScheduled", "scheduled", scheduled,
+               "unscheduled_count_", unscheduled_count_);
   if (scheduled) {
     --unscheduled_count_;
     DCHECK_GE(unscheduled_count_, 0);
 
     if (unscheduled_count_ == 0) {
       if (scheduled_callback_.get())
         scheduled_callback_->Run();
 
       ScheduleProcessCommands();
     }
@@ skipping 51 matching lines @@
   command_processed_callback_.reset(callback);
 }
 
 void GpuScheduler::ScheduleProcessCommands() {
   MessageLoop::current()->PostTask(
       FROM_HERE,
       method_factory_.NewRunnableMethod(&GpuScheduler::ProcessCommands));
 }
 
 }  // namespace gpu