GPU: Only allow the UI channel to preempt if all stubs are scheduled.

gpu/command_buffer/service/gpu_scheduler.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug/trace_event.h"
@@ skipping 118 matching lines @@
 
     DCHECK_GE(unscheduled_count_, 0);
 
     if (unscheduled_count_ == 0) {
       TRACE_EVENT_ASYNC_END1("gpu", "ProcessingSwap", this,
                              "GpuScheduler", this);
       // When the scheduler transitions from the unscheduled to the scheduled
       // state, cancel the task that would reschedule it after a timeout.
       reschedule_task_factory_.InvalidateWeakPtrs();
 
-      if (!scheduled_callback_.is_null())
-        scheduled_callback_.Run();
+      if (!scheduling_changed_callback_.is_null())
+        scheduling_changed_callback_.Run(true);
     }
   } else {
-    if (unscheduled_count_ == 0) {
+    ++unscheduled_count_;
+    if (unscheduled_count_ == 1) {
       TRACE_EVENT_ASYNC_BEGIN1("gpu", "ProcessingSwap", this,
                                "GpuScheduler", this);
 #if defined(OS_WIN)
       if (base::win::GetVersion() < base::win::VERSION_VISTA) {
         // When the scheduler transitions from scheduled to unscheduled, post a
         // delayed task that it will force it back into a scheduled state after
         // a timeout. This should only be necessary on pre-Vista.
         MessageLoop::current()->PostDelayedTask(
             FROM_HERE,
             base::Bind(&GpuScheduler::RescheduleTimeOut,
                        reschedule_task_factory_.GetWeakPtr()),
             base::TimeDelta::FromMilliseconds(kRescheduleTimeOutDelay));
       }
 #endif
+      if (!scheduling_changed_callback_.is_null())
+        scheduling_changed_callback_.Run(false);
     }
-
-    ++unscheduled_count_;
   }
 }
 
 bool GpuScheduler::IsScheduled() {
   return unscheduled_count_ == 0;
 }
 
 bool GpuScheduler::HasMoreWork() {
   return !unschedule_fences_.empty() ||
          (decoder_ && decoder_->ProcessPendingQueries());
 }
 
-void GpuScheduler::SetScheduledCallback(
-    const base::Closure& scheduled_callback) {
-  scheduled_callback_ = scheduled_callback;
+void GpuScheduler::SetSchedulingChangedCallback(
+    const SchedulingChangedCallback& callback) {
+  scheduling_changed_callback_ = callback;
 }
 
 Buffer GpuScheduler::GetSharedMemoryBuffer(int32 shm_id) {
   return command_buffer_->GetTransferBuffer(shm_id);
 }
 
 void GpuScheduler::set_token(int32 token) {
   command_buffer_->SetToken(token);
 }
 
@@ skipping 94 matching lines @@
 }
 
 GpuScheduler::UnscheduleFence::UnscheduleFence(
     gfx::GLFence* fence_, base::Closure task_): fence(fence_), task(task_) {
 }
 
 GpuScheduler::UnscheduleFence::~UnscheduleFence() {
 }
 
 }  // namespace gpu