[Reland] Per WebViewScheduler virtual time

third_party/WebKit/Source/platform/TimerTest.cpp

 // Copyright 2015 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 "platform/Timer.h"
 
 #include "platform/testing/TestingPlatformSupport.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebScheduler.h"
 #include "public/platform/WebThread.h"
 #include "public/platform/WebViewScheduler.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include <queue>
 
 using testing::ElementsAre;
 
 namespace blink {
 namespace {
 double gCurrentTimeSecs = 0.0;
 
-double currentTime()
-{
-    return gCurrentTimeSecs;
-}
-
 // This class exists because gcc doesn't know how to move an OwnPtr.
 class RefCountedTaskContainer : public RefCounted<RefCountedTaskContainer> {
 public:
     explicit RefCountedTaskContainer(WebTaskRunner::Task* task) : m_task(adoptPtr(task)) { }
 
     ~RefCountedTaskContainer() { }
 
     void run()
     {
         m_task->run();
     }
 
 private:
     OwnPtr<WebTaskRunner::Task> m_task;
 };
 
 class DelayedTask {
 public:
     DelayedTask(WebTaskRunner::Task* task, double delaySeconds)
         : m_task(adoptRef(new RefCountedTaskContainer(task)))
-        , m_runTimeSeconds(monotonicallyIncreasingTime() + delaySeconds)
-        , m_delaySeconds(delaySeconds) { }
+        , m_runTimeSeconds(gCurrentTimeSecs + delaySeconds)
+        , m_delaySeconds(delaySeconds)
+    {
+    }
 
     bool operator<(const DelayedTask& other) const
     {
         return m_runTimeSeconds > other.m_runTimeSeconds;
     }
 
     void run() const
     {
         m_task->run();
     }
@@ skipping 28 matching lines @@
     {
         m_timerTasks->push(DelayedTask(task, delayMs * 0.001));
     }
 
     WebTaskRunner* clone() override
     {
         ASSERT_NOT_REACHED();
         return nullptr;
     }
 
+    double virtualTimeSeconds() const override
+    {
+        ASSERT_NOT_REACHED();
+        return 0.0;
+    }
+
+    double monotonicallyIncreasingVirtualTimeSeconds() const override
+    {
+        return gCurrentTimeSecs;
+    }
+
     std::priority_queue<DelayedTask>* m_timerTasks; // NOT OWNED
 };
 
 class MockWebScheduler : public WebScheduler {
 public:
     MockWebScheduler() : m_timerWebTaskRunner(&m_timerTasks) { }
     ~MockWebScheduler() override { }
 
     bool shouldYieldForHighPriorityWork() override
     {
@@ skipping 166 matching lines @@
         return static_cast<MockWebScheduler*>(m_webThread->scheduler());
     }
 
     OwnPtr<FakeWebThread> m_webThread;
 };
 
 class TimerTest : public testing::Test {
 public:
     void SetUp() override
     {
-        m_originalTimeFunction = setTimeFunctionsForTesting(currentTime);
-
         m_runTimes.clear();
         gCurrentTimeSecs = 10.0;
         m_startTime = gCurrentTimeSecs;
     }
 
-    void TearDown() override
-    {
-        setTimeFunctionsForTesting(m_originalTimeFunction);
-    }
-
     void countingTask(Timer<TimerTest>*)
     {
-        m_runTimes.append(monotonicallyIncreasingTime());
+        m_runTimes.append(gCurrentTimeSecs);
     }
 
     void recordNextFireTimeTask(Timer<TimerTest>* timer)
     {
-        m_nextFireTimes.append(monotonicallyIncreasingTime() + timer->nextFireInterval());
+        m_nextFireTimes.append(gCurrentTimeSecs + timer->nextFireInterval());
     }
 
     void advanceTimeBy(double timeSecs)
     {
         gCurrentTimeSecs += timeSecs;
     }
 
     void runUntilIdle()
     {
         m_platform.runUntilIdle();
@@ skipping 19 matching lines @@
         return m_platform.nextTimerTaskDelaySecs();
     }
 
 protected:
     double m_startTime;
     WTF::Vector<double> m_runTimes;
     WTF::Vector<double> m_nextFireTimes;
 
 private:
     TimerTestPlatform m_platform;
-    TimeFunction m_originalTimeFunction;
 };
 
 TEST_F(TimerTest, StartOneShot_Zero)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
     timer.startOneShot(0, BLINK_FROM_HERE);
 
     ASSERT(hasOneTimerTask());
     EXPECT_FLOAT_EQ(0.0, nextTimerTaskDelaySecs());
 
@@ skipping 89 matching lines @@
     timer.startOneShot(10, BLINK_FROM_HERE);
 
     ASSERT(hasOneTimerTask());
     EXPECT_FLOAT_EQ(10.0, nextTimerTaskDelaySecs());
 
     timer.stop();
 
     runUntilIdle();
     EXPECT_FALSE(m_runTimes.size());
 
-    double secondPostTime = monotonicallyIncreasingTime();
+    double secondPostTime = gCurrentTimeSecs;
     timer.startOneShot(10, BLINK_FROM_HERE);
 
     ASSERT(hasOneTimerTask());
     EXPECT_FLOAT_EQ(10.0, nextTimerTaskDelaySecs());
 
     runUntilIdle();
     EXPECT_THAT(m_runTimes, ElementsAre(secondPostTime + 10.0));
 }
 
 TEST_F(TimerTest, StartOneShot_NonZero_RepostingAfterRunning)
@@ skipping 297 matching lines @@
     TimerForTest<TimerTest> timer(this, &TimerTest::countingTask, &taskRunner);
     timer.startOneShot(0, BLINK_FROM_HERE);
 
     // Make sure the task was posted on taskRunner.
     EXPECT_FALSE(timerTasks.empty());
 }
 
 
 } // namespace
 } // namespace blink