content/gpu: Simplify stub scheduling.

gpu/command_buffer/service/gpu_scheduler.h

 // 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.
 
 #ifndef GPU_COMMAND_BUFFER_SERVICE_GPU_SCHEDULER_H_
 #define GPU_COMMAND_BUFFER_SERVICE_GPU_SCHEDULER_H_
 
 #include <queue>
 
 #include "base/atomic_ref_count.h"
@@ skipping 47 matching lines @@
 
   ~GpuScheduler() override;
 
   void PutChanged();
 
   void SetPreemptByFlag(scoped_refptr<PreemptionFlag> flag) {
     preemption_flag_ = flag;
   }
 
   // Sets whether commands should be processed by this scheduler. Setting to
-  // false unschedules. Setting to true reschedules. Whether or not the
-  // scheduler is currently scheduled is "reference counted". Every call with
-  // false must eventually be paired by a call with true.
-  void SetScheduled(bool is_scheduled);
+  // false unschedules. Setting to true reschedules.
+  void SetScheduled(bool scheduled);
 
-  // Returns whether the scheduler is currently able to process more commands.
-  bool IsScheduled();
+  bool scheduled() const { return scheduled_; }
 
   // Returns whether the scheduler needs to be polled again in the future to
   // process pending queries.
   bool HasPendingQueries() const;
 
   // Process pending queries and return. HasPendingQueries() can be used to
   // determine if there's more pending queries after this has been called.
   void ProcessPendingQueries();
 
   typedef base::Callback<void(bool /* scheduled */)> SchedulingChangedCallback;
@@ skipping 17 matching lines @@
 
   // Perform some idle work and return. HasMoreIdleWork() can be used to
   // determine if there's more idle work do be done after this has been called.
   void PerformIdleWork();
 
   CommandParser* parser() const {
     return parser_.get();
   }
 
  private:
-  // Artificially reschedule if the scheduler is still unscheduled after a
-  // timeout.
-  void RescheduleTimeOut();
-
   bool IsPreempted();
 
   // The GpuScheduler holds a weak reference to the CommandBuffer. The
   // CommandBuffer owns the GpuScheduler and holds a strong reference to it
   // through the ProcessCommands callback.
   CommandBufferServiceBase* command_buffer_;
 
   // The parser uses this to execute commands.
   AsyncAPIInterface* handler_;
 
   // Does not own decoder. TODO(apatrick): The GpuScheduler shouldn't need a
   // pointer to the decoder, it is only used to initialize the CommandParser,
   // which could be an argument to the constructor, and to determine the
   // reason for context lost.
   gles2::GLES2Decoder* decoder_;
 
   // TODO(apatrick): The GpuScheduler currently creates and owns the parser.
   // This should be an argument to the constructor.
   scoped_ptr<CommandParser> parser_;
 
-  // Greater than zero if this is waiting to be rescheduled before continuing.
-  int unscheduled_count_;
-
-  // The number of times this scheduler has been artificially rescheduled on
-  // account of a timeout.
-  int rescheduled_count_;
+  // Whether the scheduler is currently able to process more commands.
+  bool scheduled_;
 
   SchedulingChangedCallback scheduling_changed_callback_;
   base::Closure descheduled_callback_;
   base::Closure command_processed_callback_;
 
   // If non-NULL and |preemption_flag_->IsSet()|, exit PutChanged early.
   scoped_refptr<PreemptionFlag> preemption_flag_;
   bool was_preempted_;
 
-  // A factory for outstanding rescheduling tasks that is invalidated whenever
-  // the scheduler is rescheduled.
-  base::WeakPtrFactory<GpuScheduler> reschedule_task_factory_;
-
   DISALLOW_COPY_AND_ASSIGN(GpuScheduler);
 };
 
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_GPU_SCHEDULER_H_