content/child/scheduler/scheduler_helper.h

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CONTENT_CHILD_SCHEDULER_SCHEDULER_HELPER_H_
   6 #define CONTENT_CHILD_SCHEDULER_SCHEDULER_HELPER_H_
   7
   8 #include "cc/test/test_now_source.h"
   9 #include "content/child/scheduler/cancelable_closure_holder.h"
  10 #include "content/child/scheduler/single_thread_idle_task_runner.h"
  11 #include "content/child/scheduler/task_queue_manager.h"
  12
  13 namespace content {
  14
  15 class PrioritizingTaskQueueSelector;
  16 class NestableSingleThreadTaskRunner;
  17
  18 // Common scheduler functionality for Default and Idle tasks.
  19 class CONTENT_EXPORT SchedulerHelper {
  20  public:
  21   // Used to by scheduler implementations to customize idle behaviour.
  22   class CONTENT_EXPORT SchedulerHelperDelegate {
  23    public:
  24     SchedulerHelperDelegate();
  25     virtual ~SchedulerHelperDelegate();
  26
  27     // If it's ok to enter a Long Idle period, return true.  Otherwise return
  28     // false and set next_long_idle_period_delay_out so we know when to try
  29     // again.
  30     virtual bool CanEnterLongIdlePeriod(
  31         base::TimeTicks now,
  32         base::TimeDelta* next_long_idle_period_delay_out) = 0;
  33
  34    private:
  35     DISALLOW_COPY_AND_ASSIGN(SchedulerHelperDelegate);
  36   };
  37
  38   // NOTE |total_task_queue_count| must be >= TASK_QUEUE_COUNT.
  39   // Category strings must have application lifetime (statics or
  40   // literals). They may not include " chars.
  41   SchedulerHelper(
  42       scoped_refptr<NestableSingleThreadTaskRunner> main_task_runner,
  43       SchedulerHelperDelegate* scheduler_helper_delegate,
  44       const char* tracing_category,
  45       const char* disabled_by_default_tracing_category,
  46       size_t total_task_queue_count);
  47   ~SchedulerHelper();
  48
  49   // Returns the default task runner.
  50   scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner();
  51
  52   // Returns the idle task runner. Tasks posted to this runner may be reordered
  53   // relative to other task types and may be starved for an arbitrarily long
  54   // time if no idle time is available.
  55   scoped_refptr<SingleThreadIdleTaskRunner> IdleTaskRunner();
  56
  57   // Returns the control task runner.  Tasks posted to this runner are executed
  58   // with the highest priority. Care must be taken to avoid starvation of other
  59   // task queues.
  60   scoped_refptr<base::SingleThreadTaskRunner> ControlTaskRunner();
  61
  62   // Returns true if a currently running idle task could exceed its deadline
  63   // without impacting user experience too much. This should only be used if
  64   // there is a task which cannot be pre-empted and is likely to take longer
  65   // than the largest expected idle task deadline. It should NOT be polled to
  66   // check whether more work can be performed on the current idle task after
  67   // its deadline has expired - post a new idle task for the continuation of the
  68   // work in this case.
  69   // Must be called from the thread this class was created on.
  70   bool CanExceedIdleDeadlineIfRequired() const;
  71
  72   // Adds or removes a task observer from the scheduler. The observer will be
  73   // notified before and after every executed task. These functions can only be
  74   // called on the thread this class was created on.
  75   void AddTaskObserver(base::MessageLoop::TaskObserver* task_observer);
  76   void RemoveTaskObserver(base::MessageLoop::TaskObserver* task_observer);
  77
  78   // Shuts down the scheduler by dropping any remaining pending work in the work
  79   // queues. After this call any work posted to the task runners will be
  80   // silently dropped.
  81   void Shutdown();
  82
  83   // Returns true if Shutdown() has been called. Otherwise returns false.
  84   bool IsShutdown() const { return !task_queue_manager_.get(); }
  85
  86   // Keep SchedulerHelper::TaskQueueIdToString in sync with this enum.
  87   enum QueueId {
  88     DEFAULT_TASK_QUEUE,
  89     IDLE_TASK_QUEUE,
  90     CONTROL_TASK_QUEUE,
  91     CONTROL_TASK_AFTER_WAKEUP_QUEUE,
  92     // Must be the last entry.
  93     TASK_QUEUE_COUNT,
  94   };
  95
  96   // Keep SchedulerHelper::IdlePeriodStateToString in sync with this enum.
  97   enum class IdlePeriodState {
  98     NOT_IN_IDLE_PERIOD,
  99     IN_SHORT_IDLE_PERIOD,
 100     IN_LONG_IDLE_PERIOD,
 101     IN_LONG_IDLE_PERIOD_WITH_MAX_DEADLINE,
 102     ENDING_LONG_IDLE_PERIOD
 103   };
 104
 105   static const char* TaskQueueIdToString(QueueId queue_id);
 106   static const char* IdlePeriodStateToString(IdlePeriodState state);
 107
 108   // The maximum length of an idle period.
 109   static const int kMaximumIdlePeriodMillis = 50;
 110
 111   // The minimum delay to wait between retrying to initiate a long idle time.
 112   static const int kRetryInitiateLongIdlePeriodDelayMillis = 1;
 113
 114   // IdleTaskDeadlineSupplier Implementation:
 115   void CurrentIdleTaskDeadlineCallback(base::TimeTicks* deadline_out) const;
 116
 117   // Returns the new idle period state for the next long idle period. Fills in
 118   // |next_long_idle_period_delay_out| with the next time we should try to
 119   // initiate the next idle period.
 120   IdlePeriodState ComputeNewLongIdlePeriodState(
 121       const base::TimeTicks now,
 122       base::TimeDelta* next_long_idle_period_delay_out);
 123
 124   // Initiate a long idle period.
 125   void InitiateLongIdlePeriod();
 126   void InitiateLongIdlePeriodAfterWakeup();
 127
 128   // Start and end an idle period. If |post_end_idle_period| is true, it will
 129   // post a delayed EndIdlePeriod scheduled to occur at |idle_period_deadline|.
 130   void StartIdlePeriod(IdlePeriodState new_idle_period_state,
 131                        base::TimeTicks now,
 132                        base::TimeTicks idle_period_deadline,
 133                        bool post_end_idle_period);
 134
 135   void EndIdlePeriod();
 136
 137   // Returns true if |state| represents being within an idle period state.
 138   static bool IsInIdlePeriod(IdlePeriodState state);
 139
 140   void CheckOnValidThread() const {
 141     DCHECK(thread_checker_.CalledOnValidThread());
 142   }
 143
 144   // Accessor methods.
 145   base::TimeTicks Now() const;
 146   IdlePeriodState SchedulerIdlePeriodState() const;
 147   PrioritizingTaskQueueSelector* SchedulerTaskQueueSelector() const;
 148   TaskQueueManager* SchedulerTaskQueueManager() const;
 149
 150   // Test helpers.
 151   void SetTimeSourceForTesting(scoped_refptr<cc::TestNowSource> time_source);
 152   void SetWorkBatchSizeForTesting(size_t work_batch_size);
 153
 154  private:
 155   friend class SchedulerHelperTest;
 156
 157   base::ThreadChecker thread_checker_;
 158   scoped_ptr<PrioritizingTaskQueueSelector> task_queue_selector_;
 159   scoped_ptr<TaskQueueManager> task_queue_manager_;
 160
 161   CancelableClosureHolder end_idle_period_closure_;
 162   CancelableClosureHolder initiate_next_long_idle_period_closure_;
 163   CancelableClosureHolder initiate_next_long_idle_period_after_wakeup_closure_;
 164
 165   IdlePeriodState idle_period_state_;
 166   SchedulerHelperDelegate* scheduler_helper_delegate_;  // NOT OWNED
 167
 168   scoped_refptr<base::SingleThreadTaskRunner> control_task_runner_;
 169   scoped_refptr<base::SingleThreadTaskRunner> control_task_after_wakeup_runner_;
 170   scoped_refptr<base::SingleThreadTaskRunner> default_task_runner_;
 171   scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_;
 172
 173   base::TimeTicks idle_period_deadline_;
 174   scoped_refptr<cc::TestNowSource> time_source_;
 175
 176   const char* tracing_category_;
 177   const char* disabled_by_default_tracing_category_;
 178
 179   base::WeakPtr<SchedulerHelper> weak_scheduler_ptr_;
 180   base::WeakPtrFactory<SchedulerHelper> weak_factory_;
 181
 182   DISALLOW_COPY_AND_ASSIGN(SchedulerHelper);
 183 };
 184
 185 }  // namespace content
 186
 187 #endif  // CONTENT_CHILD_SCHEDULER_SCHEDULER_HELPER_H_