cc: Make BackToBackBeginFrameSource a SyntheticBeginFrameSource.

cc/test/scheduler_test_common.cc

Index: cc/test/scheduler_test_common.cc
diff --git a/cc/test/scheduler_test_common.cc b/cc/test/scheduler_test_common.cc
index 36201961c82b57c9e8df5549ce78bb094636fd62..4cefb26945caf890a552fac61b1a1b0e3a66c35b 100644
--- a/cc/test/scheduler_test_common.cc
+++ b/cc/test/scheduler_test_common.cc
@@ -22,10 +22,8 @@ base::TimeTicks FakeDelayBasedTimeSource::Now() const { return now_; }
 
 TestDelayBasedTimeSource::TestDelayBasedTimeSource(
     base::SimpleTestTickClock* now_src,
-    base::TimeDelta interval,
     OrderedSimpleTaskRunner* task_runner)
-    : DelayBasedTimeSource(interval, task_runner), now_src_(now_src) {
-}
+    : DelayBasedTimeSource(task_runner), now_src_(now_src) {}
 
 base::TimeTicks TestDelayBasedTimeSource::Now() const {
   return now_src_->NowTicks();
@@ -45,26 +43,61 @@ FakeBeginFrameSource::~FakeBeginFrameSource() {}
 TestBackToBackBeginFrameSource::TestBackToBackBeginFrameSource(
     base::SimpleTestTickClock* now_src,
     base::SingleThreadTaskRunner* task_runner)
-    : BackToBackBeginFrameSource(task_runner), now_src_(now_src) {
+    : now_src_(now_src), task_runner_(task_runner), weak_factory_(this) {}
+
+TestBackToBackBeginFrameSource::~TestBackToBackBeginFrameSource() = default;
+
+void TestBackToBackBeginFrameSource::AddObserver(BeginFrameObserver* obs) {
+  BeginFrameSourceBase::AddObserver(obs);
+  pending_begin_frame_observers_.insert(obs);
+  PostPendingBeginFramesTask();
+}
+
+void TestBackToBackBeginFrameSource::RemoveObserver(BeginFrameObserver* obs) {
+  BeginFrameSourceBase::RemoveObserver(obs);
+  pending_begin_frame_observers_.erase(obs);
+  if (pending_begin_frame_observers_.empty())
+    begin_frame_task_.Cancel();
 }
 
-TestBackToBackBeginFrameSource::~TestBackToBackBeginFrameSource() {
+void TestBackToBackBeginFrameSource::DidFinishFrame(BeginFrameObserver* obs,
+                                                    size_t remaining_frames) {
+  BeginFrameSourceBase::DidFinishFrame(obs, remaining_frames);
+  if (remaining_frames == 0 && observers_.find(obs) != observers_.end()) {
+    pending_begin_frame_observers_.insert(obs);
+    PostPendingBeginFramesTask();
+  }
 }
 
 base::TimeTicks TestBackToBackBeginFrameSource::Now() {
   return now_src_->NowTicks();
 }
 
-TestSyntheticBeginFrameSource::TestSyntheticBeginFrameSource(
-    base::SimpleTestTickClock* now_src,
-    OrderedSimpleTaskRunner* task_runner,
-    base::TimeDelta initial_interval)
-    : SyntheticBeginFrameSource(
-          TestDelayBasedTimeSource::Create(now_src,
-                                           initial_interval,
-                                           task_runner)) {}
+void TestBackToBackBeginFrameSource::PostPendingBeginFramesTask() {
+  DCHECK(needs_begin_frames());
+  DCHECK(!pending_begin_frame_observers_.empty());
+  if (begin_frame_task_.IsCancelled()) {
+    begin_frame_task_.Reset(
+        base::Bind(&TestBackToBackBeginFrameSource::SendPendingBeginFrames,
+                   weak_factory_.GetWeakPtr()));
+    task_runner_->PostTask(FROM_HERE, begin_frame_task_.callback());
+  }
+}
+
+void TestBackToBackBeginFrameSource::SendPendingBeginFrames() {
+  DCHECK(needs_begin_frames());
+  DCHECK(!begin_frame_task_.IsCancelled());
+  begin_frame_task_.Cancel();
+
+  base::TimeTicks now = Now();
+  BeginFrameArgs args = BeginFrameArgs::Create(
+      BEGINFRAME_FROM_HERE, now, now + BeginFrameArgs::DefaultInterval(),
+      BeginFrameArgs::DefaultInterval(), BeginFrameArgs::NORMAL);
 
-TestSyntheticBeginFrameSource::~TestSyntheticBeginFrameSource() {
+  std::set<BeginFrameObserver*> pending_observers;
+  pending_observers.swap(pending_begin_frame_observers_);
+  for (BeginFrameObserver* obs : pending_observers)
+    obs->OnBeginFrame(args);
 }
 
 std::unique_ptr<FakeCompositorTimingHistory>