content/gpu: Simplify stub scheduling.

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/message_loop/message_loop.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/command_buffer/service/logger.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_fence.h"
 #include "ui/gl/gl_switches.h"
 
-#if defined(OS_WIN)
-#include "base/win/windows_version.h"
-#endif
-
 using ::base::SharedMemory;
 
 namespace gpu {
 
 #if defined(OS_WIN)
 const int64 kRescheduleTimeOutDelay = 1000;
 #endif
 
 GpuScheduler::GpuScheduler(CommandBufferServiceBase* command_buffer,
                            AsyncAPIInterface* handler,
                            gles2::GLES2Decoder* decoder)
     : command_buffer_(command_buffer),
       handler_(handler),
       decoder_(decoder),
       unscheduled_count_(0),

[piman, 2015/09/16 23:48:42]

You still need an initializer for scheduled_.

[sunnyps, 2015/09/17 00:04:53]

Done.

-      rescheduled_count_(0),
-      was_preempted_(false),
-      reschedule_task_factory_(this) {}
+      was_preempted_(false) {}
 
-GpuScheduler::~GpuScheduler() {
-}
+GpuScheduler::~GpuScheduler() {}
 
 void GpuScheduler::PutChanged() {
   TRACE_EVENT1(
      "gpu", "GpuScheduler:PutChanged",
      "decoder", decoder_ ? decoder_->GetLogger()->GetLogPrefix() : "None");
 
   CommandBuffer::State state = command_buffer_->GetLastState();
 
   // If there is no parser, exit.
   if (!parser_.get()) {
@@ skipping 52 matching lines @@
     decoder_->EndDecoding();
     decoder_->AddProcessingCommandsTime(base::TimeTicks::Now() - begin_time);
   }
 }
 
 void GpuScheduler::SetScheduled(bool scheduled) {
   TRACE_EVENT2("gpu", "GpuScheduler:SetScheduled", "this", this,
                "new unscheduled_count_",
                unscheduled_count_ + (scheduled? -1 : 1));
   if (scheduled) {
-    // If the scheduler was rescheduled after a timeout, ignore the subsequent
-    // calls to SetScheduled when they eventually arrive until they are all
-    // accounted for.
-    if (rescheduled_count_ > 0) {
-      --rescheduled_count_;
-      return;
-    } else {
-      --unscheduled_count_;
-    }
-
-    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 (!scheduling_changed_callback_.is_null())
+    --unscheduled_count_;
+    if (unscheduled_count_ == 0 && !scheduling_changed_callback_.is_null())
         scheduling_changed_callback_.Run(true);
-    }
   } else {
     ++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.
-        base::MessageLoop::current()->PostDelayedTask(
-            FROM_HERE,
-            base::Bind(&GpuScheduler::RescheduleTimeOut,
-                       reschedule_task_factory_.GetWeakPtr()),
-            base::TimeDelta::FromMilliseconds(kRescheduleTimeOutDelay));
-      }
-#endif
-      if (!scheduling_changed_callback_.is_null())
+    if (unscheduled_count_ == 1 && !scheduling_changed_callback_.is_null())
         scheduling_changed_callback_.Run(false);
-    }
   }
+  DCHECK_GE(unscheduled_count_, 0);
 }
 
 bool GpuScheduler::IsScheduled() {
   return unscheduled_count_ == 0;
 }
 
 bool GpuScheduler::HasMoreWork() {
   return (decoder_ && decoder_->ProcessPendingQueries(false)) ||
          HasMoreIdleWork();
 }
@@ skipping 64 matching lines @@
 bool GpuScheduler::HasMoreIdleWork() {
   return (decoder_ && decoder_->HasMoreIdleWork());
 }
 
 void GpuScheduler::PerformIdleWork() {
   if (!decoder_)
     return;
   decoder_->PerformIdleWork();
 }
 
-void GpuScheduler::RescheduleTimeOut() {
-  int new_count = unscheduled_count_ + rescheduled_count_;
-
-  rescheduled_count_ = 0;
-
-  while (unscheduled_count_)
-    SetScheduled(true);
-
-  rescheduled_count_ = new_count;
-}
-
 }  // namespace gpu