third_party/WebKit/Source/platform/TimerTest.cpp - Issue 2266443002: Optimize posting of WTF::Closure and improve scheduler test mocks

Unified Diff: third_party/WebKit/Source/platform/TimerTest.cpp

Issue 2266443002: Optimize posting of WTF::Closure and improve scheduler test mocks (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: Cut back to just the WTF::Closure fix plus the scheduler test mock refactor. Created 4 years, 4 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: third_party/WebKit/Source/platform/TimerTest.cpp

diff --git a/third_party/WebKit/Source/platform/TimerTest.cpp b/third_party/WebKit/Source/platform/TimerTest.cpp

index 91c20089b21ffc08dfa7ac90a9ef0927c8c61b1d..51ef4fc941c95acef71738a567014d54213519e1 100644

--- a/third_party/WebKit/Source/platform/TimerTest.cpp

+++ b/third_party/WebKit/Source/platform/TimerTest.cpp

@@ -4,6 +4,9 @@

#include "platform/Timer.h"

+#include "platform/scheduler/base/task_queue_impl.h"

+#include "platform/scheduler/child/web_task_runner_impl.h"

+#include "platform/scheduler/renderer/renderer_scheduler_impl.h"

#include "platform/testing/TestingPlatformSupport.h"

#include "public/platform/Platform.h"

#include "public/platform/WebScheduler.h"

@@ -11,6 +14,7 @@

#include "public/platform/WebViewScheduler.h"

#include "testing/gmock/include/gmock/gmock.h"

#include "testing/gtest/include/gtest/gtest.h"

+#include "wtf/CurrentTime.h"

#include "wtf/PtrUtil.h"

#include "wtf/RefCounted.h"

#include <memory>

@@ -20,325 +24,53 @@ using testing::ElementsAre;

namespace blink {

namespace {

-double gCurrentTimeSecs = 0.0;

-class DelayedTask {

-public:

- DelayedTask(WebTaskRunner::Task* task, double delaySeconds)

- : m_task(task)

- , m_runTimeSeconds(gCurrentTimeSecs + delaySeconds)

- , m_delaySeconds(delaySeconds)

- {

- }

- bool operator<(const DelayedTask& other) const

- {

- return m_runTimeSeconds > other.m_runTimeSeconds;

- }

- void run() const

- {

- m_task->run();

- }

- double runTimeSeconds() const

- {

- return m_runTimeSeconds;

- }

- double delaySeconds() const

- {

- return m_delaySeconds;

- }

-private:

- std::unique_ptr<WebTaskRunner::Task> m_task;

- double m_runTimeSeconds;

- double m_delaySeconds;

-};

-class MockWebTaskRunner : public WebTaskRunner {

-public:

- explicit MockWebTaskRunner(std::priority_queue<DelayedTask>* timerTasks) : m_timerTasks(timerTasks) { }

- ~MockWebTaskRunner() override { }

- void postTask(const WebTraceLocation&, Task* task) override

- {

- m_timerTasks->push(DelayedTask(task, 0));

- }

- void postDelayedTask(const WebTraceLocation&, Task* task, double delayMs) override

- {

- m_timerTasks->push(DelayedTask(task, delayMs * 0.001));

- }

- bool runsTasksOnCurrentThread() override

- {

- NOTREACHED();

- return true;

- }

- std::unique_ptr<WebTaskRunner> clone() override

- {

- NOTREACHED();

- return nullptr;

- }

- double virtualTimeSeconds() const override

- {

- NOTREACHED();

- return 0.0;

- }

- double monotonicallyIncreasingVirtualTimeSeconds() const override

- {

- return gCurrentTimeSecs;

- }

- base::SingleThreadTaskRunner* taskRunner() override

- {

- ASSERT_NOT_REACHED();

- return nullptr;

- }

- std::priority_queue<DelayedTask>* m_timerTasks; // NOT OWNED

-};

-class MockWebScheduler : public WebScheduler {

-public:

- 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

- {

- }

- WebTaskRunner* timerTaskRunner() override

- {

- return &m_timerWebTaskRunner;

- }

- WebTaskRunner* loadingTaskRunner() override

- {

- NOTREACHED();

- return nullptr;

- }

- void runUntilIdle()

- {

- while (m_timerTasks.size()) {

- gCurrentTimeSecs = m_timerTasks.top().runTimeSeconds();

- m_timerTasks.top().run();

- m_timerTasks.pop();

- }

- void runUntilIdleOrDeadlinePassed(double deadline)

- {

- while (m_timerTasks.size()) {

- if (m_timerTasks.top().runTimeSeconds() > deadline) {

- gCurrentTimeSecs = deadline;

- break;

- }

- gCurrentTimeSecs = m_timerTasks.top().runTimeSeconds();

- m_timerTasks.top().run();

- m_timerTasks.pop();

- }

- void runPendingTasks()

- {

- while (m_timerTasks.size() && m_timerTasks.top().runTimeSeconds() <= gCurrentTimeSecs) {

- m_timerTasks.top().run();

- m_timerTasks.pop();

- }

- bool hasOneTimerTask() const

- {

- return m_timerTasks.size() == 1;

- }

- double nextTimerTaskDelaySecs() const

- {

- ASSERT(hasOneTimerTask());

- return m_timerTasks.top().delaySeconds();

- }

- void shutdown() override {}

- std::unique_ptr<WebViewScheduler> createWebViewScheduler(InterventionReporter*) override { return nullptr; }

- void suspendTimerQueue() override { }

- void resumeTimerQueue() override { }

- void addPendingNavigation(WebScheduler::NavigatingFrameType) override { }

- void removePendingNavigation(WebScheduler::NavigatingFrameType) override { }

- void onNavigationStarted() override { }

-private:

- std::priority_queue<DelayedTask> m_timerTasks;

- MockWebTaskRunner m_timerWebTaskRunner;

-};

-class FakeWebThread : public WebThread {

-public:

- FakeWebThread() : m_webScheduler(wrapUnique(new MockWebScheduler())) { }

- ~FakeWebThread() override { }

- virtual bool isCurrentThread() const

- {

- NOTREACHED();

- return true;

- }

- virtual PlatformThreadId threadId() const

- {

- NOTREACHED();

- return 0;

- }

- WebTaskRunner* getWebTaskRunner() override

- {

- NOTREACHED();

- return nullptr;

- }

- WebScheduler* scheduler() const override

- {

- return m_webScheduler.get();

- }

- virtual void enterRunLoop()

- {

- NOTREACHED();

- }

- virtual void exitRunLoop()

- {

- NOTREACHED();

- }

-private:

- std::unique_ptr<MockWebScheduler> m_webScheduler;

-};

-class TimerTestPlatform : public TestingPlatformSupport {

-public:

- TimerTestPlatform()

- : m_webThread(wrapUnique(new FakeWebThread())) { }

- ~TimerTestPlatform() override { }

- WebThread* currentThread() override

- {

- return m_webThread.get();

- }

- void runUntilIdle()

- {

- mockScheduler()->runUntilIdle();

- }

- void runPendingTasks()

- {

- mockScheduler()->runPendingTasks();

- }

- void runUntilIdleOrDeadlinePassed(double deadline)

- {

- mockScheduler()->runUntilIdleOrDeadlinePassed(deadline);

- }

- bool hasOneTimerTask() const

- {

- return mockScheduler()->hasOneTimerTask();

- }

- double nextTimerTaskDelaySecs() const

- {

- return mockScheduler()->nextTimerTaskDelaySecs();

- }

-private:

- MockWebScheduler* mockScheduler() const

- {

- return static_cast<MockWebScheduler*>(m_webThread->scheduler());

- }

- std::unique_ptr<FakeWebThread> m_webThread;

-};

class TimerTest : public testing::Test {

public:

void SetUp() override

{

m_runTimes.clear();

- gCurrentTimeSecs = 10.0;

- m_startTime = gCurrentTimeSecs;

+ m_platform.advanceClockSeconds(10.0);

+ m_startTime = monotonicallyIncreasingTime();

}

void countingTask(TimerBase*)

{

- m_runTimes.append(gCurrentTimeSecs);

+ m_runTimes.append(monotonicallyIncreasingTime());

}

void recordNextFireTimeTask(TimerBase* timer)

{

- m_nextFireTimes.append(gCurrentTimeSecs + timer->nextFireInterval());

- }

- void advanceTimeBy(double timeSecs)

- {

- gCurrentTimeSecs += timeSecs;

- }

- void runUntilIdle()

- {

- m_platform.runUntilIdle();

- }

- void runPendingTasks()

- {

- m_platform.runPendingTasks();

+ m_nextFireTimes.append(monotonicallyIncreasingTime() + timer->nextFireInterval());

}

- void runUntilIdleOrDeadlinePassed(double deadline)

+ void runUntilDeadline(double deadline)

{

- m_platform.runUntilIdleOrDeadlinePassed(deadline);

- }

+ double period = deadline - monotonicallyIncreasingTime();

+ EXPECT_GE(period, 0.0);

+ m_platform.runForPeriodSeconds(period);

- bool hasOneTimerTask() const

- {

- return m_platform.hasOneTimerTask();

+ // We may have stopped before the clock advanced to |deadline|.

+ double timeToAdvance = deadline - monotonicallyIncreasingTime();

+ m_platform.advanceClockSeconds(timeToAdvance);

}

- double nextTimerTaskDelaySecs() const

+ // Returns false if there are no pending delayed tasks, otherwise sets |time| to

+ // the delay in seconds till the next pending delayed task is scheduled to fire.

+ bool timeTillNextDelayedTask(double* time) const

{

- return m_platform.nextTimerTaskDelaySecs();

+ base::TimeTicks nextRunTime;

+ if (!m_platform.rendererScheduler()->TimerTaskRunner()->GetTimeDomain()->NextScheduledRunTime(&nextRunTime))

+ return false;

+ *time = (nextRunTime - m_platform.rendererScheduler()->TimerTaskRunner()->GetTimeDomain()->Now()).InSecondsF();

+ return true;

}

protected:

double m_startTime;

WTF::Vector<double> m_runTimes;

WTF::Vector<double> m_nextFireTimes;

-private:

- TimerTestPlatform m_platform;

+ TestingPlatformSupportWithMockScheduler m_platform;

};

TEST_F(TimerTest, StartOneShot_Zero)

@@ -346,10 +78,10 @@ TEST_F(TimerTest, StartOneShot_Zero)

Timer<TimerTest> timer(this, &TimerTest::countingTask);

timer.startOneShot(0, BLINK_FROM_HERE);

- ASSERT(hasOneTimerTask());

- EXPECT_FLOAT_EQ(0.0, nextTimerTaskDelaySecs());

+ double runTime;

+ EXPECT_FALSE(timeTillNextDelayedTask(&runTime));

- runUntilIdle();

+ m_platform.runUntilIdle();

EXPECT_THAT(m_runTimes, ElementsAre(m_startTime));

}

@@ -358,12 +90,12 @@ TEST_F(TimerTest, StartOneShot_ZeroAndCancel)

Timer<TimerTest> timer(this, &TimerTest::countingTask);

timer.startOneShot(0, BLINK_FROM_HERE);

- ASSERT(hasOneTimerTask());

- EXPECT_FLOAT_EQ(0.0, nextTimerTaskDelaySecs());

+ double runTime;

+ EXPECT_FALSE(timeTillNextDelayedTask(&runTime));

timer.stop();

- runUntilIdle();

+ m_platform.runUntilIdle();

EXPECT_FALSE(m_runTimes.size());

}

@@ -372,20 +104,19 @@ TEST_F(TimerTest, StartOneShot_ZeroAndCancelThenRepost)

Timer<TimerTest> timer(this, &TimerTest::countingTask);

timer.startOneShot(0, BLINK_FROM_HERE);

- ASSERT(hasOneTimerTask());

- EXPECT_FLOAT_EQ(0.0, nextTimerTaskDelaySecs());

+ double runTime;

+ EXPECT_FALSE(timeTillNextDelayedTask(&runTime));

timer.stop();

- runUntilIdle();

+ m_platform.runUntilIdle();

EXPECT_FALSE(m_runTimes.size());

timer.startOneShot(0, BLINK_FROM_HERE);

- ASSERT(hasOneTimerTask());

- EXPECT_FLOAT_EQ(0.0, nextTimerTaskDelaySecs());

+ EXPECT_FALSE(timeTillNextDelayedTask(&runTime));

- runUntilIdle();

+ m_platform.runUntilIdle();

EXPECT_THAT(m_runTimes, ElementsAre(m_startTime));

}

@@ -394,18 +125,17 @@ TEST_F(TimerTest, StartOneShot_Zero_RepostingAfterRunning)

Timer<TimerTest> timer(this, &TimerTest::countingTask);

timer.startOneShot(0, BLINK_FROM_HERE);

- ASSERT(hasOneTimerTask());

- EXPECT_FLOAT_EQ(0.0, nextTimerTaskDelaySecs());

+ double runTime;

+ EXPECT_FALSE(timeTillNextDelayedTask(&runTime));

- runUntilIdle();

+ m_platform.runUntilIdle();

EXPECT_THAT(m_runTimes, ElementsAre(m_startTime));

timer.startOneShot(0, BLINK_FROM_HERE);

- ASSERT(hasOneTimerTask());

- EXPECT_FLOAT_EQ(0.0, nextTimerTaskDelaySecs());

+ EXPECT_FALSE(timeTillNextDelayedTask(&runTime));

- runUntilIdle();

+ m_platform.runUntilIdle();

EXPECT_THAT(m_runTimes, ElementsAre(m_startTime, m_startTime));

}

@@ -414,10 +144,11 @@ TEST_F(TimerTest, StartOneShot_NonZero)

Timer<TimerTest> timer(this, &TimerTest::countingTask);

timer.startOneShot(10.0, BLINK_FROM_HERE);

- ASSERT(hasOneTimerTask());

- EXPECT_FLOAT_EQ(10.0, nextTimerTaskDelaySecs());

+ double runTime;

+ EXPECT_TRUE(timeTillNextDelayedTask(&runTime));

+ EXPECT_FLOAT_EQ(10.0, runTime);

- runUntilIdle();

+ m_platform.runUntilIdle();

EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 10.0));

}

@@ -426,12 +157,14 @@ TEST_F(TimerTest, StartOneShot_NonZeroAndCancel)

Timer<TimerTest> timer(this, &TimerTest::countingTask);

timer.startOneShot(10, BLINK_FROM_HERE);

- ASSERT(hasOneTimerTask());

- EXPECT_FLOAT_EQ(10.0, nextTimerTaskDelaySecs());

+ double runTime;

+ EXPECT_TRUE(timeTillNextDelayedTask(&runTime));

+ EXPECT_FLOAT_EQ(10.0, runTime);

timer.stop();

+ EXPECT_TRUE(timeTillNextDelayedTask(&runTime));

- runUntilIdle();

+ m_platform.runUntilIdle();

EXPECT_FALSE(m_runTimes.size());

}

@@ -440,21 +173,23 @@ TEST_F(TimerTest, StartOneShot_NonZeroAndCancelThenRepost)

Timer<TimerTest> timer(this, &TimerTest::countingTask);

timer.startOneShot(10, BLINK_FROM_HERE);

- ASSERT(hasOneTimerTask());

- EXPECT_FLOAT_EQ(10.0, nextTimerTaskDelaySecs());

+ double runTime;

+ EXPECT_TRUE(timeTillNextDelayedTask(&runTime));

+ EXPECT_FLOAT_EQ(10.0, runTime);

timer.stop();

+ EXPECT_TRUE(timeTillNextDelayedTask(&runTime));

- runUntilIdle();

+ m_platform.runUntilIdle();

EXPECT_FALSE(m_runTimes.size());

- double secondPostTime = gCurrentTimeSecs;

+ double secondPostTime = monotonicallyIncreasingTime();

timer.startOneShot(10, BLINK_FROM_HERE);

- ASSERT(hasOneTimerTask());

- EXPECT_FLOAT_EQ(10.0, nextTimerTaskDelaySecs());

+ EXPECT_TRUE(timeTillNextDelayedTask(&runTime));

+ EXPECT_FLOAT_EQ(10.0, runTime);

- runUntilIdle();

+ m_platform.runUntilIdle();

EXPECT_THAT(m_runTimes, ElementsAre(secondPostTime + 10.0));

}

@@ -463,18 +198,19 @@ TEST_F(TimerTest, StartOneShot_NonZero_RepostingAfterRunning)

Timer<TimerTest> timer(this, &TimerTest::countingTask);

timer.startOneShot(10, BLINK_FROM_HERE);

- ASSERT(hasOneTimerTask());

- EXPECT_FLOAT_EQ(10.0, nextTimerTaskDelaySecs());

+ double runTime;

+ EXPECT_TRUE(timeTillNextDelayedTask(&runTime));

+ EXPECT_FLOAT_EQ(10.0, runTime);

- runUntilIdle();

+ m_platform.runUntilIdle();

EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 10.0));

timer.startOneShot(20, BLINK_FROM_HERE);

- ASSERT(hasOneTimerTask());

- EXPECT_FLOAT_EQ(20.0, nextTimerTaskDelaySecs());

+ EXPECT_TRUE(timeTillNextDelayedTask(&runTime));

+ EXPECT_FLOAT_EQ(20.0, runTime);

- runUntilIdle();

+ m_platform.runUntilIdle();

EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 10.0, m_startTime + 30.0));

}

@@ -484,10 +220,11 @@ TEST_F(TimerTest, PostingTimerTwiceWithSameRunTimeDoesNothing)

timer.startOneShot(10, BLINK_FROM_HERE);

- ASSERT(hasOneTimerTask());

- EXPECT_FLOAT_EQ(10.0, nextTimerTaskDelaySecs());

+ double runTime;

+ EXPECT_TRUE(timeTillNextDelayedTask(&runTime));

+ EXPECT_FLOAT_EQ(10.0, runTime);

- runUntilIdle();

+ m_platform.runUntilIdle();

EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 10.0));

}

@@ -497,7 +234,7 @@ TEST_F(TimerTest, PostingTimerTwiceWithNewerRunTimeCancelsOriginalTask)

timer.startOneShot(10, BLINK_FROM_HERE);

timer.startOneShot(0, BLINK_FROM_HERE);

- runUntilIdle();

+ m_platform.runUntilIdle();

EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 0.0));

}

@@ -507,7 +244,7 @@ TEST_F(TimerTest, PostingTimerTwiceWithLaterRunTimeCancelsOriginalTask)

timer.startOneShot(0, BLINK_FROM_HERE);

timer.startOneShot(10, BLINK_FROM_HERE);

- runUntilIdle();

+ m_platform.runUntilIdle();

EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 10.0));

}

@@ -516,10 +253,11 @@ TEST_F(TimerTest, StartRepeatingTask)

Timer<TimerTest> timer(this, &TimerTest::countingTask);

timer.startRepeating(1.0, BLINK_FROM_HERE);

- ASSERT(hasOneTimerTask());

- EXPECT_FLOAT_EQ(1.0, nextTimerTaskDelaySecs());

+ double runTime;

+ EXPECT_TRUE(timeTillNextDelayedTask(&runTime));

+ EXPECT_FLOAT_EQ(1.0, runTime);

- runUntilIdleOrDeadlinePassed(m_startTime + 5.5);

+ runUntilDeadline(m_startTime + 5.5);

EXPECT_THAT(m_runTimes, ElementsAre(

m_startTime + 1.0, m_startTime + 2.0, m_startTime + 3.0, m_startTime + 4.0, m_startTime + 5.0));

}

@@ -529,14 +267,15 @@ TEST_F(TimerTest, StartRepeatingTask_ThenCancel)

Timer<TimerTest> timer(this, &TimerTest::countingTask);

timer.startRepeating(1.0, BLINK_FROM_HERE);

- ASSERT(hasOneTimerTask());

- EXPECT_FLOAT_EQ(1.0, nextTimerTaskDelaySecs());

+ double runTime;

+ EXPECT_TRUE(timeTillNextDelayedTask(&runTime));

+ EXPECT_FLOAT_EQ(1.0, runTime);

- runUntilIdleOrDeadlinePassed(m_startTime + 2.5);

+ runUntilDeadline(m_startTime + 2.5);

EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 1.0, m_startTime + 2.0));

timer.stop();

- runUntilIdle();

+ m_platform.runUntilIdle();

EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 1.0, m_startTime + 2.0));

}

@@ -546,14 +285,15 @@ TEST_F(TimerTest, StartRepeatingTask_ThenPostOneShot)

Timer<TimerTest> timer(this, &TimerTest::countingTask);

timer.startRepeating(1.0, BLINK_FROM_HERE);

- ASSERT(hasOneTimerTask());

- EXPECT_FLOAT_EQ(1.0, nextTimerTaskDelaySecs());

+ double runTime;

+ EXPECT_TRUE(timeTillNextDelayedTask(&runTime));

+ EXPECT_FLOAT_EQ(1.0, runTime);

- runUntilIdleOrDeadlinePassed(m_startTime + 2.5);

+ runUntilDeadline(m_startTime + 2.5);

EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 1.0, m_startTime + 2.0));

timer.startOneShot(0, BLINK_FROM_HERE);

- runUntilIdle();

+ m_platform.runUntilIdle();

EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 1.0, m_startTime + 2.0, m_startTime + 2.5));

}

@@ -594,7 +334,7 @@ TEST_F(TimerTest, IsActive_AfterRunning_OneShotZero)

Timer<TimerTest> timer(this, &TimerTest::countingTask);

timer.startOneShot(0, BLINK_FROM_HERE);

- runUntilIdle();

+ m_platform.runUntilIdle();

EXPECT_FALSE(timer.isActive());

}

@@ -603,7 +343,7 @@ TEST_F(TimerTest, IsActive_AfterRunning_OneShotNonZero)

Timer<TimerTest> timer(this, &TimerTest::countingTask);

timer.startOneShot(10, BLINK_FROM_HERE);

- runUntilIdle();

+ m_platform.runUntilIdle();

EXPECT_FALSE(timer.isActive());

}

@@ -612,7 +352,7 @@ TEST_F(TimerTest, IsActive_AfterRunning_Repeating)

Timer<TimerTest> timer(this, &TimerTest::countingTask);

timer.startRepeating(1.0, BLINK_FROM_HERE);

- runUntilIdleOrDeadlinePassed(m_startTime + 10);

+ runUntilDeadline(m_startTime + 10);

EXPECT_TRUE(timer.isActive()); // It should run until cancelled.

}

@@ -634,10 +374,12 @@ TEST_F(TimerTest, NextFireInterval_OneShotNonZero)

TEST_F(TimerTest, NextFireInterval_OneShotNonZero_AfterAFewSeconds)

{

+ m_platform.setAutoAdvanceNowToPendingTasks(false);

Timer<TimerTest> timer(this, &TimerTest::countingTask);

timer.startOneShot(10, BLINK_FROM_HERE);

- advanceTimeBy(2.0);

+ m_platform.advanceClockSeconds(2.0);

EXPECT_FLOAT_EQ(8.0, timer.nextFireInterval());

}

@@ -687,24 +429,30 @@ TEST_F(TimerTest, AugmentRepeatInterval)

EXPECT_FLOAT_EQ(10.0, timer.repeatInterval());

EXPECT_FLOAT_EQ(10.0, timer.nextFireInterval());

- advanceTimeBy(2.0);

+ m_platform.advanceClockSeconds(2.0);

timer.augmentRepeatInterval(10);

EXPECT_FLOAT_EQ(20.0, timer.repeatInterval());

EXPECT_FLOAT_EQ(18.0, timer.nextFireInterval());

- runUntilIdleOrDeadlinePassed(m_startTime + 50.0);

+ // NOTE setAutoAdvanceNowToPendingTasks(true) (which uses cc::OrderedSimpleTaskRunner)

+ // results in somewhat strange behavior of the test clock which breaks this test.

+ // Specifically the test clock advancing logic ignores newly posted delayed tasks and

+ // advances too far.

+ runUntilDeadline(m_startTime + 50.0);

EXPECT_THAT(m_runTimes, ElementsAre(m_startTime + 20.0, m_startTime + 40.0));

}

TEST_F(TimerTest, AugmentRepeatInterval_TimerFireDelayed)

{

+ m_platform.setAutoAdvanceNowToPendingTasks(false);

Timer<TimerTest> timer(this, &TimerTest::countingTask);

timer.startRepeating(10, BLINK_FROM_HERE);

EXPECT_FLOAT_EQ(10.0, timer.repeatInterval());

EXPECT_FLOAT_EQ(10.0, timer.nextFireInterval());

- advanceTimeBy(123.0); // Make the timer long overdue.

+ m_platform.advanceClockSeconds(123.0); // Make the timer long overdue.

timer.augmentRepeatInterval(10);

EXPECT_FLOAT_EQ(20.0, timer.repeatInterval());

@@ -714,35 +462,24 @@ TEST_F(TimerTest, AugmentRepeatInterval_TimerFireDelayed)

TEST_F(TimerTest, RepeatingTimerDoesNotDrift)

{

+ m_platform.setAutoAdvanceNowToPendingTasks(false);

Timer<TimerTest> timer(this, &TimerTest::recordNextFireTimeTask);

timer.startRepeating(2.0, BLINK_FROM_HERE);

- ASSERT(hasOneTimerTask());

recordNextFireTimeTask(&timer); // Next scheduled task to run at m_startTime + 2.0

// Simulate timer firing early. Next scheduled task to run at m_startTime + 4.0

- advanceTimeBy(1.9);

- runUntilIdleOrDeadlinePassed(gCurrentTimeSecs + 0.2);

- advanceTimeBy(2.0);

- runPendingTasks(); // Next scheduled task to run at m_startTime + 6.0

- advanceTimeBy(2.1);

- runPendingTasks(); // Next scheduled task to run at m_startTime + 8.0

- advanceTimeBy(2.9);

- runPendingTasks(); // Next scheduled task to run at m_startTime + 10.0

- advanceTimeBy(3.1);

- runPendingTasks(); // Next scheduled task to run at m_startTime + 14.0 (skips a beat)

- advanceTimeBy(4.0);

- runPendingTasks(); // Next scheduled task to run at m_startTime + 18.0 (skips a beat)

+ m_platform.advanceClockSeconds(1.9);

+ runUntilDeadline(monotonicallyIncreasingTime() + 0.2);

- advanceTimeBy(10.0); // Next scheduled task to run at m_startTime + 28.0 (skips 5 beats)

- runPendingTasks();

+ m_platform.runForPeriodSeconds(2.0); // Next scheduled task to run at m_startTime + 6.0

+ m_platform.runForPeriodSeconds(2.1); // Next scheduled task to run at m_startTime + 8.0

+ m_platform.runForPeriodSeconds(2.9); // Next scheduled task to run at m_startTime + 10.0

+ m_platform.runForPeriodSeconds(3.1); // Next scheduled task to run at m_startTime + 14.0 (skips a beat)

+ m_platform.runForPeriodSeconds(4.0); // Next scheduled task to run at m_startTime + 18.0 (skips a beat)

+ m_platform.runForPeriodSeconds(10.0); // Next scheduled task to run at m_startTime + 28.0 (skips 5 beats)

- runUntilIdleOrDeadlinePassed(m_startTime + 5.5);

EXPECT_THAT(m_nextFireTimes, ElementsAre(

m_startTime + 2.0,

m_startTime + 4.0,

@@ -769,13 +506,13 @@ public:

TEST_F(TimerTest, UserSuppliedWebTaskRunner)

{

- std::priority_queue<DelayedTask> timerTasks;

- MockWebTaskRunner taskRunner(&timerTasks);

- TimerForTest<TimerTest> timer(&taskRunner, this, &TimerTest::countingTask);

+ scoped_refptr<scheduler::TaskQueue> taskRunner(m_platform.rendererScheduler()->NewTimerTaskRunner("test"));

+ scheduler::WebTaskRunnerImpl webTaskRunner(taskRunner);

+ TimerForTest<TimerTest> timer(&webTaskRunner, this, &TimerTest::countingTask);

timer.startOneShot(0, BLINK_FROM_HERE);

// Make sure the task was posted on taskRunner.

- EXPECT_FALSE(timerTasks.empty());

+ EXPECT_FALSE(taskRunner->IsEmpty());

}

« no previous file with comments | « third_party/WebKit/Source/platform/DEPS ('k') | third_party/WebKit/Source/platform/WebTaskRunner.cpp » ('j') | no next file with comments »