Patch 2/3 to get WebScheduler via WebThread

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"
-#include "platform/scheduler/Scheduler.h"
 #include "public/platform/Platform.h"
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
 using ::testing::Invoke;
 using ::testing::ElementsAre;
 using ::testing::Return;
 
 namespace blink {
 
 class MockScriptLoader: public ScriptLoader {
 public:
     explicit MockScriptLoader(Element* element) : ScriptLoader(element, false, false) { }
 
     ~MockScriptLoader() override { }
 
     MOCK_METHOD0(execute, void());
     MOCK_CONST_METHOD0(isReady, bool());
 };
 
+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;
+    }
+
+    void addTaskObserver(TaskObserver*) override { ASSERT_NOT_REACHED(); }
+    void removeTaskObserver(TaskObserver*) override { ASSERT_NOT_REACHED(); }
+
+    WebScheduler* scheduler() const override { return m_webScheduler; }
+
+    void enterRunLoop() override { ASSERT_NOT_REACHED(); }
+    void exitRunLoop() override { ASSERT_NOT_REACHED(); }
+
+private:
+    WebScheduler* m_webScheduler;
+};
+
 class MockPlatform : public Platform, private WebScheduler {
 public:
-    MockPlatform() : m_shouldYield(false), m_shouldYieldEveryOtherTime(false) { }
-
-    WebScheduler* scheduler() override
-    {
-        return this;
-    }
+    MockPlatform() : m_mockWebThread(this), m_shouldYield(false), m_shouldYieldEveryOtherTime(false) { }
 
     void postLoadingTask(const WebTraceLocation&, WebThread::Task* task) override
     {
         m_tasks.append(adoptPtr(task));
     }
 
     void cryptographicallyRandomValues(unsigned char* buffer, size_t length) override { }
 
+    WebThread* currentThread() override { return &m_mockWebThread; }
+
     void runSingleTask()
     {
         if (m_tasks.isEmpty())
             return;
         m_tasks.takeFirst()->run();
     }
 
     void runAllTasks()
     {
         while (!m_tasks.isEmpty())
@@ skipping 12 matching lines @@
         m_shouldYield = shouldYield;
     }
 
     // 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;
     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);
 
         m_scriptRunner = ScriptRunner::create(m_document.get());
         m_oldPlatform = Platform::current();
-        m_oldScheduler = Scheduler::shared();
 
         // Force Platform::initialize to create a new one pointing at MockPlatform.
-        Scheduler::setForTesting(nullptr);
         Platform::initialize(&m_platform);
         m_platform.setShouldYield(false);
         m_platform.setShouldYieldEveryOtherTime(false);
     }
 
     void TearDown() override
     {
         m_scriptRunner.release();
-        Scheduler::shutdown();
-        Scheduler::setForTesting(m_oldScheduler);
         Platform::initialize(m_oldPlatform);
     }
 
     RefPtrWillBePersistent<Document> m_document;
     RefPtrWillBePersistent<Element> m_element;
     OwnPtrWillBePersistent<ScriptRunner> m_scriptRunner;
     std::vector<int> m_order; // gmock matchers don't work nicely with WTF::Vector
     MockPlatform m_platform;
     Platform* m_oldPlatform; // NOT OWNED
-    Scheduler* m_oldScheduler; // NOT OWNED
 };
 
 TEST_F(ScriptRunnerTest, QueueSingleScript_Async)
 {
     MockScriptLoader scriptLoader(m_element.get());
     m_scriptRunner->queueScriptForExecution(&scriptLoader, ScriptRunner::ASYNC_EXECUTION);
     m_scriptRunner->notifyScriptReady(&scriptLoader, ScriptRunner::ASYNC_EXECUTION);
 
     EXPECT_CALL(scriptLoader, execute());
     m_platform.runAllTasks();
@@ skipping 380 matching lines @@
     testing::Mock::VerifyAndClear(&scriptLoader2);
     testing::Mock::VerifyAndClear(&scriptLoader3);
     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