cc: Make BackToBackBeginFrameSource a SyntheticBeginFrameSource.

cc/test/scheduler_test_common.cc

 // Copyright 2012 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.
 
 #include "cc/test/scheduler_test_common.h"
 
 #include <stddef.h>
 
 #include <string>
 
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "cc/debug/rendering_stats_instrumentation.h"
 
 namespace cc {
 
 void FakeDelayBasedTimeSourceClient::OnTimerTick() {
   tick_called_ = true;
 }
 
 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();
 }
 
 std::string TestDelayBasedTimeSource::TypeString() const {
   return "TestDelayBasedTimeSource";
 }
 
 TestDelayBasedTimeSource::~TestDelayBasedTimeSource() {
 }
 
 FakeBeginFrameSource::FakeBeginFrameSource() {}
 
 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();
 }
 
-TestBackToBackBeginFrameSource::~TestBackToBackBeginFrameSource() {
+void TestBackToBackBeginFrameSource::RemoveObserver(BeginFrameObserver* obs) {
+  BeginFrameSourceBase::RemoveObserver(obs);
+  pending_begin_frame_observers_.erase(obs);
+  if (pending_begin_frame_observers_.empty())
+    begin_frame_task_.Cancel();
+}
+
+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());
+  }
+}
 
-TestSyntheticBeginFrameSource::~TestSyntheticBeginFrameSource() {
+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);
+
+  std::set<BeginFrameObserver*> pending_observers;
+  pending_observers.swap(pending_begin_frame_observers_);
+  for (BeginFrameObserver* obs : pending_observers)
+    obs->OnBeginFrame(args);
 }
 
 std::unique_ptr<FakeCompositorTimingHistory>
 FakeCompositorTimingHistory::Create(
     bool using_synchronous_renderer_compositor) {
   std::unique_ptr<RenderingStatsInstrumentation>
       rendering_stats_instrumentation = RenderingStatsInstrumentation::Create();
   return base::WrapUnique(new FakeCompositorTimingHistory(
       using_synchronous_renderer_compositor,
       std::move(rendering_stats_instrumentation)));
@@ skipping 122 matching lines @@
       now_src_(now_src) {}
 
 base::TimeTicks TestScheduler::Now() const {
   return now_src_->NowTicks();
 }
 
 TestScheduler::~TestScheduler() {
 }
 
 }  // namespace cc