Revert 93066 - Execute all GL commands up to the put offset reported by a each flush.This means g...

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 gpu {
 
-GpuScheduler* GpuScheduler::Create(CommandBuffer* command_buffer,
-                                   SurfaceManager* surface_manager,
-                                   gles2::ContextGroup* group) {
+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) || defined(TOUCH_UI)
+      swap_buffers_count_(0),
+      acknowledged_swap_buffers_count_(0),
+#endif
+      method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   DCHECK(command_buffer);
-
-  gles2::GLES2Decoder* decoder =
-      gles2::GLES2Decoder::Create(surface_manager, group);
-
-  GpuScheduler* scheduler = new GpuScheduler(command_buffer,
-                                             decoder,
-                                             NULL);
-
-  decoder->set_engine(scheduler);
-
+  decoder_.reset(gles2::GLES2Decoder::Create(surface_manager, group));
+  decoder_->set_engine(this);
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableGPUServiceLogging)) {
-    decoder->set_debug(true);
+    decoder_->set_debug(true);
   }
-
-  return scheduler;
 }
 
-GpuScheduler* GpuScheduler::CreateForTests(CommandBuffer* command_buffer,
-                                           gles2::GLES2Decoder* decoder,
-                                           CommandParser* parser) {
+GpuScheduler::GpuScheduler(CommandBuffer* command_buffer,
+                           gles2::GLES2Decoder* decoder,
+                           CommandParser* parser,
+                           int commands_per_update)
+    : command_buffer_(command_buffer),
+      commands_per_update_(commands_per_update),
+      unscheduled_count_(0),
+#if defined(OS_MACOSX) || defined(TOUCH_UI)
+      swap_buffers_count_(0),
+      acknowledged_swap_buffers_count_(0),
+#endif
+      method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
   DCHECK(command_buffer);
-  GpuScheduler* scheduler = new GpuScheduler(command_buffer,
-                                             decoder,
-                                             parser);
-
-  return scheduler;
+  decoder_.reset(decoder);
+  parser_.reset(parser);
 }
 
 GpuScheduler::~GpuScheduler() {
   Destroy();
 }
 
 bool GpuScheduler::InitializeCommon(
     const scoped_refptr<gfx::GLSurface>& surface,
     const scoped_refptr<gfx::GLContext>& context,
     const gfx::Size& size,
     const gles2::DisallowedExtensions& disallowed_extensions,
     const char* allowed_extensions,
     const std::vector<int32>& attribs) {
   DCHECK(context);
 
   if (!context->MakeCurrent(surface))
     return false;
 
 #if !defined(OS_MACOSX)
   // Set up swap interval for onscreen contexts.
   if (!surface->IsOffscreen()) {
     if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kDisableGpuVsync))
       context->SetSwapInterval(0);
     else
       context->SetSwapInterval(1);
   }
 #endif
 
+  // Do not limit to a certain number of commands before scheduling another
+  // update when rendering onscreen.
+  if (!surface->IsOffscreen())
+    commands_per_update_ = INT_MAX;
+
   // Map the ring buffer and create the parser.
   Buffer ring_buffer = command_buffer_->GetRingBuffer();
   if (ring_buffer.ptr) {
     parser_.reset(new CommandParser(ring_buffer.ptr,
                                     ring_buffer.size,
                                     0,
                                     ring_buffer.size,
                                     0,
                                     decoder_.get()));
   } else {
@@ skipping 37 matching lines @@
   else
     return decoder_->SetParent(NULL, 0);
 }
 
 #if defined(OS_MACOSX) || defined(TOUCH_UI)
 namespace {
 const unsigned int kMaxOutstandingSwapBuffersCallsPerOnscreenContext = 1;
 }
 #endif
 
-void GpuScheduler::PutChanged() {
+void GpuScheduler::PutChanged(bool sync) {
   TRACE_EVENT1("gpu", "GpuScheduler:PutChanged", "this", this);
-
-  DCHECK(IsScheduled());
-
   CommandBuffer::State state = command_buffer_->GetState();
   parser_->set_put(state.put_offset);
+
+  if (sync)
+    ProcessCommands();
+  else
+    ScheduleProcessCommands();
+}
+
+void GpuScheduler::ProcessCommands() {
+  TRACE_EVENT1("gpu", "GpuScheduler:ProcessCommands", "this", this);
+  CommandBuffer::State state = command_buffer_->GetState();
   if (state.error != error::kNoError)
     return;
 
+  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_->SetContextLostReason(decoder_->GetContextLostReason());
       command_buffer_->SetParseError(error::kLostContext);
       return;
     }
   }
 
 #if defined(OS_MACOSX)
   bool do_rate_limiting = surface_.get() != NULL;
 #elif defined(TOUCH_UI)
   bool do_rate_limiting = back_surface_.get() != NULL;
 #endif
 
 #if defined(OS_MACOSX) || defined(TOUCH_UI)
   // Don't swamp the browser process with SwapBuffers calls it can't handle.
-  DCHECK(!do_rate_limiting ||
-         swap_buffers_count_ - acknowledged_swap_buffers_count_ == 0);
+  if (do_rate_limiting &&
+      swap_buffers_count_ - acknowledged_swap_buffers_count_ >=
+      kMaxOutstandingSwapBuffersCallsPerOnscreenContext) {
+    TRACE_EVENT0("gpu", "EarlyOut_OSX_Throttle");
+    // 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;
-  while (!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::IsError(error)) {
-      command_buffer_->SetContextLostReason(decoder_->GetContextLostReason());
-      command_buffer_->SetParseError(error);
-      return;
+      if (error == error::kWaiting || error == error::kYield) {
+        is_break = true;
+        break;
+      } else if (error::IsError(error)) {
+        command_buffer_->SetContextLostReason(decoder_->GetContextLostReason());
+        command_buffer_->SetParseError(error);
+        return;
+      }
+
+      if (unscheduled_count_ > 0) {
+        is_break = true;
+        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 (command_processed_callback_.get())
-      command_processed_callback_->Run();
-
-    if (unscheduled_count_ > 0)
-      return;
+  if (unscheduled_count_ == 0 &&
+      error != error::kWaiting &&
+      !parser_->IsEmpty()) {
+    ScheduleProcessCommands();
   }
 }
 
 void GpuScheduler::SetScheduled(bool scheduled) {
   TRACE_EVENT2("gpu", "GpuScheduler:SetScheduled", "this", this,
                "new unscheduled_count_",
                unscheduled_count_ + (scheduled? -1 : 1));
   if (scheduled) {
     --unscheduled_count_;
     DCHECK_GE(unscheduled_count_, 0);
 
-    if (unscheduled_count_ == 0 && scheduled_callback_.get())
-      scheduled_callback_->Run();
+    if (unscheduled_count_ == 0) {
+      if (scheduled_callback_.get())
+        scheduled_callback_->Run();
+
+      ScheduleProcessCommands();
+    }
   } else {
     ++unscheduled_count_;
   }
 }
 
 bool GpuScheduler::IsScheduled() {
   return unscheduled_count_ == 0;
 }
 
 void GpuScheduler::SetScheduledCallback(Callback0::Type* scheduled_callback) {
@@ skipping 45 matching lines @@
     Callback0::Type* callback) {
   command_processed_callback_.reset(callback);
 }
 
 void GpuScheduler::SetTokenCallback(
     const base::Callback<void(int32)>& callback) {
   DCHECK(set_token_callback_.is_null());
   set_token_callback_ = callback;
 }
 
-GpuScheduler::GpuScheduler(CommandBuffer* command_buffer,
-                           gles2::GLES2Decoder* decoder,
-                           CommandParser* parser)
-    : command_buffer_(command_buffer),
-      decoder_(decoder),
-      parser_(parser),
-      unscheduled_count_(0),
-#if defined(OS_MACOSX) || defined(TOUCH_UI)
-      swap_buffers_count_(0),
-      acknowledged_swap_buffers_count_(0),
-#endif
-      method_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+void GpuScheduler::ScheduleProcessCommands() {
+  MessageLoop::current()->PostTask(
+      FROM_HERE,
+      method_factory_.NewRunnableMethod(&GpuScheduler::ProcessCommands));
 }
 
 void GpuScheduler::WillResize(gfx::Size size) {
   if (wrapped_resize_callback_.get()) {
     wrapped_resize_callback_->Run(size);
   }
 }
 
 }  // namespace gpu