cc/test/scheduler_test_common.h

   1 // Copyright 2011 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_SCHEDULER_TEST_COMMON_H_
   6 #define CC_TEST_SCHEDULER_TEST_COMMON_H_
   7
   8 #include <string>
   9
  10 #include "base/basictypes.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "base/time/time.h"
  13 #include "cc/scheduler/compositor_timing_history.h"
  14 #include "cc/scheduler/scheduler.h"
  15 #include "cc/test/ordered_simple_task_runner.h"
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 namespace cc {
  19
  20 class RenderingStatsInstrumentation;
  21
  22 class FakeTimeSourceClient : public TimeSourceClient {
  23  public:
  24   FakeTimeSourceClient() : tick_called_(false) {}
  25   void Reset() { tick_called_ = false; }
  26   bool TickCalled() const { return tick_called_; }
  27
  28   // TimeSourceClient implementation.
  29   void OnTimerTick() override;
  30
  31  protected:
  32   bool tick_called_;
  33
  34  private:
  35   DISALLOW_COPY_AND_ASSIGN(FakeTimeSourceClient);
  36 };
  37
  38 class FakeDelayBasedTimeSource : public DelayBasedTimeSource {
  39  public:
  40   static scoped_ptr<FakeDelayBasedTimeSource> Create(
  41       base::TimeDelta interval,
  42       base::SingleThreadTaskRunner* task_runner) {
  43     return make_scoped_ptr(new FakeDelayBasedTimeSource(interval, task_runner));
  44   }
  45
  46   ~FakeDelayBasedTimeSource() override {}
  47
  48   void SetNow(base::TimeTicks time) { now_ = time; }
  49   base::TimeTicks Now() const override;
  50
  51  protected:
  52   FakeDelayBasedTimeSource(base::TimeDelta interval,
  53                            base::SingleThreadTaskRunner* task_runner)
  54       : DelayBasedTimeSource(interval, task_runner) {}
  55
  56   base::TimeTicks now_;
  57
  58  private:
  59   DISALLOW_COPY_AND_ASSIGN(FakeDelayBasedTimeSource);
  60 };
  61
  62 class TestDelayBasedTimeSource : public DelayBasedTimeSource {
  63  public:
  64   static scoped_ptr<TestDelayBasedTimeSource> Create(
  65       base::SimpleTestTickClock* now_src,
  66       base::TimeDelta interval,
  67       OrderedSimpleTaskRunner* task_runner) {
  68     return make_scoped_ptr(
  69         new TestDelayBasedTimeSource(now_src, interval, task_runner));
  70   }
  71
  72   ~TestDelayBasedTimeSource() override;
  73
  74  protected:
  75   TestDelayBasedTimeSource(base::SimpleTestTickClock* now_src,
  76                            base::TimeDelta interval,
  77                            OrderedSimpleTaskRunner* task_runner);
  78
  79   // Overridden from DelayBasedTimeSource
  80   base::TimeTicks Now() const override;
  81   std::string TypeString() const override;
  82
  83   // Not owned.
  84   base::SimpleTestTickClock* now_src_;
  85
  86  private:
  87   DISALLOW_COPY_AND_ASSIGN(TestDelayBasedTimeSource);
  88 };
  89
  90 class FakeBeginFrameSource : public BeginFrameSourceBase {
  91  public:
  92   FakeBeginFrameSource() : remaining_frames_(false) {}
  93   ~FakeBeginFrameSource() override {}
  94
  95   BeginFrameObserver* GetObserver() { return observer_; }
  96
  97   BeginFrameArgs TestLastUsedBeginFrameArgs() {
  98     if (observer_) {
  99       return observer_->LastUsedBeginFrameArgs();
 100     }
 101     return BeginFrameArgs();
 102   }
 103
 104   void TestOnBeginFrame(const BeginFrameArgs& args) {
 105     return CallOnBeginFrame(args);
 106   }
 107
 108   // BeginFrameSource
 109   void DidFinishFrame(size_t remaining_frames) override;
 110   void AsValueInto(base::trace_event::TracedValue* dict) const override;
 111
 112  private:
 113   bool remaining_frames_;
 114
 115   DISALLOW_COPY_AND_ASSIGN(FakeBeginFrameSource);
 116 };
 117
 118 class TestBackToBackBeginFrameSource : public BackToBackBeginFrameSource {
 119  public:
 120   ~TestBackToBackBeginFrameSource() override;
 121
 122   static scoped_ptr<TestBackToBackBeginFrameSource> Create(
 123       base::SimpleTestTickClock* now_src,
 124       base::SingleThreadTaskRunner* task_runner) {
 125     return make_scoped_ptr(
 126         new TestBackToBackBeginFrameSource(now_src, task_runner));
 127   }
 128
 129  protected:
 130   TestBackToBackBeginFrameSource(base::SimpleTestTickClock* now_src,
 131                                  base::SingleThreadTaskRunner* task_runner);
 132
 133   base::TimeTicks Now() override;
 134   // Not owned.
 135   base::SimpleTestTickClock* now_src_;
 136
 137  private:
 138   DISALLOW_COPY_AND_ASSIGN(TestBackToBackBeginFrameSource);
 139 };
 140
 141 class TestSyntheticBeginFrameSource : public SyntheticBeginFrameSource {
 142  public:
 143   ~TestSyntheticBeginFrameSource() override;
 144
 145   static scoped_ptr<TestSyntheticBeginFrameSource> Create(
 146       base::SimpleTestTickClock* now_src,
 147       OrderedSimpleTaskRunner* task_runner,
 148       base::TimeDelta initial_interval) {
 149     scoped_ptr<TestDelayBasedTimeSource> time_source =
 150         TestDelayBasedTimeSource::Create(now_src, initial_interval,
 151                                          task_runner);
 152     return make_scoped_ptr(
 153         new TestSyntheticBeginFrameSource(time_source.Pass()));
 154   }
 155
 156  protected:
 157   explicit TestSyntheticBeginFrameSource(
 158       scoped_ptr<DelayBasedTimeSource> time_source);
 159
 160  private:
 161   DISALLOW_COPY_AND_ASSIGN(TestSyntheticBeginFrameSource);
 162 };
 163
 164 class FakeCompositorTimingHistory : public CompositorTimingHistory {
 165  public:
 166   static scoped_ptr<FakeCompositorTimingHistory> Create();
 167   ~FakeCompositorTimingHistory() override;
 168
 169   void SetDrawDurationEstimate(base::TimeDelta duration);
 170   void SetBeginMainFrameToCommitDurationEstimate(base::TimeDelta duration);
 171   void SetCommitToActivateDurationEstimate(base::TimeDelta duration);
 172
 173   base::TimeDelta DrawDurationEstimate() const override;
 174   base::TimeDelta BeginMainFrameToCommitDurationEstimate() const override;
 175   base::TimeDelta CommitToActivateDurationEstimate() const override;
 176
 177  protected:
 178   FakeCompositorTimingHistory(scoped_ptr<RenderingStatsInstrumentation>
 179                                   rendering_stats_instrumentation_owned);
 180
 181   scoped_ptr<RenderingStatsInstrumentation>
 182       rendering_stats_instrumentation_owned_;
 183
 184   base::TimeDelta draw_duration_;
 185   base::TimeDelta begin_main_frame_to_commit_duration_;
 186   base::TimeDelta commit_to_activate_duration_;
 187
 188  private:
 189   DISALLOW_COPY_AND_ASSIGN(FakeCompositorTimingHistory);
 190 };
 191
 192 class TestScheduler : public Scheduler {
 193  public:
 194   static scoped_ptr<TestScheduler> Create(
 195       base::SimpleTestTickClock* now_src,
 196       SchedulerClient* client,
 197       const SchedulerSettings& scheduler_settings,
 198       int layer_tree_host_id,
 199       OrderedSimpleTaskRunner* task_runner,
 200       BeginFrameSource* external_frame_source,
 201       scoped_ptr<CompositorTimingHistory> compositor_timing_history);
 202
 203   // Extra test helper functionality
 204   bool IsBeginRetroFrameArgsEmpty() const {
 205     return begin_retro_frame_args_.empty();
 206   }
 207
 208   bool CanStart() const { return state_machine_.CanStartForTesting(); }
 209
 210   BeginFrameSource& frame_source() { return *frame_source_; }
 211   bool FrameProductionThrottled() { return throttle_frame_production_; }
 212
 213   ~TestScheduler() override;
 214
 215   base::TimeDelta BeginImplFrameInterval() {
 216     return begin_impl_frame_tracker_.Interval();
 217   }
 218
 219  protected:
 220   // Overridden from Scheduler.
 221   base::TimeTicks Now() const override;
 222
 223  private:
 224   TestScheduler(
 225       base::SimpleTestTickClock* now_src,
 226       SchedulerClient* client,
 227       const SchedulerSettings& scheduler_settings,
 228       int layer_tree_host_id,
 229       OrderedSimpleTaskRunner* task_runner,
 230       BeginFrameSource* external_frame_source,
 231       scoped_ptr<TestSyntheticBeginFrameSource> synthetic_frame_source,
 232       scoped_ptr<TestBackToBackBeginFrameSource> unthrottled_frame_source,
 233       scoped_ptr<CompositorTimingHistory> compositor_timing_history);
 234
 235   base::SimpleTestTickClock* now_src_;
 236
 237   DISALLOW_COPY_AND_ASSIGN(TestScheduler);
 238 };
 239
 240 }  // namespace cc
 241
 242 #endif  // CC_TEST_SCHEDULER_TEST_COMMON_H_