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/delay_based_time_source.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 FakeTimeSourceClient : public TimeSourceClient {
  21  public:
  22   FakeTimeSourceClient() : tick_called_(false) {}
  23   void Reset() { tick_called_ = false; }
  24   bool TickCalled() const { return tick_called_; }
  25
  26   // TimeSourceClient implementation.
  27   void OnTimerTick() override;
  28
  29  protected:
  30   bool tick_called_;
  31 };
  32
  33 class FakeDelayBasedTimeSource : public DelayBasedTimeSource {
  34  public:
  35   static scoped_refptr<FakeDelayBasedTimeSource> Create(
  36       base::TimeDelta interval, base::SingleThreadTaskRunner* task_runner) {
  37     return make_scoped_refptr(new FakeDelayBasedTimeSource(interval,
  38                                                            task_runner));
  39   }
  40
  41   void SetNow(base::TimeTicks time) { now_ = time; }
  42   base::TimeTicks Now() const override;
  43
  44  protected:
  45   FakeDelayBasedTimeSource(base::TimeDelta interval,
  46                            base::SingleThreadTaskRunner* task_runner)
  47       : DelayBasedTimeSource(interval, task_runner) {}
  48   ~FakeDelayBasedTimeSource() override {}
  49
  50   base::TimeTicks now_;
  51 };
  52
  53 class TestDelayBasedTimeSource : public DelayBasedTimeSource {
  54  public:
  55   static scoped_refptr<TestDelayBasedTimeSource> Create(
  56       scoped_refptr<TestNowSource> now_src,
  57       base::TimeDelta interval,
  58       OrderedSimpleTaskRunner* task_runner) {
  59     return make_scoped_refptr(
  60         new TestDelayBasedTimeSource(now_src, interval, task_runner));
  61   }
  62
  63  protected:
  64   TestDelayBasedTimeSource(scoped_refptr<TestNowSource> now_src,
  65                            base::TimeDelta interval,
  66                            OrderedSimpleTaskRunner* task_runner);
  67
  68   // Overridden from DelayBasedTimeSource
  69   ~TestDelayBasedTimeSource() override;
  70   base::TimeTicks Now() const override;
  71   std::string TypeString() const override;
  72
  73   scoped_refptr<TestNowSource> now_src_;
  74 };
  75
  76 struct FakeBeginFrameSource : public BeginFrameSourceMixIn {
  77   bool remaining_frames_ = false;
  78
  79   BeginFrameObserver* GetObserver() { return observer_; }
  80
  81   BeginFrameArgs TestLastUsedBeginFrameArgs() {
  82     if (observer_) {
  83       return observer_->LastUsedBeginFrameArgs();
  84     }
  85     return BeginFrameArgs();
  86   }
  87   void TestOnBeginFrame(const BeginFrameArgs& args) {
  88     return CallOnBeginFrame(args);
  89   }
  90
  91   // BeginFrameSource
  92   void DidFinishFrame(size_t remaining_frames) override;
  93   void AsValueInto(base::trace_event::TracedValue* dict) const override;
  94
  95   ~FakeBeginFrameSource() override {}
  96 };
  97
  98 class TestBackToBackBeginFrameSource : public BackToBackBeginFrameSource {
  99  public:
 100   ~TestBackToBackBeginFrameSource() override;
 101
 102   static scoped_ptr<TestBackToBackBeginFrameSource> Create(
 103       scoped_refptr<TestNowSource> now_src,
 104       base::SingleThreadTaskRunner* task_runner) {
 105     return make_scoped_ptr(
 106         new TestBackToBackBeginFrameSource(now_src, task_runner));
 107   }
 108
 109  protected:
 110   TestBackToBackBeginFrameSource(scoped_refptr<TestNowSource> now_src,
 111                                  base::SingleThreadTaskRunner* task_runner);
 112
 113   base::TimeTicks Now() override;
 114
 115   scoped_refptr<TestNowSource> now_src_;
 116 };
 117
 118 class TestSyntheticBeginFrameSource : public SyntheticBeginFrameSource {
 119  public:
 120   ~TestSyntheticBeginFrameSource() override;
 121
 122   static scoped_ptr<TestSyntheticBeginFrameSource> Create(
 123       scoped_refptr<TestNowSource> now_src,
 124       OrderedSimpleTaskRunner* task_runner,
 125       base::TimeDelta initial_interval) {
 126     return make_scoped_ptr(
 127         new TestSyntheticBeginFrameSource(TestDelayBasedTimeSource::Create(
 128             now_src, initial_interval, task_runner)));
 129   }
 130
 131  protected:
 132   TestSyntheticBeginFrameSource(
 133       scoped_refptr<DelayBasedTimeSource> time_source);
 134 };
 135
 136 class TestScheduler;
 137 class TestSchedulerFrameSourcesConstructor
 138     : public SchedulerFrameSourcesConstructor {
 139  public:
 140   ~TestSchedulerFrameSourcesConstructor() override;
 141
 142  protected:
 143   BeginFrameSource* ConstructPrimaryFrameSource(Scheduler* scheduler) override;
 144   BeginFrameSource* ConstructUnthrottledFrameSource(
 145       Scheduler* scheduler) override;
 146
 147   OrderedSimpleTaskRunner* test_task_runner_;
 148   TestNowSource* now_src_;
 149
 150  protected:
 151   explicit TestSchedulerFrameSourcesConstructor(
 152       OrderedSimpleTaskRunner* test_task_runner,
 153       TestNowSource* now_src);
 154   friend class TestScheduler;
 155 };
 156
 157 class TestScheduler : public Scheduler {
 158  public:
 159   static scoped_ptr<TestScheduler> Create(
 160       scoped_refptr<TestNowSource> now_src,
 161       SchedulerClient* client,
 162       const SchedulerSettings& scheduler_settings,
 163       int layer_tree_host_id,
 164       const scoped_refptr<OrderedSimpleTaskRunner>& task_runner,
 165       scoped_ptr<BeginFrameSource> external_begin_frame_source) {
 166     TestSchedulerFrameSourcesConstructor frame_sources_constructor(
 167         task_runner.get(), now_src.get());
 168     return make_scoped_ptr(new TestScheduler(
 169                                    now_src,
 170                                    client,
 171                                    scheduler_settings,
 172                                    layer_tree_host_id,
 173                                    task_runner,
 174                                    &frame_sources_constructor,
 175                                    external_begin_frame_source.Pass()));
 176   }
 177
 178   // Extra test helper functionality
 179   bool IsBeginRetroFrameArgsEmpty() const {
 180     return begin_retro_frame_args_.empty();
 181   }
 182
 183   bool CanStart() const { return state_machine_.CanStartForTesting(); }
 184
 185   BeginFrameSource& frame_source() { return *frame_source_; }
 186   bool FrameProductionThrottled() { return throttle_frame_production_; }
 187   BeginFrameArgs begin_impl_frame_args() { return begin_impl_frame_args_; }
 188
 189   ~TestScheduler() override;
 190
 191   void NotifyReadyToCommitThenActivateIfNeeded() {
 192     NotifyReadyToCommit();
 193     if (settings_.impl_side_painting) {
 194       NotifyReadyToActivate();
 195     }
 196   }
 197
 198  protected:
 199   // Overridden from Scheduler.
 200   base::TimeTicks Now() const override;
 201
 202  private:
 203   TestScheduler(
 204       scoped_refptr<TestNowSource> now_src,
 205       SchedulerClient* client,
 206       const SchedulerSettings& scheduler_settings,
 207       int layer_tree_host_id,
 208       const scoped_refptr<OrderedSimpleTaskRunner>& test_task_runner,
 209       TestSchedulerFrameSourcesConstructor* frame_sources_constructor,
 210       scoped_ptr<BeginFrameSource> external_begin_frame_source);
 211
 212   scoped_refptr<TestNowSource> now_src_;
 213 };
 214
 215 }  // namespace cc
 216
 217 #endif  // CC_TEST_SCHEDULER_TEST_COMMON_H_