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