Introduce WebTaskRunner Patch 3/5

Source/core/dom/ScriptRunnerTest.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 "core/dom/ScriptRunner.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/ScriptLoader.h"
@@ skipping 21 matching lines @@
     explicit MockScriptLoader(Element* element) : ScriptLoader(element, false, false)
     {
     }
 };
 
 class MockWebThread : public WebThread {
 public:
     explicit MockWebThread(WebScheduler* webScheduler) : m_webScheduler(webScheduler) { }
     ~MockWebThread() override { }
 
-    void postTask(const WebTraceLocation&, Task*) override { ASSERT_NOT_REACHED(); }
-    void postDelayedTask(const WebTraceLocation&, Task*, long long) override { ASSERT_NOT_REACHED(); }
-
     bool isCurrentThread() const override
     {
         ASSERT_NOT_REACHED();
         return false;
     }
 
     PlatformThreadId threadId() const override
     {
         ASSERT_NOT_REACHED();
         return 0;
     }
 
+    WebTaskRunner* taskRunner() override
+    {
+        ASSERT_NOT_REACHED();
+        return nullptr;
+    }
+
     void addTaskObserver(TaskObserver*) override { ASSERT_NOT_REACHED(); }
     void removeTaskObserver(TaskObserver*) override { ASSERT_NOT_REACHED(); }
 
     WebScheduler* scheduler() const override { return m_webScheduler; }
 
 private:
     WebScheduler* m_webScheduler;
 };
 
+class MockWebTaskRunner : public WebTaskRunner {
+public:
+    explicit MockWebTaskRunner(Deque<OwnPtr<WebTaskRunner::Task>>* tasks) : m_tasks(tasks) { }
+    ~MockWebTaskRunner() override { }
+
+    virtual void postTask(const WebTraceLocation&, Task* task)
+    {
+        m_tasks->append(adoptPtr(task));
+    }
+
+    void postDelayedTask(const WebTraceLocation&, Task* task, long long delayMs) override
+    {
+        ASSERT_NOT_REACHED();
+    }
+
+    Deque<OwnPtr<WebTaskRunner::Task>>* m_tasks; // NOT OWNED
+};
+
 class MockPlatform : public Platform, private WebScheduler {
 public:
-    MockPlatform() : m_mockWebThread(this), m_shouldYield(false), m_shouldYieldEveryOtherTime(false) { }
-
-    void postLoadingTask(const WebTraceLocation&, WebThread::Task* task) override
-    {
-        m_tasks.append(adoptPtr(task));
-    }
+    MockPlatform()
+        : m_mockWebThread(this)
+        , m_mockWebTaskRunner(&m_tasks)
+        , m_shouldYield(false)
+        , m_shouldYieldEveryOtherTime(false) { }
 
     void cryptographicallyRandomValues(unsigned char* buffer, size_t length) override { }
 
     WebThread* currentThread() override { return &m_mockWebThread; }
 
+    WebTaskRunner* loadingTaskRunner() override
+    {
+        return &m_mockWebTaskRunner;
+    }
+
+    WebTaskRunner* timerTaskRunner() override
+    {
+        ASSERT_NOT_REACHED();
+        return nullptr;
+    }
+
     void runSingleTask()
     {
         if (m_tasks.isEmpty())
             return;
         m_tasks.takeFirst()->run();
     }
 
     void runAllTasks()
     {
         while (!m_tasks.isEmpty())
@@ skipping 13 matching lines @@
     }
 
     // NOTE if we yield 100% of the time, nothing will get run.
     void setShouldYieldEveryOtherTime(bool shouldYieldEveryOtherTime)
     {
         m_shouldYieldEveryOtherTime = shouldYieldEveryOtherTime;
     }
 
 private:
     MockWebThread m_mockWebThread;
-    Deque<OwnPtr<WebThread::Task>> m_tasks;
+    Deque<OwnPtr<WebTaskRunner::Task>> m_tasks;
+    MockWebTaskRunner m_mockWebTaskRunner;
     bool m_shouldYield;
     bool m_shouldYieldEveryOtherTime;
 };
 
 class ScriptRunnerTest : public testing::Test {
 public:
     void SetUp() override
     {
         m_document = Document::create();
         m_element = m_document->createElement("foo", ASSERT_NO_EXCEPTION);
@@ skipping 416 matching lines @@
     testing::Mock::VerifyAndClear(scriptLoader2.get());
     testing::Mock::VerifyAndClear(scriptLoader3.get());
     EXPECT_CALL(*scriptLoader2, execute()).Times(1);
     EXPECT_CALL(*scriptLoader3, execute()).Times(1);
     EXPECT_CALL(*scriptLoader2, isReady()).WillRepeatedly(Return(true));
     EXPECT_CALL(*scriptLoader3, isReady()).WillRepeatedly(Return(true));
     m_platform.runAllTasks();
 }
 
 } // namespace blink