Revert of Implement timers by posting delayed tasks

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 "config.h"
 #include "platform/Timer.h"
 
 #include "public/platform/Platform.h"
 #include "public/platform/WebScheduler.h"
 #include "public/platform/WebThread.h"
 #include <gmock/gmock.h>
 #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(WebThread::Task* task) : m_task(adoptPtr(task)) { }
-
-    ~RefCountedTaskContainer() { }
-
-    void run()
-    {
-        m_task->run();
-    }
-
-private:
-    OwnPtr<WebThread::Task> m_task;
-};
-
-class DelayedTask {
-public:
-    DelayedTask(WebThread::Task* task, long long delayMs)
-        : m_task(adoptRef(new RefCountedTaskContainer(task)))
-        , m_runTimeSecs(monotonicallyIncreasingTime() + 0.001 * static_cast<double>(delayMs))
-        , m_delayMs(delayMs) { }
-
-    bool operator<(const DelayedTask& other) const
-    {
-        return m_runTimeSecs > other.m_runTimeSecs;
-    }
-
-    void run() const
-    {
-        m_task->run();
-    }
-
-    double runTimeSecs() const
-    {
-        return m_runTimeSecs;
-    }
-
-    long long delayMs() const
-    {
-        return m_delayMs;
-    }
-
-private:
-    RefPtr<RefCountedTaskContainer> m_task;
-    double m_runTimeSecs;
-    long long m_delayMs;
-};
-
 class MockWebScheduler : public WebScheduler {
 public:
-    MockWebScheduler() { }
+    explicit MockWebScheduler() { }
     ~MockWebScheduler() override { }
 
     bool shouldYieldForHighPriorityWork() override
     {
         return false;
     }
 
     bool canExceedIdleDeadlineIfRequired() override
     {
         return false;
@@ skipping 10 matching lines @@
     void postIdleTaskAfterWakeup(const WebTraceLocation&, WebThread::IdleTask*) override
     {
     }
 
     void postLoadingTask(const WebTraceLocation&, WebThread::Task*) override
     {
     }
 
     void postTimerTask(const WebTraceLocation&, WebThread::Task* task, long long delayMs) override
     {
-        m_timerTasks.push(DelayedTask(task, delayMs));
     }
-
-    void runUntilIdle()
-    {
-        while (!m_timerTasks.empty()) {
-            gCurrentTimeSecs = m_timerTasks.top().runTimeSecs();
-            m_timerTasks.top().run();
-            m_timerTasks.pop();
-        }
-    }
-
-    void runUntilIdleOrDeadlinePassed(double deadline)
-    {
-        while (!m_timerTasks.empty()) {
-            if (m_timerTasks.top().runTimeSecs() > deadline) {
-                gCurrentTimeSecs = deadline;
-                break;
-            }
-            gCurrentTimeSecs = m_timerTasks.top().runTimeSecs();
-            m_timerTasks.top().run();
-            m_timerTasks.pop();
-        }
-    }
-
-    bool hasOneTimerTask() const
-    {
-        return m_timerTasks.size() == 1;
-    }
-
-    long nextTimerTaskDelayMillis() const
-    {
-        ASSERT(hasOneTimerTask());
-        return m_timerTasks.top().delayMs();
-    }
-
-private:
-    std::priority_queue<DelayedTask> m_timerTasks;
 };
 
 class FakeWebThread : public WebThread {
 public:
-    FakeWebThread() : m_webScheduler(adoptPtr(new MockWebScheduler())) { }
+    explicit FakeWebThread(WebScheduler* webScheduler) : m_webScheduler(webScheduler) { }
     ~FakeWebThread() override { }
 
     // WebThread implementation:
     void postTask(const WebTraceLocation&, Task*)
     {
         ASSERT_NOT_REACHED();
     }
 
     virtual void postDelayedTask(const WebTraceLocation&, Task*, long long)
     {
         ASSERT_NOT_REACHED();
     }
 
     virtual bool isCurrentThread() const
     {
         ASSERT_NOT_REACHED();
         return true;
     }
 
     virtual PlatformThreadId threadId() const
     {
         ASSERT_NOT_REACHED();
         return 0;
     }
 
     WebScheduler* scheduler() const override
     {
-        return m_webScheduler.get();
+        return m_webScheduler;
     }
 
     virtual void enterRunLoop()
     {
         ASSERT_NOT_REACHED();
     }
 
     virtual void exitRunLoop()
     {
         ASSERT_NOT_REACHED();
     }
 
 private:
-    OwnPtr<MockWebScheduler> m_webScheduler;
+    WebScheduler* m_webScheduler;
 };
 
 class TimerTestPlatform : public Platform {
 public:
-    TimerTestPlatform()
-        : m_webThread(adoptPtr(new FakeWebThread())) { }
+    explicit TimerTestPlatform(WebThread* webThread)
+        : m_webThread(webThread)
+        , m_timerInterval(-1) { }
     ~TimerTestPlatform() override { }
 
     WebThread* currentThread() override
     {
-        return m_webThread.get();
+        return m_webThread;
     }
 
     void cryptographicallyRandomValues(unsigned char*, size_t) override
     {
         ASSERT_NOT_REACHED();
     }
 
     const unsigned char* getTraceCategoryEnabledFlag(const char* categoryName) override
     {
         static const unsigned char enabled[] = {0};
         return enabled;
     }
 
+    void setSharedTimerFiredFunction(SharedTimerFunction timerFunction) override
+    {
+        s_timerFunction = timerFunction;
+    }
+
+    void setSharedTimerFireInterval(double interval) override
+    {
+        m_timerInterval = interval;
+    }
+
+    virtual void stopSharedTimer() override
+    {
+        m_timerInterval = -1;
+    }
+
     void runUntilIdle()
     {
-        mockScheduler()->runUntilIdle();
+        while (hasOneTimerTask()) {
+            gCurrentTimeSecs += m_timerInterval;
+            s_timerFunction();
+        }
     }
 
     void runUntilIdleOrDeadlinePassed(double deadline)
     {
-        mockScheduler()->runUntilIdleOrDeadlinePassed(deadline);
+        while (hasOneTimerTask()) {
+            double newTime = gCurrentTimeSecs + m_timerInterval;
+            if (newTime >= deadline) {
+                gCurrentTimeSecs = deadline;
+                break;
+            }
+            gCurrentTimeSecs = newTime;
+            s_timerFunction();
+        }
     }
 
     bool hasOneTimerTask() const
     {
-        return mockScheduler()->hasOneTimerTask();
+        return s_timerFunction && m_timerInterval >= 0;
     }
 
     long nextTimerTaskDelayMillis() const
     {
-        return mockScheduler()->nextTimerTaskDelayMillis();
+        ASSERT(hasOneTimerTask());
+        return static_cast<long>(m_timerInterval * 1000);
     }
 
 private:
-    MockWebScheduler* mockScheduler() const
-    {
-        return static_cast<MockWebScheduler*>(m_webThread->scheduler());
-    }
+    WebThread* m_webThread;
+    double m_timerInterval;
 
-    OwnPtr<FakeWebThread> m_webThread;
+    // This needs to be static because the callback is registered only once by
+    // PlatformThreadData.
+    static SharedTimerFunction s_timerFunction;
 };
 
+Platform::SharedTimerFunction TimerTestPlatform::s_timerFunction;
+
 class TimerTest : public testing::Test {
 public:
     void SetUp() override
     {
-        m_platform = adoptPtr(new TimerTestPlatform());
+        m_mockWebScheduler = adoptPtr(new MockWebScheduler());
+        m_fakeWebThread = adoptPtr(new FakeWebThread(m_mockWebScheduler.get()));
+        m_platform = adoptPtr(new TimerTestPlatform(m_fakeWebThread.get()));
         m_oldPlatform = Platform::current();
         Platform::initialize(m_platform.get());
         WTF::setMonotonicallyIncreasingTimeFunction(currentTime);
 
         m_runTimes.clear();
         gCurrentTimeSecs = 10.0;
         m_startTime = gCurrentTimeSecs;
     }
 
     void TearDown() override
@@ skipping 29 matching lines @@
     long nextTimerTaskDelayMillis() const
     {
         return m_platform->nextTimerTaskDelayMillis();
     }
 
 protected:
     double m_startTime;
     std::vector<double> m_runTimes;
 
 private:
+    OwnPtr<MockWebScheduler> m_mockWebScheduler;
+    OwnPtr<FakeWebThread> m_fakeWebThread;
     OwnPtr<TimerTestPlatform> m_platform;
     Platform* m_oldPlatform;
 };
 
 TEST_F(TimerTest, StartOneShot_Zero)
 {
     Timer<TimerTest> timer(this, &TimerTest::countingTask);
     timer.startOneShot(0, FROM_HERE);
 
     ASSERT(hasOneTimerTask());
@@ skipping 407 matching lines @@
     MockTimerWithAlignment timer;
     timer.setAlignedFireTime(m_startTime + 1.0);
 
     timer.start(0.0, 0.0, FROM_HERE);
 
     EXPECT_FLOAT_EQ(1.0, timer.nextFireInterval());
     EXPECT_FLOAT_EQ(0.0, timer.nextUnalignedFireInterval());
     EXPECT_FLOAT_EQ(m_startTime, timer.lastFireTime());
 
     timer.setAlignedFireTime(m_startTime);
-    timer.didChangeAlignmentInterval(monotonicallyIncreasingTime());
+    timer.didChangeAlignmentInterval();
 
     EXPECT_FLOAT_EQ(0.0, timer.nextFireInterval());
     EXPECT_FLOAT_EQ(0.0, timer.nextUnalignedFireInterval());
     EXPECT_FLOAT_EQ(m_startTime, timer.lastFireTime());
 }
 
 
 } // namespace
 } // namespace blink