Introduce WebTaskRunner Patch 3/5

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)) { }
+    explicit RefCountedTaskContainer(WebTaskRunner::Task* task) : m_task(adoptPtr(task)) { }
 
     ~RefCountedTaskContainer() { }
 
     void run()
     {
         m_task->run();
     }
 
 private:
-    OwnPtr<WebThread::Task> m_task;
+    OwnPtr<WebTaskRunner::Task> m_task;
 };
 
 class DelayedTask {
 public:
-    DelayedTask(WebThread::Task* task, long long delayMs)
+    DelayedTask(WebTaskRunner::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
@@ skipping 10 matching lines @@
     {
         return m_delayMs;
     }
 
 private:
     RefPtr<RefCountedTaskContainer> m_task;
     double m_runTimeSecs;
     long long m_delayMs;
 };
 
+class MockWebTaskRunner : public WebTaskRunner {
+public:
+    explicit MockWebTaskRunner(std::priority_queue<DelayedTask>* timerTasks) : m_timerTasks(timerTasks) { }
+    ~MockWebTaskRunner() override { }
+
+    virtual void postTask(const WebTraceLocation&, Task* task)
+    {
+        m_timerTasks->push(DelayedTask(task, 0));
+    }
+
+    void postDelayedTask(const WebTraceLocation&, Task* task, long long delayMs) override
+    {
+        m_timerTasks->push(DelayedTask(task, delayMs));
+    }
+
+    std::priority_queue<DelayedTask>* m_timerTasks; // NOT OWNED
+};
+
 class MockWebScheduler : public WebScheduler {
 public:
-    MockWebScheduler() { }
+    MockWebScheduler() : m_timerWebTaskRunner(&m_timerTasks) { }
     ~MockWebScheduler() override { }
 
     bool shouldYieldForHighPriorityWork() override
     {
         return false;
     }
 
     bool canExceedIdleDeadlineIfRequired() override
     {
         return false;
     }
 
     void postIdleTask(const WebTraceLocation&, WebThread::IdleTask*) override
     {
     }
 
     void postNonNestableIdleTask(const WebTraceLocation&, WebThread::IdleTask*) override
     {
     }
 
     void postIdleTaskAfterWakeup(const WebTraceLocation&, WebThread::IdleTask*) override
     {
     }
 
-    void postLoadingTask(const WebTraceLocation&, WebThread::Task*) override
+    WebTaskRunner* timerTaskRunner() override
     {
+        return &m_timerWebTaskRunner;
     }
 
-    void postTimerTask(const WebTraceLocation&, WebThread::Task* task, long long delayMs) override
+    WebTaskRunner* loadingTaskRunner() override
     {
-        m_timerTasks.push(DelayedTask(task, delayMs));
+        ASSERT_NOT_REACHED();
+        return nullptr;
     }
 
-    void postTimerTaskAt(const WebTraceLocation&, WebThread::Task* task, double monotonicTime) override
+    void postTimerTaskAt(const WebTraceLocation&, WebTaskRunner::Task* task, double monotonicTime) override
     {
         m_timerTasks.push(DelayedTask(task, (monotonicTime - monotonicallyIncreasingTime()) * 1000));
     }
 
     void runUntilIdle()
     {
         while (!m_timerTasks.empty()) {
             gCurrentTimeSecs = m_timerTasks.top().runTimeSecs();
             m_timerTasks.top().run();
             m_timerTasks.pop();
@@ skipping 19 matching lines @@
     }
 
     long nextTimerTaskDelayMillis() const
     {
         ASSERT(hasOneTimerTask());
         return m_timerTasks.top().delayMs();
     }
 
 private:
     std::priority_queue<DelayedTask> m_timerTasks;
+    MockWebTaskRunner m_timerWebTaskRunner;
 };
 
 class FakeWebThread : public WebThread {
 public:
     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;
     }
 
+    WebTaskRunner* taskRunner() override
+    {
+        ASSERT_NOT_REACHED();
+        return nullptr;
+    }
+
     WebScheduler* scheduler() const override
     {
         return m_webScheduler.get();
     }
 
     virtual void enterRunLoop()
     {
         ASSERT_NOT_REACHED();
     }
 
@@ skipping 541 matching lines @@
     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