components/scheduler/renderer/renderer_scheduler_impl_unittest.cc - Issue 1132753008: Replaced TestNowSource with SimpleTestTickClock.

Unified Diff: components/scheduler/renderer/renderer_scheduler_impl_unittest.cc

Issue 1132753008: Replaced TestNowSource with SimpleTestTickClock. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: Incorporated review comments: scoped leaking clocks, refactored num_now_calls_ functionality Created 5 years, 7 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: components/scheduler/renderer/renderer_scheduler_impl_unittest.cc

diff --git a/components/scheduler/renderer/renderer_scheduler_impl_unittest.cc b/components/scheduler/renderer/renderer_scheduler_impl_unittest.cc

index 449282af046bc5c363dea3b3c6f0e238aeebe533..1fe0a375a18fb7b0bede03adf537d17f4d3cb1c8 100644

--- a/components/scheduler/renderer/renderer_scheduler_impl_unittest.cc

+++ b/components/scheduler/renderer/renderer_scheduler_impl_unittest.cc

@@ -5,9 +5,9 @@

#include "components/scheduler/renderer/renderer_scheduler_impl.h"

#include "base/callback.h"

+#include "base/test/simple_test_tick_clock.h"

#include "cc/output/begin_frame_args.h"

#include "cc/test/ordered_simple_task_runner.h"

-#include "cc/test/test_now_source.h"

#include "components/scheduler/child/nestable_task_runner_for_test.h"

#include "components/scheduler/child/scheduler_message_loop_delegate.h"

#include "components/scheduler/child/test_time_source.h"

@@ -79,11 +79,11 @@ void RepostingIdleTestTask(SingleThreadIdleTaskRunner* idle_task_runner,

}

void UpdateClockToDeadlineIdleTestTask(

- cc::TestNowSource* clock,

+ base::SimpleTestTickClock* clock,

base::SingleThreadTaskRunner* task_runner,

int* run_count,

base::TimeTicks deadline) {

- clock->SetNow(deadline);

+ clock->Advance(deadline - clock->NowTicks());

// Due to the way in which OrderedSimpleTestRunner orders tasks and the fact

// that we updated the time within a task, the delayed pending task to call

// EndIdlePeriod will not happen until after a TaskQueueManager DoWork, so

@@ -123,26 +123,28 @@ class RendererSchedulerImplTest : public testing::Test {

public:

using Policy = RendererSchedulerImpl::Policy;

- RendererSchedulerImplTest()

- : clock_(cc::TestNowSource::Create(5000)),

- mock_task_runner_(new cc::OrderedSimpleTaskRunner(clock_, false)),

- nestable_task_runner_(

- NestableTaskRunnerForTest::Create(mock_task_runner_)),

- scheduler_(new RendererSchedulerImpl(nestable_task_runner_)),

- default_task_runner_(scheduler_->DefaultTaskRunner()),

- compositor_task_runner_(scheduler_->CompositorTaskRunner()),

- loading_task_runner_(scheduler_->LoadingTaskRunner()),

- idle_task_runner_(scheduler_->IdleTaskRunner()),

- timer_task_runner_(scheduler_->TimerTaskRunner()) {

+ RendererSchedulerImplTest() : clock_(new base::SimpleTestTickClock()) {

+ clock_->Advance(base::TimeDelta::FromInternalValue(5000));

+ mock_task_runner_ = new cc::OrderedSimpleTaskRunner(clock_.get(), false);

+ nestable_task_runner_ =

+ NestableTaskRunnerForTest::Create(mock_task_runner_);

+ scheduler_ =

+ make_scoped_ptr(new RendererSchedulerImpl(nestable_task_runner_));

+ default_task_runner_ = scheduler_->DefaultTaskRunner();

+ compositor_task_runner_ = scheduler_->CompositorTaskRunner();

+ loading_task_runner_ = scheduler_->LoadingTaskRunner();

+ idle_task_runner_ = scheduler_->IdleTaskRunner();

+ timer_task_runner_ = scheduler_->TimerTaskRunner();

scheduler_->GetSchedulerHelperForTesting()->SetTimeSourceForTesting(

- make_scoped_ptr(new TestTimeSource(clock_)));

+ make_scoped_ptr(new TestTimeSource(clock_.get())));

scheduler_->GetSchedulerHelperForTesting()

->GetTaskQueueManagerForTesting()

- ->SetTimeSourceForTesting(make_scoped_ptr(new TestTimeSource(clock_)));

+ ->SetTimeSourceForTesting(

+ make_scoped_ptr(new TestTimeSource(clock_.get())));

}

RendererSchedulerImplTest(base::MessageLoop* message_loop)

- : clock_(cc::TestNowSource::Create(5000)),

+ : clock_(new base::SimpleTestTickClock()),

message_loop_(message_loop),

nestable_task_runner_(

SchedulerMessageLoopDelegate::Create(message_loop)),

@@ -152,11 +154,13 @@ class RendererSchedulerImplTest : public testing::Test {

loading_task_runner_(scheduler_->LoadingTaskRunner()),

idle_task_runner_(scheduler_->IdleTaskRunner()),

timer_task_runner_(scheduler_->TimerTaskRunner()) {

+ clock_->Advance(base::TimeDelta::FromInternalValue(5000));

scheduler_->GetSchedulerHelperForTesting()->SetTimeSourceForTesting(

- make_scoped_ptr(new TestTimeSource(clock_)));

+ make_scoped_ptr(new TestTimeSource(clock_.get())));

scheduler_->GetSchedulerHelperForTesting()

->GetTaskQueueManagerForTesting()

- ->SetTimeSourceForTesting(make_scoped_ptr(new TestTimeSource(clock_)));

+ ->SetTimeSourceForTesting(

+ make_scoped_ptr(new TestTimeSource(clock_.get())));

}

~RendererSchedulerImplTest() override {}

@@ -183,7 +187,7 @@ class RendererSchedulerImplTest : public testing::Test {

void DoMainFrame() {

scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(

- BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),

+ BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),

base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));

scheduler_->DidCommitFrameToCompositor();

}

@@ -199,7 +203,7 @@ class RendererSchedulerImplTest : public testing::Test {

void ScheduleDelayedPolicyUpdate(base::TimeDelta delay) {

scheduler_->delayed_update_policy_runner_.SetDeadline(FROM_HERE, delay,

- clock_->Now());

+ clock_->NowTicks());

}

// Helper for posting several tasks of specific types. |task_descriptor| is a

@@ -291,7 +295,7 @@ class RendererSchedulerImplTest : public testing::Test {

&RendererSchedulerImpl::InputStreamStateToString);

}

- scoped_refptr<cc::TestNowSource> clock_;

+ scoped_ptr<base::SimpleTestTickClock> clock_;

// Only one of mock_task_runner_ or message_loop_ will be set.

scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_;

scoped_ptr<base::MessageLoop> message_loop_;

@@ -339,10 +343,10 @@ TEST_F(RendererSchedulerImplTest, TestRentrantTask) {

TEST_F(RendererSchedulerImplTest, TestPostIdleTask) {

int run_count = 0;

base::TimeTicks expected_deadline =

- clock_->Now() + base::TimeDelta::FromMilliseconds(2300);

+ clock_->NowTicks() + base::TimeDelta::FromMilliseconds(2300);

base::TimeTicks deadline_in_task;

- clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(100));

+ clock_->Advance(base::TimeDelta::FromMilliseconds(100));

idle_task_runner_->PostIdleTask(

FROM_HERE, base::Bind(&IdleTestTask, &run_count, &deadline_in_task));

@@ -350,20 +354,20 @@ TEST_F(RendererSchedulerImplTest, TestPostIdleTask) {

EXPECT_EQ(0, run_count); // Shouldn't run yet as no WillBeginFrame.

scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(

- BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),

+ BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),

base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));

RunUntilIdle();

EXPECT_EQ(0, run_count); // Shouldn't run as no DidCommitFrameToCompositor.

- clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(1200));

+ clock_->Advance(base::TimeDelta::FromMilliseconds(1200));

scheduler_->DidCommitFrameToCompositor();

RunUntilIdle();

EXPECT_EQ(0, run_count); // We missed the deadline.

scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(

- BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),

+ BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),

base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));

- clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(800));

+ clock_->Advance(base::TimeDelta::FromMilliseconds(800));

scheduler_->DidCommitFrameToCompositor();

RunUntilIdle();

EXPECT_EQ(1, run_count);

@@ -396,10 +400,10 @@ TEST_F(RendererSchedulerImplTest, TestIdleTaskExceedsDeadline) {

// Post two UpdateClockToDeadlineIdleTestTask tasks.

idle_task_runner_->PostIdleTask(

- FROM_HERE, base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_,

+ FROM_HERE, base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_.get(),

default_task_runner_, &run_count));

idle_task_runner_->PostIdleTask(

- FROM_HERE, base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_,

+ FROM_HERE, base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_.get(),

default_task_runner_, &run_count));

EnableIdleTasks();

@@ -484,15 +488,15 @@ TEST_F(RendererSchedulerImplTest, TestDelayedEndIdlePeriodCanceled) {

// Trigger the beginning of an idle period for 1000ms.

scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(

- BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),

+ BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),

base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));

DoMainFrame();

// End the idle period early (after 500ms), and send a WillBeginFrame which

// specifies that the next idle period should end 1000ms from now.

- clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(500));

+ clock_->Advance(base::TimeDelta::FromMilliseconds(500));

scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(

- BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),

+ BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),

base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));

RunUntilIdle();

@@ -500,13 +504,13 @@ TEST_F(RendererSchedulerImplTest, TestDelayedEndIdlePeriodCanceled) {

// Trigger the start of the idle period before the task to end the previous

// idle period has been triggered.

- clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(400));

+ clock_->Advance(base::TimeDelta::FromMilliseconds(400));

scheduler_->DidCommitFrameToCompositor();

// Post a task which simulates running until after the previous end idle

// period delayed task was scheduled for

scheduler_->DefaultTaskRunner()->PostTask(FROM_HERE, base::Bind(NullTask));

- clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(300));

+ clock_->Advance(base::TimeDelta::FromMilliseconds(300));

RunUntilIdle();

EXPECT_EQ(1, run_count); // We should still be in the new idle period.

@@ -680,7 +684,7 @@ TEST_F(RendererSchedulerImplTest, TestCompositorPolicyEnds) {

std::string("D1"), std::string("D2")));

run_order.clear();

- clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(1000));

+ clock_->Advance(base::TimeDelta::FromMilliseconds(1000));

PostTestTasks(&run_order, "D1 C1 D2 C2");

// Compositor policy mode should have ended now that the clock has advanced.

@@ -702,7 +706,7 @@ TEST_F(RendererSchedulerImplTest, TestTouchstartPolicyEndsAfterTimeout) {

std::string("D1"), std::string("D2")));

run_order.clear();

- clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(1000));

+ clock_->Advance(base::TimeDelta::FromMilliseconds(1000));

// Don't post any compositor tasks to simulate a very long running event

// handler.

@@ -771,7 +775,7 @@ TEST_F(RendererSchedulerImplTest, TestIsHighPriorityWorkAnticipated) {

EXPECT_FALSE(is_anticipated_before);

EXPECT_TRUE(is_anticipated_after);

- clock_->AdvanceNow(priority_escalation_after_input_duration() * 2);

+ clock_->Advance(priority_escalation_after_input_duration() * 2);

simulate_input = false;

default_task_runner_->PostTask(

FROM_HERE,

@@ -835,7 +839,7 @@ TEST_F(RendererSchedulerImplTest, SlowInputEvent) {

// Simulate the input event being queued for a very long time. The compositor

// task we post here represents the enqueued input task.

- clock_->AdvanceNow(priority_escalation_after_input_duration() * 2);

+ clock_->Advance(priority_escalation_after_input_duration() * 2);

compositor_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask));

RunUntilIdle();

@@ -850,7 +854,7 @@ TEST_F(RendererSchedulerImplTest, SlowInputEvent) {

EXPECT_EQ(Policy::COMPOSITOR_PRIORITY, CurrentPolicy());

// After the escalation period ends we should go back into normal mode.

- clock_->AdvanceNow(priority_escalation_after_input_duration() * 2);

+ clock_->Advance(priority_escalation_after_input_duration() * 2);

RunUntilIdle();

EXPECT_EQ(Policy::NORMAL, CurrentPolicy());

}

@@ -866,7 +870,7 @@ TEST_F(RendererSchedulerImplTest, SlowNoOpInputEvent) {

// Simulate the input event being queued for a very long time. The compositor

// task we post here represents the enqueued input task.

- clock_->AdvanceNow(priority_escalation_after_input_duration() * 2);

+ clock_->Advance(priority_escalation_after_input_duration() * 2);

compositor_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask));

RunUntilIdle();

@@ -876,7 +880,7 @@ TEST_F(RendererSchedulerImplTest, SlowNoOpInputEvent) {

// If we let the compositor queue drain, we should fall out of input

// priority.

- clock_->AdvanceNow(priority_escalation_after_input_duration() * 2);

+ clock_->Advance(priority_escalation_after_input_duration() * 2);

RunUntilIdle();

EXPECT_EQ(Policy::NORMAL, CurrentPolicy());

}

@@ -892,7 +896,7 @@ TEST_F(RendererSchedulerImplTest, NoOpInputEvent) {

// If nothing else happens after this, we should drop out of compositor

// priority after the escalation period ends and stop polling.

- clock_->AdvanceNow(priority_escalation_after_input_duration() * 2);

+ clock_->Advance(priority_escalation_after_input_duration() * 2);

RunUntilIdle();

EXPECT_EQ(Policy::NORMAL, CurrentPolicy());

EXPECT_FALSE(mock_task_runner_->HasPendingTasks());

@@ -909,18 +913,18 @@ TEST_F(RendererSchedulerImplTest, NoOpInputEventExtendsEscalationPeriod) {

EXPECT_EQ(Policy::COMPOSITOR_PRIORITY, CurrentPolicy());

// Send a no-op input event in the middle of the escalation period.

- clock_->AdvanceNow(priority_escalation_after_input_duration() / 2);

+ clock_->Advance(priority_escalation_after_input_duration() / 2);

scheduler_->DidReceiveInputEventOnCompositorThread(

FakeInputEvent(blink::WebInputEvent::GestureScrollUpdate));

RunUntilIdle();

EXPECT_EQ(Policy::COMPOSITOR_PRIORITY, CurrentPolicy());

// The escalation period should have been extended by the new input event.

- clock_->AdvanceNow(3 * priority_escalation_after_input_duration() / 4);

+ clock_->Advance(3 * priority_escalation_after_input_duration() / 4);

RunUntilIdle();

EXPECT_EQ(Policy::COMPOSITOR_PRIORITY, CurrentPolicy());

- clock_->AdvanceNow(priority_escalation_after_input_duration() / 2);

+ clock_->Advance(priority_escalation_after_input_duration() / 2);

RunUntilIdle();

EXPECT_EQ(Policy::NORMAL, CurrentPolicy());

}

@@ -929,15 +933,15 @@ TEST_F(RendererSchedulerImplTest, InputArrivesAfterBeginFrame) {

EXPECT_EQ(Policy::NORMAL, CurrentPolicy());

cc::BeginFrameArgs args = cc::BeginFrameArgs::Create(

- BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),

+ BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),

base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL);

- clock_->AdvanceNow(priority_escalation_after_input_duration() / 2);

+ clock_->Advance(priority_escalation_after_input_duration() / 2);

scheduler_->DidReceiveInputEventOnCompositorThread(

FakeInputEvent(blink::WebInputEvent::GestureScrollBegin));

// Simulate a BeginMainFrame task from the past.

- clock_->AdvanceNow(2 * priority_escalation_after_input_duration());

+ clock_->Advance(2 * priority_escalation_after_input_duration());

scheduler_->WillBeginFrame(args);

scheduler_->DidCommitFrameToCompositor();

@@ -946,13 +950,13 @@ TEST_F(RendererSchedulerImplTest, InputArrivesAfterBeginFrame) {

// Should remain in input priority policy since the input event hasn't been

// processed yet.

- clock_->AdvanceNow(2 * priority_escalation_after_input_duration());

+ clock_->Advance(2 * priority_escalation_after_input_duration());

RunUntilIdle();

EXPECT_EQ(Policy::COMPOSITOR_PRIORITY, CurrentPolicy());

// Process the input event with a new BeginMainFrame.

DoMainFrame();

- clock_->AdvanceNow(2 * priority_escalation_after_input_duration());

+ clock_->Advance(2 * priority_escalation_after_input_duration());

RunUntilIdle();

EXPECT_EQ(Policy::NORMAL, CurrentPolicy());

}

@@ -991,10 +995,11 @@ TEST_F(RendererSchedulerImplTest, OnePendingDelayedAndOneUrgentUpdatePolicy) {

new RendererSchedulerImplForTest(nestable_task_runner_);

scheduler_.reset(mock_scheduler);

scheduler_->GetSchedulerHelperForTesting()->SetTimeSourceForTesting(

- make_scoped_ptr(new TestTimeSource(clock_)));

+ make_scoped_ptr(new TestTimeSource(clock_.get())));

scheduler_->GetSchedulerHelperForTesting()

->GetTaskQueueManagerForTesting()

- ->SetTimeSourceForTesting(make_scoped_ptr(new TestTimeSource(clock_)));

+ ->SetTimeSourceForTesting(

+ make_scoped_ptr(new TestTimeSource(clock_.get())));

mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);

ScheduleDelayedPolicyUpdate(base::TimeDelta::FromMilliseconds(1));

@@ -1011,10 +1016,11 @@ TEST_F(RendererSchedulerImplTest, OneUrgentAndOnePendingDelayedUpdatePolicy) {

new RendererSchedulerImplForTest(nestable_task_runner_);

scheduler_.reset(mock_scheduler);

scheduler_->GetSchedulerHelperForTesting()->SetTimeSourceForTesting(

- make_scoped_ptr(new TestTimeSource(clock_)));

+ make_scoped_ptr(new TestTimeSource(clock_.get())));

scheduler_->GetSchedulerHelperForTesting()

->GetTaskQueueManagerForTesting()

- ->SetTimeSourceForTesting(make_scoped_ptr(new TestTimeSource(clock_)));

+ ->SetTimeSourceForTesting(

+ make_scoped_ptr(new TestTimeSource(clock_.get())));

mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);

EnsureUrgentPolicyUpdatePostedOnMainThread();

@@ -1031,10 +1037,11 @@ TEST_F(RendererSchedulerImplTest, UpdatePolicyCountTriggeredByOneInputEvent) {

new RendererSchedulerImplForTest(nestable_task_runner_);

scheduler_.reset(mock_scheduler);

scheduler_->GetSchedulerHelperForTesting()->SetTimeSourceForTesting(

- make_scoped_ptr(new TestTimeSource(clock_)));

+ make_scoped_ptr(new TestTimeSource(clock_.get())));

scheduler_->GetSchedulerHelperForTesting()

->GetTaskQueueManagerForTesting()

- ->SetTimeSourceForTesting(make_scoped_ptr(new TestTimeSource(clock_)));

+ ->SetTimeSourceForTesting(

+ make_scoped_ptr(new TestTimeSource(clock_.get())));

mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);

scheduler_->DidReceiveInputEventOnCompositorThread(

@@ -1051,10 +1058,11 @@ TEST_F(RendererSchedulerImplTest, UpdatePolicyCountTriggeredByTwoInputEvents) {

new RendererSchedulerImplForTest(nestable_task_runner_);

scheduler_.reset(mock_scheduler);

scheduler_->GetSchedulerHelperForTesting()->SetTimeSourceForTesting(

- make_scoped_ptr(new TestTimeSource(clock_)));

+ make_scoped_ptr(new TestTimeSource(clock_.get())));

scheduler_->GetSchedulerHelperForTesting()

->GetTaskQueueManagerForTesting()

- ->SetTimeSourceForTesting(make_scoped_ptr(new TestTimeSource(clock_)));

+ ->SetTimeSourceForTesting(

+ make_scoped_ptr(new TestTimeSource(clock_.get())));

mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);

scheduler_->DidReceiveInputEventOnCompositorThread(

@@ -1073,10 +1081,11 @@ TEST_F(RendererSchedulerImplTest, EnsureUpdatePolicyNotTriggeredTooOften) {

new RendererSchedulerImplForTest(nestable_task_runner_);

scheduler_.reset(mock_scheduler);

scheduler_->GetSchedulerHelperForTesting()->SetTimeSourceForTesting(

- make_scoped_ptr(new TestTimeSource(clock_)));

+ make_scoped_ptr(new TestTimeSource(clock_.get())));

scheduler_->GetSchedulerHelperForTesting()

->GetTaskQueueManagerForTesting()

- ->SetTimeSourceForTesting(make_scoped_ptr(new TestTimeSource(clock_)));

+ ->SetTimeSourceForTesting(

+ make_scoped_ptr(new TestTimeSource(clock_.get())));

mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);

scheduler_->DidReceiveInputEventOnCompositorThread(

@@ -1169,7 +1178,7 @@ TEST_F(RendererSchedulerImplWithMessageLoopTest,

TEST_F(RendererSchedulerImplTest, TestLongIdlePeriod) {

base::TimeTicks expected_deadline =

- clock_->Now() + maximum_idle_period_duration();

+ clock_->NowTicks() + maximum_idle_period_duration();

base::TimeTicks deadline_in_task;

int run_count = 0;

@@ -1187,7 +1196,7 @@ TEST_F(RendererSchedulerImplTest, TestLongIdlePeriod) {

TEST_F(RendererSchedulerImplTest, TestLongIdlePeriodWithPendingDelayedTask) {

base::TimeDelta pending_task_delay = base::TimeDelta::FromMilliseconds(30);

- base::TimeTicks expected_deadline = clock_->Now() + pending_task_delay;

+ base::TimeTicks expected_deadline = clock_->NowTicks() + pending_task_delay;

base::TimeTicks deadline_in_task;

int run_count = 0;

@@ -1212,7 +1221,7 @@ TEST_F(RendererSchedulerImplTest,

pending_task_delay);

// Advance clock until after delayed task was meant to be run.

- clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(20));

+ clock_->Advance(base::TimeDelta::FromMilliseconds(20));

// Post an idle task and BeginFrameNotExpectedSoon to initiate a long idle

// period. Since there is a late pending delayed task this shouldn't actually

@@ -1224,7 +1233,7 @@ TEST_F(RendererSchedulerImplTest,

EXPECT_EQ(0, run_count);

// After the delayed task has been run we should trigger an idle period.

- clock_->AdvanceNow(maximum_idle_period_duration());

+ clock_->Advance(maximum_idle_period_duration());

RunUntilIdle();

EXPECT_EQ(1, run_count);

}

@@ -1243,15 +1252,15 @@ TEST_F(RendererSchedulerImplTest, TestLongIdlePeriodRepeating) {

// Advance time to start of next long idle period and check task reposted task

// gets run.

- clock_->AdvanceNow(maximum_idle_period_duration());

+ clock_->Advance(maximum_idle_period_duration());

RunUntilIdle();

EXPECT_EQ(2, run_count);

// Advance time to start of next long idle period then end idle period with a

// new BeginMainFrame and check idle task doesn't run.

- clock_->AdvanceNow(maximum_idle_period_duration());

+ clock_->Advance(maximum_idle_period_duration());

scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(

- BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),

+ BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),

base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));

RunUntilIdle();

EXPECT_EQ(2, run_count);

@@ -1269,7 +1278,7 @@ TEST_F(RendererSchedulerImplTest, TestLongIdlePeriodDoesNotWakeScheduler) {

// idle period.

base::TimeTicks idle_period_deadline =

scheduler_->CurrentIdleTaskDeadlineForTesting();

- clock_->AdvanceNow(maximum_idle_period_duration());

+ clock_->Advance(maximum_idle_period_duration());

RunUntilIdle();

base::TimeTicks new_idle_period_deadline =

@@ -1310,7 +1319,7 @@ TEST_F(RendererSchedulerImplTest, TestLongIdlePeriodInTouchStartPolicy) {

EXPECT_EQ(0, run_count);

// The long idle period should start after the touchstart policy has finished.

- clock_->AdvanceNow(priority_escalation_after_input_duration());

+ clock_->Advance(priority_escalation_after_input_duration());

RunUntilIdle();

EXPECT_EQ(1, run_count);

}

@@ -1355,7 +1364,7 @@ TEST_F(RendererSchedulerImplTest, CanExceedIdleDeadlineIfRequired) {

// Next long idle period will be for the maximum time, so

// CanExceedIdleDeadlineIfRequired should return true.

- clock_->AdvanceNow(maximum_idle_period_duration());

+ clock_->Advance(maximum_idle_period_duration());

idle_task_runner_->PostIdleTask(

FROM_HERE,

base::Bind(&TestCanExceedIdleDeadlineIfRequiredTask, scheduler_.get(),

@@ -1367,7 +1376,7 @@ TEST_F(RendererSchedulerImplTest, CanExceedIdleDeadlineIfRequired) {

// Next long idle period will be for the maximum time, so

// CanExceedIdleDeadlineIfRequired should return true.

scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(

- BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),

+ BEGINFRAME_FROM_HERE, clock_->NowTicks(), base::TimeTicks(),

base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));

EXPECT_FALSE(scheduler_->CanExceedIdleDeadlineIfRequired());

}

@@ -1390,14 +1399,14 @@ TEST_F(RendererSchedulerImplTest, TestRendererHiddenIdlePeriod) {

// Advance time to start of next long idle period and check task reposted task

// gets run.

- clock_->AdvanceNow(maximum_idle_period_duration());

+ clock_->Advance(maximum_idle_period_duration());

RunUntilIdle();

EXPECT_EQ(2, run_count);

// Advance time by amount of time by the maximum amount of time we execute

// idle tasks when hidden (plus some slack) - idle period should have ended.

- clock_->AdvanceNow(end_idle_when_hidden_delay() +

- base::TimeDelta::FromMilliseconds(10));

+ clock_->Advance(end_idle_when_hidden_delay() +

+ base::TimeDelta::FromMilliseconds(10));

RunUntilIdle();

EXPECT_EQ(2, run_count);

}

« components/scheduler/child/test_time_source.h ('K') | « components/scheduler/renderer/deadline_task_runner_unittest.cc ('k') | no next file » | no next file with comments »