cc: Send all begin frames using a PostTask.

cc/scheduler/begin_frame_source_unittest.cc

Index: cc/scheduler/begin_frame_source_unittest.cc
diff --git a/cc/scheduler/begin_frame_source_unittest.cc b/cc/scheduler/begin_frame_source_unittest.cc
index b50c4b91ce510a5444ba5912f090adca3dec176c..f49118d7c28fa222c62ed6d4caaf527390c431d5 100644
--- a/cc/scheduler/begin_frame_source_unittest.cc
+++ b/cc/scheduler/begin_frame_source_unittest.cc
@@ -25,13 +25,12 @@ class BackToBackBeginFrameSourceTest : public ::testing::Test {
   static const int64_t kInterval;
 
   void SetUp() override {
-    now_src_.reset(new base::SimpleTestTickClock());
+    now_src_ = base::MakeUnique<base::SimpleTestTickClock>();
     now_src_->Advance(base::TimeDelta::FromMicroseconds(1000));
     task_runner_ =
         make_scoped_refptr(new OrderedSimpleTaskRunner(now_src_.get(), false));
-    std::unique_ptr<TestDelayBasedTimeSource> time_source(
-        new TestDelayBasedTimeSource(now_src_.get(), task_runner_.get()));
-    source_.reset(new BackToBackBeginFrameSource(std::move(time_source)));
+    source_.reset(
+        new BackToBackBeginFrameSource(task_runner_.get(), now_src_.get()));
     obs_ = base::WrapUnique(new ::testing::StrictMock<MockBeginFrameObserver>);
   }
 
@@ -112,9 +111,7 @@ TEST_F(BackToBackBeginFrameSourceTest,
   source_->DidFinishFrame(obs_.get(), 0);
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(10));
-  // The begin frame is posted at the time when the observer was added,
-  // so it ignores changes to "now" afterward.
-  EXPECT_BEGIN_FRAME_USED(*obs_, 1110, 1110 + kDeadline, kInterval);
+  EXPECT_BEGIN_FRAME_USED(*obs_, 1130, 1130 + kDeadline, kInterval);
   EXPECT_TRUE(task_runner_->HasPendingTasks());
   task_runner_->RunPendingTasks();
 }
@@ -137,9 +134,7 @@ TEST_F(BackToBackBeginFrameSourceTest,
   source_->AddObserver(obs_.get());
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(10));
-  // Ticks at the time at which the observer was added, ignoring the
-  // last change to "now".
-  EXPECT_BEGIN_FRAME_USED(*obs_, 1120, 1120 + kDeadline, kInterval);
+  EXPECT_BEGIN_FRAME_USED(*obs_, 1130, 1130 + kDeadline, kInterval);
   EXPECT_TRUE(task_runner_->HasPendingTasks());
   task_runner_->RunPendingTasks();
 }
@@ -199,23 +194,6 @@ TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameMultipleCallsIdempotent) {
   task_runner_->RunPendingTasks();
 }
 
-TEST_F(BackToBackBeginFrameSourceTest, DelayInPostedTaskProducesCorrectFrame) {
-  EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
-  source_->AddObserver(obs_.get());
-  EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);
-  task_runner_->RunPendingTasks();
-
-  now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
-  source_->DidFinishFrame(obs_.get(), 0);
-  now_src_->Advance(base::TimeDelta::FromMicroseconds(50));
-  // Ticks at the time the last frame finished, so ignores the last change to
-  // "now".
-  EXPECT_BEGIN_FRAME_USED(*obs_, 1100, 1100 + kDeadline, kInterval);
-
-  EXPECT_TRUE(task_runner_->HasPendingTasks());
-  task_runner_->RunPendingTasks();
-}
-
 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversSynchronized) {
   StrictMock<MockBeginFrameObserver> obs1, obs2;
 
@@ -297,10 +275,8 @@ TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversAtOnce) {
   now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
   source_->DidFinishFrame(&obs2, 0);
 
-  // Because the begin frame source already ticked when |obs1| finished,
-  // we see it as the frame time for both observers.
-  EXPECT_BEGIN_FRAME_USED(obs1, 1100, 1100 + kDeadline, kInterval);
-  EXPECT_BEGIN_FRAME_USED(obs2, 1100, 1100 + kDeadline, kInterval);
+  EXPECT_BEGIN_FRAME_USED(obs1, 1200, 1200 + kDeadline, kInterval);
+  EXPECT_BEGIN_FRAME_USED(obs2, 1200, 1200 + kDeadline, kInterval);
   task_runner_->RunPendingTasks();
 
   source_->DidFinishFrame(&obs1, 0);
@@ -318,15 +294,14 @@ class DelayBasedBeginFrameSourceTest : public ::testing::Test {
   std::unique_ptr<MockBeginFrameObserver> obs_;
 
   void SetUp() override {
-    now_src_.reset(new base::SimpleTestTickClock());
+    now_src_ = base::MakeUnique<base::SimpleTestTickClock>();
     now_src_->Advance(base::TimeDelta::FromMicroseconds(1000));
     task_runner_ =
         make_scoped_refptr(new OrderedSimpleTaskRunner(now_src_.get(), false));
-    std::unique_ptr<DelayBasedTimeSource> time_source(
-        new TestDelayBasedTimeSource(now_src_.get(), task_runner_.get()));
-    time_source->SetTimebaseAndInterval(
-        base::TimeTicks(), base::TimeDelta::FromMicroseconds(10000));
-    source_.reset(new DelayBasedBeginFrameSource(std::move(time_source)));
+    source_.reset(
+        new DelayBasedBeginFrameSource(task_runner_.get(), now_src_.get()));
+    source_->OnUpdateVSyncParameters(base::TimeTicks(),
+                                     base::TimeDelta::FromMicroseconds(10000));
     obs_.reset(new MockBeginFrameObserver);
   }
 
@@ -337,15 +312,17 @@ TEST_F(DelayBasedBeginFrameSourceTest,
        AddObserverCallsOnBeginFrameWithMissedTick) {
   now_src_->Advance(base::TimeDelta::FromMicroseconds(9010));
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
+  source_->AddObserver(obs_.get());
+
   EXPECT_BEGIN_FRAME_USED_MISSED(*obs_, 10000, 20000, 10000);
-  source_->AddObserver(obs_.get());  // Should cause the last tick to be sent
-  // No tasks should need to be run for this to occur.
+  task_runner_->RunPendingTasks();  // Should cause the last tick to be sent.
 }
 
 TEST_F(DelayBasedBeginFrameSourceTest, AddObserverCallsCausesOnBeginFrame) {
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
-  EXPECT_BEGIN_FRAME_USED_MISSED(*obs_, 0, 10000, 10000);
   source_->AddObserver(obs_.get());
+  EXPECT_BEGIN_FRAME_USED_MISSED(*obs_, 0, 10000, 10000);
+  task_runner_->RunPendingTasks();
   EXPECT_EQ(10000, task_runner_->NextTaskTime().ToInternalValue());
 
   EXPECT_BEGIN_FRAME_USED(*obs_, 10000, 20000, 10000);
@@ -475,8 +452,9 @@ TEST_F(DelayBasedBeginFrameSourceTest, DoubleTickMissedFrame) {
   StrictMock<MockBeginFrameObserver> obs;
 
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs, false);
-  EXPECT_BEGIN_FRAME_USED_MISSED(obs, 0, 10000, 10000);
   source_->AddObserver(&obs);
+  EXPECT_BEGIN_FRAME_USED_MISSED(obs, 0, 10000, 10000);
+  task_runner_->RunPendingTasks();
   source_->RemoveObserver(&obs);
 
   source_->OnUpdateVSyncParameters(base::TimeTicks::FromInternalValue(5000),
@@ -493,8 +471,9 @@ TEST_F(DelayBasedBeginFrameSourceTest, DoubleTickMissedFrame) {
                                    base::TimeDelta::FromInternalValue(10000));
   now_src_->Advance(base::TimeDelta::FromInternalValue(5000));
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs, false);
-  EXPECT_BEGIN_FRAME_USED_MISSED(obs, 10000, 20000, 10000);
   source_->AddObserver(&obs);
+  EXPECT_BEGIN_FRAME_USED_MISSED(obs, 10000, 20000, 10000);
+  task_runner_->RunPendingTasks();
   source_->RemoveObserver(&obs);
 }