cc: Make BackToBackBeginFrameSource a SyntheticBeginFrameSource.

cc/test/scheduler_test_common.h

 // Copyright 2011 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 CC_TEST_SCHEDULER_TEST_COMMON_H_
 #define CC_TEST_SCHEDULER_TEST_COMMON_H_
 
 #include <stddef.h>
 
 #include <memory>
@@ skipping 22 matching lines @@
 
  protected:
   bool tick_called_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FakeDelayBasedTimeSourceClient);
 };
 
 class FakeDelayBasedTimeSource : public DelayBasedTimeSource {
  public:
-  static std::unique_ptr<FakeDelayBasedTimeSource> Create(
-      base::TimeDelta interval,
-      base::SingleThreadTaskRunner* task_runner) {
-    return base::WrapUnique(
-        new FakeDelayBasedTimeSource(interval, task_runner));
-  }
-
+  explicit FakeDelayBasedTimeSource(base::SingleThreadTaskRunner* task_runner)
+      : DelayBasedTimeSource(task_runner) {}
   ~FakeDelayBasedTimeSource() override {}
 
   void SetNow(base::TimeTicks time) { now_ = time; }
   base::TimeTicks Now() const override;
 
  protected:
-  FakeDelayBasedTimeSource(base::TimeDelta interval,
-                           base::SingleThreadTaskRunner* task_runner)
-      : DelayBasedTimeSource(interval, task_runner) {}
-
   base::TimeTicks now_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FakeDelayBasedTimeSource);
 };
 
 class TestDelayBasedTimeSource : public DelayBasedTimeSource {
  public:
-  static std::unique_ptr<TestDelayBasedTimeSource> Create(
-      base::SimpleTestTickClock* now_src,
-      base::TimeDelta interval,
-      OrderedSimpleTaskRunner* task_runner) {
-    return base::WrapUnique(
-        new TestDelayBasedTimeSource(now_src, interval, task_runner));
-  }
-
+  TestDelayBasedTimeSource(base::SimpleTestTickClock* now_src,
+                           OrderedSimpleTaskRunner* task_runner);
   ~TestDelayBasedTimeSource() override;
 
  protected:
-  TestDelayBasedTimeSource(base::SimpleTestTickClock* now_src,
-                           base::TimeDelta interval,
-                           OrderedSimpleTaskRunner* task_runner);
-
   // Overridden from DelayBasedTimeSource
   base::TimeTicks Now() const override;
   std::string TypeString() const override;
 
   // Not owned.
   base::SimpleTestTickClock* now_src_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestDelayBasedTimeSource);
 };
@@ skipping 15 matching lines @@
   }
 
   bool has_observers() const { return !observers_.empty(); }
 
   using BeginFrameSourceBase::SetBeginFrameSourcePaused;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FakeBeginFrameSource);
 };
 
-class TestBackToBackBeginFrameSource : public BackToBackBeginFrameSource {
+class TestBackToBackBeginFrameSource : public BeginFrameSourceBase {

[enne (OOO), 2016/06/14 21:25:17]

Why can't this be a BackToBackBeginFrameSource? It looks like you replicate some
of the logic in the test class, which is a bit <_<

[danakj, 2016/06/14 21:53:23]

Oh, I did that first so I could ignore some tests. Let me try that.

[danakj, 2016/06/14 22:00:16]

It is now deleted.

  public:
   TestBackToBackBeginFrameSource(base::SimpleTestTickClock* now_src,
                                  base::SingleThreadTaskRunner* task_runner);
   ~TestBackToBackBeginFrameSource() override;
 
- protected:
-  base::TimeTicks Now() override;
-  // Not owned.
-  base::SimpleTestTickClock* now_src_;
+  // BeginFrameSourceBase overrides.
+  void AddObserver(BeginFrameObserver* obs) override;
+  void RemoveObserver(BeginFrameObserver* obs) override;
+  void DidFinishFrame(BeginFrameObserver* obs,
+                      size_t remaining_frames) override;
 
  private:
+  base::TimeTicks Now();
+  void PostPendingBeginFramesTask();
+  void SendPendingBeginFrames();
+
+  base::SimpleTestTickClock* now_src_;
+  base::SingleThreadTaskRunner* task_runner_;
+  base::CancelableClosure begin_frame_task_;
+  std::set<BeginFrameObserver*> pending_begin_frame_observers_;
+  base::WeakPtrFactory<TestBackToBackBeginFrameSource> weak_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(TestBackToBackBeginFrameSource);
 };
 
-class TestSyntheticBeginFrameSource : public SyntheticBeginFrameSource {
- public:
-  explicit TestSyntheticBeginFrameSource(base::SimpleTestTickClock* now_src,
-                                         OrderedSimpleTaskRunner* task_runner,
-                                         base::TimeDelta initial_interval);
-  ~TestSyntheticBeginFrameSource() override;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(TestSyntheticBeginFrameSource);
-};
-
 class FakeCompositorTimingHistory : public CompositorTimingHistory {
  public:
   static std::unique_ptr<FakeCompositorTimingHistory> Create(
       bool using_synchronous_renderer_compositor);
   ~FakeCompositorTimingHistory() override;
 
   void SetAllEstimatesTo(base::TimeDelta duration);
 
   void SetBeginMainFrameToCommitDurationEstimate(base::TimeDelta duration);
   void SetBeginMainFrameQueueDurationCriticalEstimate(base::TimeDelta duration);
@@ skipping 88 matching lines @@
 
  private:
   base::SimpleTestTickClock* now_src_;
 
   DISALLOW_COPY_AND_ASSIGN(TestScheduler);
 };
 
 }  // namespace cc
 
 #endif  // CC_TEST_SCHEDULER_TEST_COMMON_H_