Replaced TestNowSource with SimpleTestTickClock.

cc/scheduler/scheduler_unittest.cc

 // 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.
 
 #include "cc/scheduler/scheduler.h"
 
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 235 matching lines @@
     return CallOnBeginFrame(args);
   }
 
  private:
   FakeSchedulerClient* client_;
 };
 
 class SchedulerTest : public testing::Test {
  public:
   SchedulerTest()
-      : now_src_(TestNowSource::Create()),
-        task_runner_(new OrderedSimpleTaskRunner(now_src_, true)),
+      : now_src_(new base::SimpleTestTickClock()),
+        task_runner_(new OrderedSimpleTaskRunner(now_src_.get(), true)),
         fake_external_begin_frame_source_(nullptr) {
-    // A bunch of tests require Now() to be > BeginFrameArgs::DefaultInterval()
-    now_src_->AdvanceNow(base::TimeDelta::FromMilliseconds(100));
+    now_src_->Advance(base::TimeDelta::FromInternalValue(10000));
+    // A bunch of tests require NowTicks()
+    // to be > BeginFrameArgs::DefaultInterval()
+    now_src_->Advance(base::TimeDelta::FromMilliseconds(100));
     // Fail if we need to run 100 tasks in a row.
     task_runner_->SetRunTaskLimit(100);
   }
 
   ~SchedulerTest() override {}
 
  protected:
   TestScheduler* CreateScheduler() {
     scoped_ptr<FakeExternalBeginFrameSource> fake_external_begin_frame_source;
     if (scheduler_settings_.use_external_begin_frame_source) {
       fake_external_begin_frame_source.reset(
           new FakeExternalBeginFrameSource(client_.get()));
       fake_external_begin_frame_source_ =
           fake_external_begin_frame_source.get();
     }
-    scheduler_ = TestScheduler::Create(now_src_, client_.get(),
+    scheduler_ = TestScheduler::Create(now_src_.get(), client_.get(),
                                        scheduler_settings_, 0, task_runner_,
                                        fake_external_begin_frame_source.Pass());
     DCHECK(scheduler_);
     client_->set_scheduler(scheduler_.get());
     return scheduler_.get();
   }
 
   void CreateSchedulerAndInitSurface() {
     CreateScheduler();
     EXPECT_SCOPED(InitializeOutputSurfaceAndFirstCommit());
   }
 
   void SetUpScheduler(bool initSurface) {
     SetUpScheduler(make_scoped_ptr(new FakeSchedulerClient), initSurface);
   }
 
   void SetUpScheduler(scoped_ptr<FakeSchedulerClient> client,
                       bool initSurface) {
     client_ = client.Pass();
     if (initSurface)
       CreateSchedulerAndInitSurface();
     else
       CreateScheduler();
   }
 
   OrderedSimpleTaskRunner& task_runner() { return *task_runner_; }
-  TestNowSource* now_src() { return now_src_.get(); }
+  base::SimpleTestTickClock* now_src() { return now_src_.get(); }
 
   // As this function contains EXPECT macros, to allow debugging it should be
   // called inside EXPECT_SCOPED like so;
   //   EXPECT_SCOPED(client.InitializeOutputSurfaceAndFirstCommit(scheduler));
   void InitializeOutputSurfaceAndFirstCommit() {
     TRACE_EVENT0("cc",
                  "SchedulerUnitTest::InitializeOutputSurfaceAndFirstCommit");
     DCHECK(scheduler_);
 
     // Check the client doesn't have any actions queued when calling this
@@ skipping 83 matching lines @@
       EXPECT_TRUE(task_runner_->RunTasksWhile(
           client_->ImplFrameDeadlinePending(false)));
       EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
     }
   }
 
   BeginFrameArgs SendNextBeginFrame() {
     DCHECK(scheduler_->settings().use_external_begin_frame_source);
     // Creep the time forward so that any BeginFrameArgs is not equal to the
     // last one otherwise we violate the BeginFrameSource contract.
-    now_src_->AdvanceNow(BeginFrameArgs::DefaultInterval());
+    now_src_->Advance(BeginFrameArgs::DefaultInterval());
     BeginFrameArgs args =
         CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, now_src());
     fake_external_begin_frame_source_->TestOnBeginFrame(args);
     return args;
   }
 
   FakeExternalBeginFrameSource* fake_external_begin_frame_source() const {
     return fake_external_begin_frame_source_;
   }
 
   void MainFrameInHighLatencyMode(
       int64 begin_main_frame_to_commit_estimate_in_ms,
       int64 commit_to_activate_estimate_in_ms,
       bool impl_latency_takes_priority,
       bool should_send_begin_main_frame);
   void BeginFramesNotFromClient(bool use_external_begin_frame_source,
                                 bool throttle_frame_production);
   void BeginFramesNotFromClient_SwapThrottled(
       bool use_external_begin_frame_source,
       bool throttle_frame_production);
   void DidLoseOutputSurfaceAfterBeginFrameStartedWithHighLatency(
       bool impl_side_painting);
   void DidLoseOutputSurfaceAfterReadyToCommit(bool impl_side_painting);
 
-  scoped_refptr<TestNowSource> now_src_;
+  scoped_ptr<base::SimpleTestTickClock> now_src_;
   scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
   FakeExternalBeginFrameSource* fake_external_begin_frame_source_;
   SchedulerSettings scheduler_settings_;
   scoped_ptr<FakeSchedulerClient> client_;
   scoped_ptr<TestScheduler> scheduler_;
 };
 
 TEST_F(SchedulerTest, InitializeOutputSurfaceDoesNotBeginImplFrame) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(false);
@@ skipping 1368 matching lines @@
   // Run posted BeginRetroFrame.
   task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(false));
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionAnimate", client_, 1, 2);
   EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
   EXPECT_TRUE(client_->needs_begin_frames());
   client_->Reset();
 
   // Let time pass sufficiently beyond the regular deadline but not beyond the
   // late deadline.
-  now_src()->AdvanceNow(BeginFrameArgs::DefaultInterval() -
-                        base::TimeDelta::FromMicroseconds(1));
-  task_runner().RunUntilTime(now_src()->Now());
+  now_src()->Advance(BeginFrameArgs::DefaultInterval() -
+                     base::TimeDelta::FromMicroseconds(1));
+  task_runner().RunUntilTime(now_src()->NowTicks());
   EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
 
   // Take us out of a swap throttled state.
   scheduler_->DidSwapBuffersComplete();
   EXPECT_SINGLE_ACTION("ScheduledActionSendBeginMainFrame", client_);
   EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
   EXPECT_TRUE(client_->needs_begin_frames());
   client_->Reset();
 
   // Verify that the deadline was rescheduled.
-  task_runner().RunUntilTime(now_src()->Now());
+  task_runner().RunUntilTime(now_src()->NowTicks());
   EXPECT_SINGLE_ACTION("ScheduledActionDrawAndSwapIfPossible", client_);
   EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
   EXPECT_TRUE(client_->needs_begin_frames());
   client_->Reset();
 }
 
 TEST_F(SchedulerTest, RetroFrameDoesNotExpireTooEarly) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
 
@@ skipping 29 matching lines @@
   EXPECT_ACTION("ScheduledActionAnimate", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 1, 2);
 
   // Keep animating.
   client_->Reset();
   scheduler_->SetNeedsAnimate();
   scheduler_->SetNeedsRedraw();
   EXPECT_NO_ACTION(client_);
 
   // Let's advance to the retro frame's deadline.
-  now_src()->AdvanceNow(retro_frame_args.deadline - now_src()->Now());
+  now_src()->Advance(retro_frame_args.deadline - now_src()->NowTicks());
 
   // The retro frame hasn't expired yet.
   task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(false));
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionAnimate", client_, 1, 2);
   EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
 
   // This is an immediate deadline case.
   client_->Reset();
   task_runner().RunPendingTasks();
@@ skipping 37 matching lines @@
   EXPECT_ACTION("ScheduledActionAnimate", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client_, 1, 2);
 
   // Keep animating.
   client_->Reset();
   scheduler_->SetNeedsAnimate();
   scheduler_->SetNeedsRedraw();
   EXPECT_NO_ACTION(client_);
 
   // Let's advance sufficiently past the retro frame's deadline.
-  now_src()->AdvanceNow(retro_frame_args.deadline - now_src()->Now() +
-                        base::TimeDelta::FromMicroseconds(1));
+  now_src()->Advance(retro_frame_args.deadline - now_src()->NowTicks() +
+                     base::TimeDelta::FromMicroseconds(1));
 
   // The retro frame should've expired.
   EXPECT_NO_ACTION(client_);
 }
 
 TEST_F(SchedulerTest, MissedFrameDoesNotExpireTooEarly) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
 
   scheduler_->SetNeedsCommit();
   EXPECT_TRUE(client_->needs_begin_frames());
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrames(true)", client_);
 
   BeginFrameArgs missed_frame_args =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, now_src());
   missed_frame_args.type = BeginFrameArgs::MISSED;
 
   // Advance to the deadline.
-  now_src()->AdvanceNow(missed_frame_args.deadline - now_src()->Now());
+  now_src()->Advance(missed_frame_args.deadline - now_src()->NowTicks());
 
   // Missed frame is handled because it's on time.
   client_->Reset();
   fake_external_begin_frame_source_->TestOnBeginFrame(missed_frame_args);
   EXPECT_TRUE(
       task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(false)));
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionSendBeginMainFrame", client_, 1, 2);
   EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
 }
 
 TEST_F(SchedulerTest, MissedFrameExpiresOnTime) {
   scheduler_settings_.use_external_begin_frame_source = true;
   SetUpScheduler(true);
 
   scheduler_->SetNeedsCommit();
   EXPECT_TRUE(client_->needs_begin_frames());
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrames(true)", client_);
 
   BeginFrameArgs missed_frame_args =
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, now_src());
   missed_frame_args.type = BeginFrameArgs::MISSED;
 
   // Advance sufficiently past the deadline.
-  now_src()->AdvanceNow(missed_frame_args.deadline - now_src()->Now() +
-                        base::TimeDelta::FromMicroseconds(1));
+  now_src()->Advance(missed_frame_args.deadline - now_src()->NowTicks() +
+                     base::TimeDelta::FromMicroseconds(1));
 
   // Missed frame is dropped because it's too late.
   client_->Reset();
   fake_external_begin_frame_source_->TestOnBeginFrame(missed_frame_args);
   EXPECT_FALSE(
       task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(false)));
   EXPECT_NO_ACTION(client_);
   EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
 }
 
@@ skipping 125 matching lines @@
   scheduler_->SetNeedsCommit();
   scheduler_->SetNeedsRedraw();
   EXPECT_SCOPED(AdvanceFrame());  // Run posted BeginFrame.
   EXPECT_ACTION("WillBeginImplFrame", client_, 0, 2);
   EXPECT_ACTION("ScheduledActionAnimate", client_, 1, 2);
   EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
   client_->Reset();
 
   // Let time pass sufficiently beyond the regular deadline but not beyond the
   // late deadline.
-  now_src()->AdvanceNow(BeginFrameArgs::DefaultInterval() -
-                        base::TimeDelta::FromMicroseconds(1));
-  task_runner().RunUntilTime(now_src()->Now());
+  now_src()->Advance(BeginFrameArgs::DefaultInterval() -
+                     base::TimeDelta::FromMicroseconds(1));
+  task_runner().RunUntilTime(now_src()->NowTicks());
   EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
 
   // Take us out of a swap throttled state.
   scheduler_->DidSwapBuffersComplete();
   EXPECT_SINGLE_ACTION("ScheduledActionSendBeginMainFrame", client_);
   EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
   client_->Reset();
 
   // Verify that the deadline was rescheduled.
   // We can't use RunUntilTime(now) here because the next frame is also
   // scheduled if throttle_frame_production = false.
-  base::TimeTicks before_deadline = now_src()->Now();
+  base::TimeTicks before_deadline = now_src()->NowTicks();
   task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
-  base::TimeTicks after_deadline = now_src()->Now();
+  base::TimeTicks after_deadline = now_src()->NowTicks();
   EXPECT_EQ(after_deadline, before_deadline);
   EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
   client_->Reset();
 }
 
 TEST_F(SchedulerTest, SyntheticBeginFrames_SwapThrottled) {
   bool use_external_begin_frame_source = false;
   bool throttle_frame_production = true;
   BeginFramesNotFromClient_SwapThrottled(use_external_begin_frame_source,
                                          throttle_frame_production);
@@ skipping 88 matching lines @@
   EXPECT_TRUE(scheduler_->BeginImplFrameDeadlinePending());
   task_runner().RunTasksWhile(client_->ImplFrameDeadlinePending(true));
   // OnBeginImplFrameDeadline didn't schedule output surface creation because
   // main frame is not yet completed.
   EXPECT_ACTION("SetNeedsBeginFrames(false)", client_, 0, 2);
   EXPECT_ACTION("SendBeginMainFrameNotExpectedSoon", client_, 1, 2);
   EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
 
   // BeginImplFrame is not started.
   client_->Reset();
-  task_runner().RunUntilTime(now_src()->Now() +
+  task_runner().RunUntilTime(now_src()->NowTicks() +
                              base::TimeDelta::FromMilliseconds(10));
   EXPECT_NO_ACTION(client_);
   EXPECT_FALSE(scheduler_->BeginImplFrameDeadlinePending());
 
   client_->Reset();
   scheduler_->NotifyBeginMainFrameStarted();
   scheduler_->NotifyReadyToCommit();
   if (impl_side_painting) {
     EXPECT_ACTION("ScheduledActionCommit", client_, 0, 3);
     EXPECT_ACTION("ScheduledActionActivateSyncTree", client_, 1, 3);
@@ skipping 728 matching lines @@
   EXPECT_SCOPED(AdvanceFrame());
 
   // At the next BeginFrame, authoritative interval is used instead of previous
   // interval.
   EXPECT_NE(initial_interval, scheduler_->BeginImplFrameInterval());
   EXPECT_EQ(authoritative_interval, scheduler_->BeginImplFrameInterval());
 }
 
 }  // namespace
 }  // namespace cc