Replaced TestNowSource with SimpleTestTickClock.

cc/scheduler/begin_frame_source_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 <deque>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/test/test_simple_task_runner.h"
@@ skipping 296 matching lines @@
 
   scoped_refptr<base::trace_event::TracedValue> state =
       new base::trace_event::TracedValue();
   source.AsValueInto(state.get());
 }
 
 // BackToBackBeginFrameSource testing -----------------------------------------
 class TestBackToBackBeginFrameSource : public BackToBackBeginFrameSource {
  public:
   static scoped_ptr<TestBackToBackBeginFrameSource> Create(
-      scoped_refptr<TestNowSource> now_src,
+      base::SimpleTestTickClock* now_src,
       base::SingleThreadTaskRunner* task_runner) {
     return make_scoped_ptr(
         new TestBackToBackBeginFrameSource(now_src, task_runner));
   }
 
  protected:
-  TestBackToBackBeginFrameSource(scoped_refptr<TestNowSource> now_src,
+  TestBackToBackBeginFrameSource(base::SimpleTestTickClock* now_src,
                                  base::SingleThreadTaskRunner* task_runner)
       : BackToBackBeginFrameSource(task_runner), now_src_(now_src) {}
 
-  base::TimeTicks Now() override { return now_src_->Now(); }
+  base::TimeTicks Now() override { return now_src_->NowTicks(); }
 
-  scoped_refptr<TestNowSource> now_src_;
+  base::SimpleTestTickClock* now_src_;
 };
 
 class BackToBackBeginFrameSourceTest : public ::testing::Test {
  public:
   static const int64_t kDeadline;
   static const int64_t kInterval;
 
-  scoped_refptr<TestNowSource> now_src_;
+  scoped_ptr<base::SimpleTestTickClock> now_src_;
   scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
   scoped_ptr<TestBackToBackBeginFrameSource> source_;
   scoped_ptr<MockBeginFrameObserver> obs_;
 
   void SetUp() override {
-    now_src_ = TestNowSource::Create(1000);
+    now_src_ = make_scoped_ptr(new base::SimpleTestTickClock());
+    now_src_->Advance(base::TimeDelta::FromInternalValue(1000));
     task_runner_ =
-        make_scoped_refptr(new OrderedSimpleTaskRunner(now_src_, false));
+        make_scoped_refptr(new OrderedSimpleTaskRunner(now_src_.get(), false));
     task_runner_->SetRunTaskLimit(1);
-    source_ =
-        TestBackToBackBeginFrameSource::Create(now_src_, task_runner_.get());
+    source_ = TestBackToBackBeginFrameSource::Create(now_src_.get(),
+                                                     task_runner_.get());
     obs_ = make_scoped_ptr(new ::testing::StrictMock<MockBeginFrameObserver>());
     source_->AddObserver(obs_.get());
   }
 
   void TearDown() override { obs_.reset(); }
 };
 
 const int64_t BackToBackBeginFrameSourceTest::kDeadline =
     BeginFrameArgs::DefaultInterval().ToInternalValue();
 
 const int64_t BackToBackBeginFrameSourceTest::kInterval =
     BeginFrameArgs::DefaultInterval().ToInternalValue();
 
 TEST_F(BackToBackBeginFrameSourceTest, SetNeedsBeginFramesSendsBeginFrame) {
   EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);
   source_->SetNeedsBeginFrames(true);
   EXPECT_TRUE(task_runner_->HasPendingTasks());
   task_runner_->RunUntilIdle();
 
   EXPECT_BEGIN_FRAME_USED(*obs_, 1100, 1100 + kDeadline, kInterval);
-  now_src_->AdvanceNowMicroseconds(100);
+  now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
   source_->DidFinishFrame(0);
   task_runner_->RunUntilIdle();
 }
 
 TEST_F(BackToBackBeginFrameSourceTest,
        DidFinishFrameThenSetNeedsBeginFramesProducesNoFrame) {
   EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);
   source_->SetNeedsBeginFrames(true);
   task_runner_->RunUntilIdle();
 
   source_->SetNeedsBeginFrames(false);
   source_->DidFinishFrame(0);
 
   EXPECT_FALSE(task_runner_->HasPendingTasks());
 }
 
 TEST_F(BackToBackBeginFrameSourceTest,
        SetNeedsBeginFramesThenDidFinishFrameProducesNoFrame) {
   EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);
   source_->SetNeedsBeginFrames(true);
   task_runner_->RunUntilIdle();
 
-  now_src_->AdvanceNowMicroseconds(100);
+  now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
   source_->DidFinishFrame(0);
   source_->SetNeedsBeginFrames(false);
 
   EXPECT_TRUE(task_runner_->HasPendingTasks());
   task_runner_->RunUntilIdle();
 }
 
 TEST_F(BackToBackBeginFrameSourceTest,
        DidFinishFrameThenTogglingSetNeedsBeginFramesProducesCorrectFrame) {
   EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);
   source_->SetNeedsBeginFrames(true);
   task_runner_->RunUntilIdle();
 
-  now_src_->AdvanceNowMicroseconds(100);
+  now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
 
   source_->SetNeedsBeginFrames(false);
-  now_src_->AdvanceNowMicroseconds(10);
+  now_src_->Advance(base::TimeDelta::FromMicroseconds(10));
   source_->DidFinishFrame(0);
-  now_src_->AdvanceNowMicroseconds(10);
+  now_src_->Advance(base::TimeDelta::FromMicroseconds(10));
   source_->SetNeedsBeginFrames(false);
-  now_src_->AdvanceNowMicroseconds(10);
+  now_src_->Advance(base::TimeDelta::FromMicroseconds(10));
   source_->SetNeedsBeginFrames(true);
 
   EXPECT_BEGIN_FRAME_USED(*obs_, 1130, 1130 + kDeadline, kInterval);
   EXPECT_TRUE(task_runner_->HasPendingTasks());
   task_runner_->RunUntilIdle();
 }
 
 TEST_F(BackToBackBeginFrameSourceTest,
        TogglingSetNeedsBeginFramesThenDidFinishFrameProducesCorrectFrame) {
   EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);
   source_->SetNeedsBeginFrames(true);
   task_runner_->RunUntilIdle();
 
-  now_src_->AdvanceNowMicroseconds(100);
+  now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
   source_->DidFinishFrame(0);
-  now_src_->AdvanceNowMicroseconds(10);
+  now_src_->Advance(base::TimeDelta::FromMicroseconds(10));
   source_->SetNeedsBeginFrames(false);
-  now_src_->AdvanceNowMicroseconds(10);
+  now_src_->Advance(base::TimeDelta::FromMicroseconds(10));
   source_->SetNeedsBeginFrames(true);
-  now_src_->AdvanceNowMicroseconds(10);
+  now_src_->Advance(base::TimeDelta::FromMicroseconds(10));
 
   EXPECT_BEGIN_FRAME_USED(*obs_, 1130, 1130 + kDeadline, kInterval);
   EXPECT_TRUE(task_runner_->HasPendingTasks());
   task_runner_->RunUntilIdle();
 }
 
 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameNeedsBeginFrameFalse) {
   source_->SetNeedsBeginFrames(false);
   source_->DidFinishFrame(0);
   EXPECT_FALSE(task_runner_->RunPendingTasks());
 }
 
 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameRemainingFrames) {
   EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);
   source_->SetNeedsBeginFrames(true);
   task_runner_->RunUntilIdle();
 
-  now_src_->AdvanceNowMicroseconds(100);
+  now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
 
   source_->DidFinishFrame(3);
   EXPECT_FALSE(task_runner_->HasPendingTasks());
   source_->DidFinishFrame(2);
   EXPECT_FALSE(task_runner_->HasPendingTasks());
   source_->DidFinishFrame(1);
   EXPECT_FALSE(task_runner_->HasPendingTasks());
 
   EXPECT_BEGIN_FRAME_USED(*obs_, 1100, 1100 + kDeadline, kInterval);
   source_->DidFinishFrame(0);
   EXPECT_EQ(base::TimeDelta(), task_runner_->DelayToNextTaskTime());
   task_runner_->RunUntilIdle();
 }
 
 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameMultipleCallsIdempotent) {
   source_->SetNeedsBeginFrames(true);
   EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);
   task_runner_->RunUntilIdle();
 
-  now_src_->AdvanceNowMicroseconds(100);
+  now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
   source_->DidFinishFrame(0);
   source_->DidFinishFrame(0);
   source_->DidFinishFrame(0);
   EXPECT_BEGIN_FRAME_USED(*obs_, 1100, 1100 + kDeadline, kInterval);
   task_runner_->RunUntilIdle();
 
-  now_src_->AdvanceNowMicroseconds(100);
+  now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
   source_->DidFinishFrame(0);
   source_->DidFinishFrame(0);
   source_->DidFinishFrame(0);
   EXPECT_BEGIN_FRAME_USED(*obs_, 1200, 1200 + kDeadline, kInterval);
   task_runner_->RunUntilIdle();
 }
 
 TEST_F(BackToBackBeginFrameSourceTest, DelayInPostedTaskProducesCorrectFrame) {
   EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);
   source_->SetNeedsBeginFrames(true);
   task_runner_->RunUntilIdle();
 
-  now_src_->AdvanceNowMicroseconds(100);
+  now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
   source_->DidFinishFrame(0);
-  now_src_->AdvanceNowMicroseconds(50);
+  now_src_->Advance(base::TimeDelta::FromMicroseconds(50));
   EXPECT_BEGIN_FRAME_USED(*obs_, 1150, 1150 + kDeadline, kInterval);
 
   EXPECT_TRUE(task_runner_->HasPendingTasks());
   task_runner_->RunUntilIdle();
 }
 
 // SyntheticBeginFrameSource testing ------------------------------------------
 class SyntheticBeginFrameSourceTest : public ::testing::Test {
  public:
-  scoped_refptr<TestNowSource> now_src_;
+  scoped_ptr<base::SimpleTestTickClock> now_src_;
   scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
   scoped_ptr<TestSyntheticBeginFrameSource> source_;
   scoped_ptr<MockBeginFrameObserver> obs_;
 
   void SetUp() override {
-    now_src_ = TestNowSource::Create(1000);
+    now_src_ = make_scoped_ptr(new base::SimpleTestTickClock());

[mithro-old, 2015/06/04 07:41:10]

I think this should be?

 now_src_.reset(new base::SimpleTestTickClock());

[Ankur Verma, 2015/06/05 14:39:16]

Done.

+    now_src_->Advance(base::TimeDelta::FromInternalValue(1000));
     task_runner_ =
-        make_scoped_refptr(new OrderedSimpleTaskRunner(now_src_, false));
+        make_scoped_refptr(new OrderedSimpleTaskRunner(now_src_.get(), false));
     source_ = TestSyntheticBeginFrameSource::Create(
-        now_src_, task_runner_.get(), base::TimeDelta::FromMicroseconds(10000));
+        now_src_.get(), task_runner_.get(),
+        base::TimeDelta::FromMicroseconds(10000));
     obs_ = make_scoped_ptr(new MockBeginFrameObserver());
     source_->AddObserver(obs_.get());
   }
 
   void TearDown() override { obs_.reset(); }
 };
 
 TEST_F(SyntheticBeginFrameSourceTest,
        SetNeedsBeginFramesCallsOnBeginFrameWithMissedTick) {
-  now_src_->SetNowMicroseconds(10010);
+  now_src_->Advance(base::TimeDelta::FromInternalValue(9010));
   EXPECT_CALL((*obs_), OnBeginFrame(CreateBeginFrameArgsForTesting(
                            BEGINFRAME_FROM_HERE, 10000, 20000, 10000,
                            BeginFrameArgs::MISSED)));
   source_->SetNeedsBeginFrames(true);  // Should cause the last tick to be sent
   // No tasks should need to be run for this to occur.
 }
 
 TEST_F(SyntheticBeginFrameSourceTest,
        SetNeedsBeginFramesCallsCausesOnBeginFrame) {
   source_->SetNeedsBeginFrames(true);
   EXPECT_EQ(10000, task_runner_->NextTaskTime().ToInternalValue());
 
   EXPECT_BEGIN_FRAME_USED(*obs_, 10000, 20000, 10000);
-  now_src_->SetNowMicroseconds(10010);
+  now_src_->Advance(base::TimeDelta::FromInternalValue(9010));
   task_runner_->RunPendingTasks();
 }
 
 TEST_F(SyntheticBeginFrameSourceTest, BasicOperation) {
   task_runner_->SetAutoAdvanceNowToPendingTasks(true);
 
   source_->SetNeedsBeginFrames(true);
   EXPECT_BEGIN_FRAME_USED(*obs_, 10000, 20000, 10000);
   EXPECT_BEGIN_FRAME_USED(*obs_, 20000, 30000, 10000);
   EXPECT_BEGIN_FRAME_USED(*obs_, 30000, 40000, 10000);
@@ skipping 217 matching lines @@
   mux_->SetActiveSource(source2_);
   SEND_BEGIN_FRAME_DROP(*source2_, 750, 1050, 300);
   SEND_BEGIN_FRAME_USED(*source2_, 1050, 1250, 300);
 
   mux_->SetActiveSource(source1_);
   SEND_BEGIN_FRAME_DROP(*source2_, 1100, 1400, 300);
 }
 
 }  // namespace
 }  // namespace cc