Source/core/dom/ScriptRunnerTest.cpp - Issue 936493003: Revert of Teach ScriptRunner how to yield and post on loading task queue

Unified Diff: Source/core/dom/ScriptRunnerTest.cpp

Issue 936493003: Revert of Teach ScriptRunner how to yield and post on loading task queue (Closed) Base URL: https://chromium.googlesource.com/chromium/blink.git@master

Patch Set: Created 5 years, 10 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: Source/core/dom/ScriptRunnerTest.cpp

diff --git a/Source/core/dom/ScriptRunnerTest.cpp b/Source/core/dom/ScriptRunnerTest.cpp

deleted file mode 100644

index 6ed5b093bf7590f899900ff5b300c29ac8593d5f..0000000000000000000000000000000000000000

--- a/Source/core/dom/ScriptRunnerTest.cpp

+++ /dev/null

@@ -1,468 +0,0 @@

-// 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/ScriptLoader.h"

-#include "platform/heap/Handle.h"

-#include "platform/scheduler/Scheduler.h"

-#include "public/platform/Platform.h"

-#include "wtf/PassOwnPtr.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 MockPlatform : public Platform, private WebScheduler {

-public:

- MockPlatform() : m_shouldYield(false), m_shouldYieldEveryOtherTime(false) { }

- WebScheduler* scheduler() override

- {

- return this;

- }

- void postLoadingTask(const WebTraceLocation&, WebThread::Task* task) override

- {

- m_tasks.append(adoptPtr(task));

- }

- void cryptographicallyRandomValues(unsigned char* buffer, size_t length) override { }

- void runSingleTask()

- {

- if (m_tasks.isEmpty())

- return;

- m_tasks.takeFirst()->run();

- }

- void runAllTasks()

- {

- while (!m_tasks.isEmpty())

- m_tasks.takeFirst()->run();

- }

- bool shouldYieldForHighPriorityWork() override

- {

- if (m_shouldYieldEveryOtherTime)

- m_shouldYield = !m_shouldYield;

- return m_shouldYield;

- }

- void setShouldYield(bool shouldYield)

- {

- m_shouldYield = shouldYield;

- }

- // NOTE if we yield 100% of the time, nothing will get run.

- void setShouldYieldEveryOtherTime(bool shouldYieldEveryOtherTime)

- {

- m_shouldYieldEveryOtherTime = shouldYieldEveryOtherTime;

- }

-private:

- 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();

- Platform::initialize(&m_platform);

- m_platform.setShouldYield(false);

- m_platform.setShouldYieldEveryOtherTime(false);

- }

- void TearDown() override

- {

- m_scriptRunner.release();

- Scheduler::shutdown();

- 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;

-};

-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();

-TEST_F(ScriptRunnerTest, QueueSingleScript_InOrder)

- MockScriptLoader scriptLoader(m_element.get());

- m_scriptRunner->queueScriptForExecution(&scriptLoader, ScriptRunner::IN_ORDER_EXECUTION);

- m_scriptRunner->resume();

- EXPECT_CALL(scriptLoader, isReady()).WillOnce(Return(true));

- EXPECT_CALL(scriptLoader, execute());

- m_platform.runAllTasks();

-TEST_F(ScriptRunnerTest, QueueMultipleScripts_InOrder)

- MockScriptLoader scriptLoader1(m_element.get());

- MockScriptLoader scriptLoader2(m_element.get());

- MockScriptLoader scriptLoader3(m_element.get());

- m_scriptRunner->queueScriptForExecution(&scriptLoader1, ScriptRunner::IN_ORDER_EXECUTION);

- m_scriptRunner->queueScriptForExecution(&scriptLoader2, ScriptRunner::IN_ORDER_EXECUTION);

- m_scriptRunner->queueScriptForExecution(&scriptLoader3, ScriptRunner::IN_ORDER_EXECUTION);

- EXPECT_CALL(scriptLoader1, execute()).WillOnce(Invoke([this] {

- m_order.push_back(1);

- }));

- EXPECT_CALL(scriptLoader2, execute()).WillOnce(Invoke([this] {

- m_order.push_back(2);

- }));

- EXPECT_CALL(scriptLoader3, execute()).WillOnce(Invoke([this] {

- m_order.push_back(3);

- }));

- // Make the scripts become ready in reverse order.

- bool isReady[] = { false, false, false };

- EXPECT_CALL(scriptLoader1, isReady()).WillRepeatedly(Invoke([&isReady] {

- return isReady[0];

- }));

- EXPECT_CALL(scriptLoader2, isReady()).WillRepeatedly(Invoke([&isReady] {

- return isReady[1];

- }));

- EXPECT_CALL(scriptLoader3, isReady()).WillRepeatedly(Invoke([&isReady] {

- return isReady[2];

- }));

- for (int i = 2; i >= 0; i--) {

- isReady[i] = true;

- m_scriptRunner->resume();

- m_platform.runAllTasks();

- }

- // But ensure the scripts were run in the expected order.

- EXPECT_THAT(m_order, ElementsAre(1, 2, 3));

-TEST_F(ScriptRunnerTest, QueueMixedScripts)

- MockScriptLoader scriptLoader1(m_element.get());

- MockScriptLoader scriptLoader2(m_element.get());

- MockScriptLoader scriptLoader3(m_element.get());

- MockScriptLoader scriptLoader4(m_element.get());

- MockScriptLoader scriptLoader5(m_element.get());

- EXPECT_CALL(scriptLoader1, isReady()).WillRepeatedly(Return(true));

- EXPECT_CALL(scriptLoader2, isReady()).WillRepeatedly(Return(true));

- EXPECT_CALL(scriptLoader3, isReady()).WillRepeatedly(Return(true));

- m_scriptRunner->queueScriptForExecution(&scriptLoader1, ScriptRunner::IN_ORDER_EXECUTION);

- m_scriptRunner->queueScriptForExecution(&scriptLoader2, ScriptRunner::IN_ORDER_EXECUTION);

- m_scriptRunner->queueScriptForExecution(&scriptLoader3, ScriptRunner::IN_ORDER_EXECUTION);

- m_scriptRunner->queueScriptForExecution(&scriptLoader4, ScriptRunner::ASYNC_EXECUTION);

- m_scriptRunner->queueScriptForExecution(&scriptLoader5, ScriptRunner::ASYNC_EXECUTION);

- m_scriptRunner->notifyScriptReady(&scriptLoader4, ScriptRunner::ASYNC_EXECUTION);

- m_scriptRunner->notifyScriptReady(&scriptLoader5, ScriptRunner::ASYNC_EXECUTION);

- EXPECT_CALL(scriptLoader1, execute()).WillOnce(Invoke([this] {

- m_order.push_back(1);

- }));

- EXPECT_CALL(scriptLoader2, execute()).WillOnce(Invoke([this] {

- m_order.push_back(2);

- }));

- EXPECT_CALL(scriptLoader3, execute()).WillOnce(Invoke([this] {

- m_order.push_back(3);

- }));

- EXPECT_CALL(scriptLoader4, execute()).WillOnce(Invoke([this] {

- m_order.push_back(4);

- }));

- EXPECT_CALL(scriptLoader5, execute()).WillOnce(Invoke([this] {

- m_order.push_back(5);

- }));

- m_platform.runAllTasks();

- // Make sure the async scripts were run before the in-order ones.

- EXPECT_THAT(m_order, ElementsAre(4, 5, 1, 2, 3));

-TEST_F(ScriptRunnerTest, QueueMixedScripts_YieldAfterEveryExecution)

- MockScriptLoader scriptLoader1(m_element.get());

- MockScriptLoader scriptLoader2(m_element.get());

- MockScriptLoader scriptLoader3(m_element.get());

- MockScriptLoader scriptLoader4(m_element.get());

- MockScriptLoader scriptLoader5(m_element.get());

- m_platform.setShouldYieldEveryOtherTime(true);