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:
-    explicit MockWebScheduler() { }
+    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:
-    explicit FakeWebThread(WebScheduler* webScheduler) : m_webScheduler(webScheduler) { }
+    FakeWebThread() : m_webScheduler(adoptPtr(new MockWebScheduler())) { }
     ~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;
+        return m_webScheduler.get();
     }
 
     virtual void enterRunLoop()
     {
         ASSERT_NOT_REACHED();
     }
 
     virtual void exitRunLoop()
     {
         ASSERT_NOT_REACHED();
     }
 
 private:
-    WebScheduler* m_webScheduler;
+    OwnPtr<MockWebScheduler> m_webScheduler;
 };
 
 class TimerTestPlatform : public Platform {
 public:
-    explicit TimerTestPlatform(WebThread* webThread)
-        : m_webThread(webThread)
-        , m_timerInterval(-1) { }
+    TimerTestPlatform()
+        : m_webThread(adoptPtr(new FakeWebThread())) { }
     ~TimerTestPlatform() override { }
 
     WebThread* currentThread() override
     {
-        return m_webThread;
+        return m_webThread.get();
     }
 
     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()
     {
-        while (hasOneTimerTask()) {
-            gCurrentTimeSecs += m_timerInterval;
-            s_timerFunction();
-        }
+        mockScheduler()->runUntilIdle();
     }
 
     void runUntilIdleOrDeadlinePassed(double deadline)
     {
-        while (hasOneTimerTask()) {
-            double newTime = gCurrentTimeSecs + m_timerInterval;
-            if (newTime >= deadline) {
-                gCurrentTimeSecs = deadline;
-                break;
-            }
-            gCurrentTimeSecs = newTime;
-            s_timerFunction();
-        }
+        mockScheduler()->runUntilIdleOrDeadlinePassed(deadline);
     }
 
     bool hasOneTimerTask() const
     {
-        return s_timerFunction && m_timerInterval >= 0;
+        return mockScheduler()->hasOneTimerTask();
     }
 
     long nextTimerTaskDelayMillis() const
     {
-        ASSERT(hasOneTimerTask());
-        return static_cast<long>(m_timerInterval * 1000);
+        return mockScheduler()->nextTimerTaskDelayMillis();
     }
 
 private:
-    WebThread* m_webThread;
-    double m_timerInterval;
+    MockWebScheduler* mockScheduler() const
+    {
+        return static_cast<MockWebScheduler*>(m_webThread->scheduler());
+    }
 
-    // This needs to be static because the callback is registered only once by
-    // PlatformThreadData.
-    static SharedTimerFunction s_timerFunction;
+    OwnPtr<FakeWebThread> m_webThread;
 };
 
-Platform::SharedTimerFunction TimerTestPlatform::s_timerFunction;
-
 class TimerTest : public testing::Test {
 public:
     void SetUp() override
     {
-        m_mockWebScheduler = adoptPtr(new MockWebScheduler());
-        m_fakeWebThread = adoptPtr(new FakeWebThread(m_mockWebScheduler.get()));
-        m_platform = adoptPtr(new TimerTestPlatform(m_fakeWebThread.get()));
+        m_platform = adoptPtr(new TimerTestPlatform());
         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();
+    timer.didChangeAlignmentInterval(monotonicallyIncreasingTime());
 
     EXPECT_FLOAT_EQ(0.0, timer.nextFireInterval());
     EXPECT_FLOAT_EQ(0.0, timer.nextUnalignedFireInterval());
     EXPECT_FLOAT_EQ(m_startTime, timer.lastFireTime());
 }
 
 
 } // namespace
 } // namespace blink