cc/test/ordered_simple_task_runner.h

   1 // Copyright 2014 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 CC_TEST_ORDERED_SIMPLE_TASK_RUNNER_H_
   6 #define CC_TEST_ORDERED_SIMPLE_TASK_RUNNER_H_
   7
   8 #include <limits>
   9 #include <set>
  10 #include <vector>
  11
  12 #include "base/basictypes.h"
  13 #include "base/compiler_specific.h"
  14 #include "base/logging.h"
  15 #include "base/test/test_simple_task_runner.h"
  16 #include "base/trace_event/trace_event.h"
  17 #include "cc/test/test_now_source.h"
  18
  19 namespace cc {
  20
  21 // Subclass of TestPendingTask which has a unique ID for every task, supports
  22 // being used inside a std::set and has debug tracing support.
  23 class TestOrderablePendingTask : public base::TestPendingTask {
  24  public:
  25   TestOrderablePendingTask();
  26   TestOrderablePendingTask(const tracked_objects::Location& location,
  27                            const base::Closure& task,
  28                            base::TimeTicks post_time,
  29                            base::TimeDelta delay,
  30                            TestNestability nestability);
  31   ~TestOrderablePendingTask();
  32
  33   // operators needed by std::set and comparison
  34   bool operator==(const TestOrderablePendingTask& other) const;
  35   bool operator<(const TestOrderablePendingTask& other) const;
  36
  37   // debug tracing functions
  38   scoped_refptr<base::debug::ConvertableToTraceFormat> AsValue() const;
  39   void AsValueInto(base::debug::TracedValue* state) const;
  40
  41  private:
  42   static size_t task_id_counter;
  43   const size_t task_id_;
  44 };
  45
  46 // This runs pending tasks based on task's post_time + delay.
  47 // We should not execute a delayed task sooner than some of the queued tasks
  48 // which don't have a delay even though it is queued early.
  49 class OrderedSimpleTaskRunner : public base::SingleThreadTaskRunner {
  50  public:
  51   OrderedSimpleTaskRunner();
  52   OrderedSimpleTaskRunner(scoped_refptr<TestNowSource> now_src,
  53                           bool advance_now);
  54
  55   // base::TestSimpleTaskRunner implementation:
  56   bool PostDelayedTask(const tracked_objects::Location& from_here,
  57                        const base::Closure& task,
  58                        base::TimeDelta delay) override;
  59   bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here,
  60                                   const base::Closure& task,
  61                                   base::TimeDelta delay) override;
  62
  63   bool RunsTasksOnCurrentThread() const override;
  64
  65   // Set a maximum number of tasks to run at once. Useful as a timeout to
  66   // prevent infinite task loops.
  67   static const size_t kAbsoluteMaxTasks;
  68   void SetRunTaskLimit(size_t max_tasks) { max_tasks_ = max_tasks; }
  69   void ClearRunTaskLimit() { max_tasks_ = kAbsoluteMaxTasks; }
  70
  71   // Allow task runner to advance now when running tasks.
  72   void SetAutoAdvanceNowToPendingTasks(bool advance_now) {
  73     advance_now_ = advance_now;
  74   }
  75
  76   bool HasPendingTasks() const;
  77   base::TimeTicks NextTaskTime();
  78   base::TimeDelta DelayToNextTaskTime();
  79
  80   // Run tasks while the callback returns true or too many tasks have been run.
  81   // Returns true if there are still pending tasks left.
  82   bool RunTasksWhile(base::Callback<bool(void)> condition);
  83
  84   // Run tasks while *all* of the callbacks return true or too many tasks have
  85   // been run. Exits on the *first* condition which returns false, skipping
  86   // calling all remaining conditions. Conditions can have side effects,
  87   // including modifying the task queue.
  88   // Returns true if there are still pending tasks left.
  89   bool RunTasksWhile(const std::vector<base::Callback<bool(void)>>& conditions);
  90
  91   // Convenience functions to run tasks with common conditions.
  92
  93   // Run tasks which existed at the start of this call.
  94   // Return code indicates tasks still exist to run.
  95   bool RunPendingTasks();
  96   // Keep running tasks until no tasks are left.
  97   // Return code indicates tasks still exist to run which also indicates if
  98   // runner reached idle.
  99   bool RunUntilIdle();
 100   // Keep running tasks until given time period.
 101   // Return code indicates tasks still exist to run.
 102   bool RunUntilTime(base::TimeTicks time);
 103   bool RunForPeriod(base::TimeDelta period);
 104
 105   // base::debug tracing functionality
 106   scoped_refptr<base::debug::ConvertableToTraceFormat> AsValue() const;
 107   virtual void AsValueInto(base::debug::TracedValue* state) const;
 108
 109   // Common conditions to run for, exposed publicly to allow external users to
 110   // use their own combinations.
 111   // -------------------------------------------------------------------------
 112
 113   // Keep running until the given number of tasks have run.
 114   // You generally shouldn't use this check as it will cause your tests to fail
 115   // when code is changed adding a new task. It is useful as a "timeout" type
 116   // solution.
 117   base::Callback<bool(void)> TaskRunCountBelow(size_t max_tasks);
 118
 119   // Keep running until a task which didn't exist initially would run.
 120   base::Callback<bool(void)> TaskExistedInitially();
 121
 122   // Stop running tasks when NextTaskTime() >= stop_at
 123   base::Callback<bool(void)> NowBefore(base::TimeTicks stop_at);
 124
 125   // Advance Now() to the next task to run.
 126   base::Callback<bool(void)> AdvanceNow();
 127
 128  protected:
 129   static bool TaskRunCountBelowCallback(size_t max_tasks, size_t* task_run);
 130   bool TaskExistedInitiallyCallback(
 131       const std::set<TestOrderablePendingTask>& existing_tasks);
 132   bool NowBeforeCallback(base::TimeTicks stop_at);
 133   bool AdvanceNowCallback();
 134
 135   ~OrderedSimpleTaskRunner() override;
 136
 137   base::ThreadChecker thread_checker_;
 138
 139   bool advance_now_;
 140   scoped_refptr<TestNowSource> now_src_;
 141
 142   size_t max_tasks_;
 143
 144   bool inside_run_tasks_until_;
 145   std::set<TestOrderablePendingTask> pending_tasks_;
 146
 147  private:
 148   DISALLOW_COPY_AND_ASSIGN(OrderedSimpleTaskRunner);
 149 };
 150
 151 }  // namespace cc
 152
 153 #endif  // CC_TEST_ORDERED_SIMPLE_TASK_RUNNER_H_