content/renderer/scheduler/renderer_scheduler_impl_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/renderer/scheduler/renderer_scheduler_impl.h"
   6
   7 #include "base/callback.h"
   8 #include "cc/output/begin_frame_args.h"
   9 #include "cc/test/ordered_simple_task_runner.h"
  10 #include "testing/gmock/include/gmock/gmock.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 namespace content {
  14
  15 namespace {
  16 class FakeInputEvent : public blink::WebInputEvent {
  17  public:
  18   explicit FakeInputEvent(blink::WebInputEvent::Type event_type)
  19       : WebInputEvent(sizeof(FakeInputEvent)) {
  20     type = event_type;
  21   }
  22
  23   FakeInputEvent(blink::WebInputEvent::Type event_type, int event_modifiers)
  24       : WebInputEvent(sizeof(FakeInputEvent)) {
  25     type = event_type;
  26     modifiers = event_modifiers;
  27   }
  28 };
  29 };  // namespace
  30
  31 class RendererSchedulerImplTest : public testing::Test {
  32  public:
  33   RendererSchedulerImplTest()
  34       : clock_(cc::TestNowSource::Create(5000)),
  35         mock_task_runner_(new cc::OrderedSimpleTaskRunner(clock_, false)),
  36         scheduler_(new RendererSchedulerImpl(mock_task_runner_)),
  37         default_task_runner_(scheduler_->DefaultTaskRunner()),
  38         compositor_task_runner_(scheduler_->CompositorTaskRunner()),
  39         loading_task_runner_(scheduler_->LoadingTaskRunner()),
  40         idle_task_runner_(scheduler_->IdleTaskRunner()) {
  41     scheduler_->SetTimeSourceForTesting(clock_);
  42   }
  43   ~RendererSchedulerImplTest() override {}
  44
  45   void RunUntilIdle() { mock_task_runner_->RunUntilIdle(); }
  46
  47   void EnableIdleTasks() {
  48     scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
  49         BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
  50         base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
  51     scheduler_->DidCommitFrameToCompositor();
  52   }
  53
  54  protected:
  55   static base::TimeDelta compositor_priority_after_touch_duration() {
  56     return base::TimeDelta::FromMilliseconds(
  57         RendererSchedulerImpl::kCompositorPriorityAfterTouchMillis);
  58   }
  59
  60   scoped_refptr<cc::TestNowSource> clock_;
  61   scoped_refptr<cc::OrderedSimpleTaskRunner> mock_task_runner_;
  62
  63   scoped_ptr<RendererSchedulerImpl> scheduler_;
  64   scoped_refptr<base::SingleThreadTaskRunner> default_task_runner_;
  65   scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
  66   scoped_refptr<base::SingleThreadTaskRunner> loading_task_runner_;
  67   scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner_;
  68
  69   DISALLOW_COPY_AND_ASSIGN(RendererSchedulerImplTest);
  70 };
  71
  72 void NullTask() {
  73 }
  74
  75 void OrderedTestTask(int value, int* result) {
  76   *result = (*result << 4) | value;
  77 }
  78
  79 void UnorderedTestTask(int value, int* result) {
  80   *result += value;
  81 }
  82
  83 void AppendToVectorTestTask(std::vector<std::string>* vector,
  84                             std::string value) {
  85   vector->push_back(value);
  86 }
  87
  88 void AppendToVectorIdleTestTask(std::vector<std::string>* vector,
  89                                 std::string value,
  90                                 base::TimeTicks deadline) {
  91   AppendToVectorTestTask(vector, value);
  92 }
  93
  94 void AppendToVectorReentrantTask(
  95     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
  96     std::vector<int>* vector,
  97     int* reentrant_count,
  98     int max_reentrant_count) {
  99   vector->push_back((*reentrant_count)++);
 100   if (*reentrant_count < max_reentrant_count) {
 101     task_runner->PostTask(
 102         FROM_HERE, base::Bind(AppendToVectorReentrantTask, task_runner, vector,
 103                               reentrant_count, max_reentrant_count));
 104   }
 105 }
 106
 107 void IdleTestTask(bool* task_run,
 108                   base::TimeTicks* deadline_out,
 109                   base::TimeTicks deadline) {
 110   EXPECT_FALSE(*task_run);
 111   *deadline_out = deadline;
 112   *task_run = true;
 113 }
 114
 115 void RepostingIdleTestTask(
 116     scoped_refptr<SingleThreadIdleTaskRunner> idle_task_runner,
 117     int* run_count,
 118     base::TimeTicks deadline) {
 119   if (*run_count == 0) {
 120     idle_task_runner->PostIdleTask(
 121         FROM_HERE,
 122         base::Bind(&RepostingIdleTestTask, idle_task_runner, run_count));
 123   }
 124   (*run_count)++;
 125 }
 126
 127 void UpdateClockToDeadlineIdleTestTask(
 128     scoped_refptr<cc::TestNowSource> clock,
 129     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
 130     int* run_count,
 131     base::TimeTicks deadline) {
 132   clock->SetNow(deadline);
 133   // Due to the way in which OrderedSimpleTestRunner orders tasks and the fact
 134   // that we updated the time within a task, the delayed pending task to call
 135   // EndIdlePeriod will not happen until after a TaskQueueManager DoWork, so
 136   // post a normal task here to ensure it runs before the next idle task.
 137   task_runner->PostTask(FROM_HERE, base::Bind(NullTask));
 138   (*run_count)++;
 139 }
 140
 141 void PostingYieldingTestTask(
 142     RendererSchedulerImpl* scheduler,
 143     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
 144     bool simulate_input,
 145     bool* should_yield_before,
 146     bool* should_yield_after) {
 147   *should_yield_before = scheduler->ShouldYieldForHighPriorityWork();
 148   task_runner->PostTask(FROM_HERE, base::Bind(NullTask));
 149   if (simulate_input) {
 150     scheduler->DidReceiveInputEventOnCompositorThread(
 151         FakeInputEvent(blink::WebInputEvent::GestureFlingStart));
 152   }
 153   *should_yield_after = scheduler->ShouldYieldForHighPriorityWork();
 154 }
 155
 156 void AnticipationTestTask(RendererSchedulerImpl* scheduler,
 157                           bool simulate_input,
 158                           bool* is_anticipated_before,
 159                           bool* is_anticipated_after) {
 160   *is_anticipated_before = scheduler->IsHighPriorityWorkAnticipated();
 161   if (simulate_input) {
 162     scheduler->DidReceiveInputEventOnCompositorThread(
 163         FakeInputEvent(blink::WebInputEvent::GestureFlingStart));
 164   }
 165   *is_anticipated_after = scheduler->IsHighPriorityWorkAnticipated();
 166 }
 167
 168 TEST_F(RendererSchedulerImplTest, TestPostDefaultTask) {
 169   int result = 0;
 170   default_task_runner_->PostTask(FROM_HERE,
 171                                  base::Bind(OrderedTestTask, 1, &result));
 172   default_task_runner_->PostTask(FROM_HERE,
 173                                  base::Bind(OrderedTestTask, 2, &result));
 174   default_task_runner_->PostTask(FROM_HERE,
 175                                  base::Bind(OrderedTestTask, 3, &result));
 176   default_task_runner_->PostTask(FROM_HERE,
 177                                  base::Bind(OrderedTestTask, 4, &result));
 178   RunUntilIdle();
 179   EXPECT_EQ(0x1234, result);
 180 }
 181
 182 TEST_F(RendererSchedulerImplTest, TestPostDefaultAndCompositor) {
 183   int result = 0;
 184   default_task_runner_->PostTask(FROM_HERE,
 185                                  base::Bind(&UnorderedTestTask, 1, &result));
 186   compositor_task_runner_->PostTask(FROM_HERE,
 187                                     base::Bind(&UnorderedTestTask, 2, &result));
 188   RunUntilIdle();
 189   EXPECT_EQ(3, result);
 190 }
 191
 192 TEST_F(RendererSchedulerImplTest, TestRentrantTask) {
 193   int count = 0;
 194   std::vector<int> order;
 195   default_task_runner_->PostTask(
 196       FROM_HERE, base::Bind(AppendToVectorReentrantTask, default_task_runner_,
 197                             &order, &count, 5));
 198   RunUntilIdle();
 199
 200   EXPECT_THAT(order, testing::ElementsAre(0, 1, 2, 3, 4));
 201 }
 202
 203 TEST_F(RendererSchedulerImplTest, TestPostIdleTask) {
 204   bool task_run = false;
 205   base::TimeTicks expected_deadline =
 206       clock_->Now() + base::TimeDelta::FromMilliseconds(2300);
 207   base::TimeTicks deadline_in_task;
 208
 209   clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(100));
 210   idle_task_runner_->PostIdleTask(
 211       FROM_HERE, base::Bind(&IdleTestTask, &task_run, &deadline_in_task));
 212
 213   RunUntilIdle();
 214   EXPECT_FALSE(task_run);  // Shouldn't run yet as no WillBeginFrame.
 215
 216   scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
 217       BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
 218       base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
 219   RunUntilIdle();
 220   EXPECT_FALSE(task_run);  // Shouldn't run as no DidCommitFrameToCompositor.
 221
 222   clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(1200));
 223   scheduler_->DidCommitFrameToCompositor();
 224   RunUntilIdle();
 225   EXPECT_FALSE(task_run);  // We missed the deadline.
 226
 227   scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
 228       BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
 229       base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
 230   clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(800));
 231   scheduler_->DidCommitFrameToCompositor();
 232   RunUntilIdle();
 233   EXPECT_TRUE(task_run);
 234   EXPECT_EQ(expected_deadline, deadline_in_task);
 235 }
 236
 237 TEST_F(RendererSchedulerImplTest, TestRepostingIdleTask) {
 238   int run_count = 0;
 239
 240   idle_task_runner_->PostIdleTask(
 241       FROM_HERE,
 242       base::Bind(&RepostingIdleTestTask, idle_task_runner_, &run_count));
 243   EnableIdleTasks();
 244   RunUntilIdle();
 245   EXPECT_EQ(1, run_count);
 246
 247   // Reposted tasks shouldn't run until next idle period.
 248   RunUntilIdle();
 249   EXPECT_EQ(1, run_count);
 250
 251   EnableIdleTasks();
 252   RunUntilIdle();
 253   EXPECT_EQ(2, run_count);
 254 }
 255
 256 TEST_F(RendererSchedulerImplTest, TestIdleTaskExceedsDeadline) {
 257   mock_task_runner_->SetAutoAdvanceNowToPendingTasks(true);
 258   int run_count = 0;
 259
 260   // Post two UpdateClockToDeadlineIdleTestTask tasks.
 261   idle_task_runner_->PostIdleTask(
 262       FROM_HERE, base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_,
 263                             default_task_runner_, &run_count));
 264   idle_task_runner_->PostIdleTask(
 265       FROM_HERE, base::Bind(&UpdateClockToDeadlineIdleTestTask, clock_,
 266                             default_task_runner_, &run_count));
 267
 268   EnableIdleTasks();
 269   RunUntilIdle();
 270   // Only the first idle task should execute since it's used up the deadline.
 271   EXPECT_EQ(1, run_count);
 272
 273   EnableIdleTasks();
 274   RunUntilIdle();
 275   // Second task should be run on the next idle period.
 276   EXPECT_EQ(2, run_count);
 277 }
 278
 279 TEST_F(RendererSchedulerImplTest, TestDelayedEndIdlePeriodCanceled) {
 280   bool task_run = false;
 281
 282   base::TimeTicks deadline_in_task;
 283   idle_task_runner_->PostIdleTask(
 284       FROM_HERE, base::Bind(&IdleTestTask, &task_run, &deadline_in_task));
 285
 286   // Trigger the beginning of an idle period for 1000ms.
 287   scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
 288       BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
 289       base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
 290   scheduler_->DidCommitFrameToCompositor();
 291
 292   // End the idle period early (after 500ms), and send a WillBeginFrame which
 293   // specifies that the next idle period should end 1000ms from now.
 294   clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(500));
 295   scheduler_->WillBeginFrame(cc::BeginFrameArgs::Create(
 296       BEGINFRAME_FROM_HERE, clock_->Now(), base::TimeTicks(),
 297       base::TimeDelta::FromMilliseconds(1000), cc::BeginFrameArgs::NORMAL));
 298
 299   RunUntilIdle();
 300   EXPECT_FALSE(task_run);  // Not currently in an idle period.
 301
 302   // Trigger the start of the idle period before the task to end the previous
 303   // idle period has been triggered.
 304   clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(400));
 305   scheduler_->DidCommitFrameToCompositor();
 306
 307   // Post a task which simulates running until after the previous end idle
 308   // period delayed task was scheduled for
 309   scheduler_->DefaultTaskRunner()->PostTask(FROM_HERE, base::Bind(NullTask));
 310   clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(300));
 311
 312   RunUntilIdle();
 313   EXPECT_TRUE(task_run);  // We should still be in the new idle period.
 314 }
 315
 316 TEST_F(RendererSchedulerImplTest, TestDefaultPolicy) {
 317   std::vector<std::string> order;
 318
 319   loading_task_runner_->PostTask(
 320       FROM_HERE,
 321       base::Bind(&AppendToVectorTestTask, &order, std::string("L1")));
 322   idle_task_runner_->PostIdleTask(
 323       FROM_HERE,
 324       base::Bind(&AppendToVectorIdleTestTask, &order, std::string("I1")));
 325   default_task_runner_->PostTask(
 326       FROM_HERE,
 327       base::Bind(&AppendToVectorTestTask, &order, std::string("D1")));
 328   compositor_task_runner_->PostTask(
 329       FROM_HERE,
 330       base::Bind(&AppendToVectorTestTask, &order, std::string("C1")));
 331   default_task_runner_->PostTask(
 332       FROM_HERE,
 333       base::Bind(&AppendToVectorTestTask, &order, std::string("D2")));
 334   compositor_task_runner_->PostTask(
 335       FROM_HERE,
 336       base::Bind(&AppendToVectorTestTask, &order, std::string("C2")));
 337
 338   EnableIdleTasks();
 339   RunUntilIdle();
 340   EXPECT_THAT(order, testing::ElementsAre(
 341       std::string("L1"), std::string("D1"), std::string("C1"),
 342       std::string("D2"), std::string("C2"), std::string("I1")));
 343 }
 344
 345 TEST_F(RendererSchedulerImplTest, TestCompositorPolicy) {
 346   std::vector<std::string> order;
 347
 348   loading_task_runner_->PostTask(
 349       FROM_HERE,
 350       base::Bind(&AppendToVectorTestTask, &order, std::string("L1")));
 351   idle_task_runner_->PostIdleTask(
 352       FROM_HERE,
 353       base::Bind(&AppendToVectorIdleTestTask, &order, std::string("I1")));
 354   default_task_runner_->PostTask(
 355       FROM_HERE,
 356       base::Bind(&AppendToVectorTestTask, &order, std::string("D1")));
 357   compositor_task_runner_->PostTask(
 358       FROM_HERE,
 359       base::Bind(&AppendToVectorTestTask, &order, std::string("C1")));
 360   default_task_runner_->PostTask(
 361       FROM_HERE,
 362       base::Bind(&AppendToVectorTestTask, &order, std::string("D2")));
 363   compositor_task_runner_->PostTask(
 364       FROM_HERE,
 365       base::Bind(&AppendToVectorTestTask, &order, std::string("C2")));
 366
 367   scheduler_->DidReceiveInputEventOnCompositorThread(
 368       FakeInputEvent(blink::WebInputEvent::GestureFlingStart));
 369   EnableIdleTasks();
 370   RunUntilIdle();
 371   EXPECT_THAT(order, testing::ElementsAre(
 372       std::string("C1"), std::string("C2"), std::string("D1"),
 373       std::string("D2"), std::string("L1"), std::string("I1")));
 374 }
 375
 376 TEST_F(RendererSchedulerImplTest, TestCompositorPolicy_DidAnimateForInput) {
 377   std::vector<std::string> order;
 378
 379   idle_task_runner_->PostIdleTask(
 380       FROM_HERE,
 381       base::Bind(&AppendToVectorIdleTestTask, &order, std::string("I1")));
 382   default_task_runner_->PostTask(
 383       FROM_HERE,
 384       base::Bind(&AppendToVectorTestTask, &order, std::string("D1")));
 385   compositor_task_runner_->PostTask(
 386       FROM_HERE,
 387       base::Bind(&AppendToVectorTestTask, &order, std::string("C1")));
 388   default_task_runner_->PostTask(
 389       FROM_HERE,
 390       base::Bind(&AppendToVectorTestTask, &order, std::string("D2")));
 391   compositor_task_runner_->PostTask(
 392       FROM_HERE,
 393       base::Bind(&AppendToVectorTestTask, &order, std::string("C2")));
 394
 395   scheduler_->DidAnimateForInputOnCompositorThread();
 396   EnableIdleTasks();
 397   RunUntilIdle();
 398   EXPECT_THAT(order, testing::ElementsAre(std::string("C1"), std::string("C2"),
 399                                           std::string("D1"), std::string("D2"),
 400                                           std::string("I1")));
 401 }
 402
 403 TEST_F(RendererSchedulerImplTest,
 404        DidReceiveInputEventOnCompositorThread_IgnoresMouseMove_WhenMouseUp) {
 405   std::vector<std::string> order;
 406
 407   idle_task_runner_->PostIdleTask(
 408       FROM_HERE,
 409       base::Bind(&AppendToVectorIdleTestTask, &order, std::string("I1")));
 410   default_task_runner_->PostTask(
 411       FROM_HERE,
 412       base::Bind(&AppendToVectorTestTask, &order, std::string("D1")));
 413   compositor_task_runner_->PostTask(
 414       FROM_HERE,
 415       base::Bind(&AppendToVectorTestTask, &order, std::string("C1")));
 416   default_task_runner_->PostTask(
 417       FROM_HERE,
 418       base::Bind(&AppendToVectorTestTask, &order, std::string("D2")));
 419   compositor_task_runner_->PostTask(
 420       FROM_HERE,
 421       base::Bind(&AppendToVectorTestTask, &order, std::string("C2")));
 422
 423   scheduler_->DidReceiveInputEventOnCompositorThread(
 424       FakeInputEvent(blink::WebInputEvent::MouseMove));
 425   EnableIdleTasks();
 426   RunUntilIdle();
 427   // Note compositor tasks are not prioritized.
 428   EXPECT_THAT(order, testing::ElementsAre(std::string("D1"), std::string("C1"),
 429                                           std::string("D2"), std::string("C2"),
 430                                           std::string("I1")));
 431 }
 432
 433 TEST_F(RendererSchedulerImplTest,
 434        DidReceiveInputEventOnCompositorThread_MouseMove_WhenMouseDown) {
 435   std::vector<std::string> order;
 436
 437   idle_task_runner_->PostIdleTask(
 438       FROM_HERE,
 439       base::Bind(&AppendToVectorIdleTestTask, &order, std::string("I1")));
 440   default_task_runner_->PostTask(
 441       FROM_HERE,
 442       base::Bind(&AppendToVectorTestTask, &order, std::string("D1")));
 443   compositor_task_runner_->PostTask(
 444       FROM_HERE,
 445       base::Bind(&AppendToVectorTestTask, &order, std::string("C1")));
 446   default_task_runner_->PostTask(
 447       FROM_HERE,
 448       base::Bind(&AppendToVectorTestTask, &order, std::string("D2")));
 449   compositor_task_runner_->PostTask(
 450       FROM_HERE,
 451       base::Bind(&AppendToVectorTestTask, &order, std::string("C2")));
 452
 453   scheduler_->DidReceiveInputEventOnCompositorThread(FakeInputEvent(
 454       blink::WebInputEvent::MouseMove, blink::WebInputEvent::LeftButtonDown));
 455   EnableIdleTasks();
 456   RunUntilIdle();
 457   // Note compositor tasks are prioritized.
 458   EXPECT_THAT(order, testing::ElementsAre(std::string("C1"), std::string("C2"),
 459                                           std::string("D1"), std::string("D2"),
 460                                           std::string("I1")));
 461 }
 462
 463 TEST_F(RendererSchedulerImplTest,
 464        DidReceiveInputEventOnCompositorThread_MouseWheel) {
 465   std::vector<std::string> order;
 466
 467   idle_task_runner_->PostIdleTask(
 468       FROM_HERE,
 469       base::Bind(&AppendToVectorIdleTestTask, &order, std::string("I1")));
 470   default_task_runner_->PostTask(
 471       FROM_HERE,
 472       base::Bind(&AppendToVectorTestTask, &order, std::string("D1")));
 473   compositor_task_runner_->PostTask(
 474       FROM_HERE,
 475       base::Bind(&AppendToVectorTestTask, &order, std::string("C1")));
 476   default_task_runner_->PostTask(
 477       FROM_HERE,
 478       base::Bind(&AppendToVectorTestTask, &order, std::string("D2")));
 479   compositor_task_runner_->PostTask(
 480       FROM_HERE,
 481       base::Bind(&AppendToVectorTestTask, &order, std::string("C2")));
 482
 483   scheduler_->DidReceiveInputEventOnCompositorThread(
 484       FakeInputEvent(blink::WebInputEvent::MouseWheel));
 485   EnableIdleTasks();
 486   RunUntilIdle();
 487   // Note compositor tasks are prioritized.
 488   EXPECT_THAT(order, testing::ElementsAre(std::string("C1"), std::string("C2"),
 489                                           std::string("D1"), std::string("D2"),
 490                                           std::string("I1")));
 491 }
 492
 493 TEST_F(RendererSchedulerImplTest,
 494        DidReceiveInputEventOnCompositorThread_IgnoresKeyboardEvents) {
 495   std::vector<std::string> order;
 496
 497   idle_task_runner_->PostIdleTask(
 498       FROM_HERE,
 499       base::Bind(&AppendToVectorIdleTestTask, &order, std::string("I1")));
 500   default_task_runner_->PostTask(
 501       FROM_HERE,
 502       base::Bind(&AppendToVectorTestTask, &order, std::string("D1")));
 503   compositor_task_runner_->PostTask(
 504       FROM_HERE,
 505       base::Bind(&AppendToVectorTestTask, &order, std::string("C1")));
 506   default_task_runner_->PostTask(
 507       FROM_HERE,
 508       base::Bind(&AppendToVectorTestTask, &order, std::string("D2")));
 509   compositor_task_runner_->PostTask(
 510       FROM_HERE,
 511       base::Bind(&AppendToVectorTestTask, &order, std::string("C2")));
 512
 513   scheduler_->DidReceiveInputEventOnCompositorThread(
 514       FakeInputEvent(blink::WebInputEvent::KeyDown));
 515   EnableIdleTasks();
 516   RunUntilIdle();
 517   // Note compositor tasks are not prioritized.
 518   EXPECT_THAT(order, testing::ElementsAre(std::string("D1"), std::string("C1"),
 519                                           std::string("D2"), std::string("C2"),
 520                                           std::string("I1")));
 521 }
 522
 523 TEST_F(RendererSchedulerImplTest,
 524        TestCompositorPolicyDoesNotStarveDefaultTasks) {
 525   std::vector<std::string> order;
 526
 527   default_task_runner_->PostTask(
 528       FROM_HERE,
 529       base::Bind(&AppendToVectorTestTask, &order, std::string("D1")));
 530   compositor_task_runner_->PostTask(
 531       FROM_HERE,
 532       base::Bind(&AppendToVectorTestTask, &order, std::string("C1")));
 533   for (int i = 0; i < 20; i++) {
 534     compositor_task_runner_->PostTask(FROM_HERE, base::Bind(&NullTask));
 535   }
 536   compositor_task_runner_->PostTask(
 537       FROM_HERE,
 538       base::Bind(&AppendToVectorTestTask, &order, std::string("C2")));
 539
 540   scheduler_->DidReceiveInputEventOnCompositorThread(
 541       FakeInputEvent(blink::WebInputEvent::GestureFlingStart));
 542   RunUntilIdle();
 543   // Ensure that the default D1 task gets to run at some point before the final
 544   // C2 compositor task.
 545   EXPECT_THAT(order, testing::ElementsAre(std::string("C1"), std::string("D1"),
 546                                           std::string("C2")));
 547 }
 548
 549 TEST_F(RendererSchedulerImplTest, TestCompositorPolicyEnds) {
 550   std::vector<std::string> order;
 551
 552   default_task_runner_->PostTask(
 553       FROM_HERE,
 554       base::Bind(&AppendToVectorTestTask, &order, std::string("D1")));
 555   compositor_task_runner_->PostTask(
 556       FROM_HERE,
 557       base::Bind(&AppendToVectorTestTask, &order, std::string("C1")));
 558   default_task_runner_->PostTask(
 559       FROM_HERE,
 560       base::Bind(&AppendToVectorTestTask, &order, std::string("D2")));
 561   compositor_task_runner_->PostTask(
 562       FROM_HERE,
 563       base::Bind(&AppendToVectorTestTask, &order, std::string("C2")));
 564
 565   scheduler_->DidReceiveInputEventOnCompositorThread(
 566       FakeInputEvent(blink::WebInputEvent::GestureFlingStart));
 567   RunUntilIdle();
 568   EXPECT_THAT(order,
 569               testing::ElementsAre(std::string("C1"), std::string("C2"),
 570                                    std::string("D1"), std::string("D2")));
 571
 572   order.clear();
 573   clock_->AdvanceNow(base::TimeDelta::FromMilliseconds(1000));
 574
 575   default_task_runner_->PostTask(
 576       FROM_HERE,
 577       base::Bind(&AppendToVectorTestTask, &order, std::string("D1")));
 578   compositor_task_runner_->PostTask(
 579       FROM_HERE,
 580       base::Bind(&AppendToVectorTestTask, &order, std::string("C1")));
 581   default_task_runner_->PostTask(
 582       FROM_HERE,
 583       base::Bind(&AppendToVectorTestTask, &order, std::string("D2")));
 584   compositor_task_runner_->PostTask(
 585       FROM_HERE,
 586       base::Bind(&AppendToVectorTestTask, &order, std::string("C2")));
 587
 588   // Compositor policy mode should have ended now that the clock has advanced.
 589   RunUntilIdle();
 590   EXPECT_THAT(order,
 591               testing::ElementsAre(std::string("D1"), std::string("C1"),
 592                                    std::string("D2"), std::string("C2")));
 593 }
 594
 595 TEST_F(RendererSchedulerImplTest, TestIsHighPriorityWorkAnticipated) {
 596   bool is_anticipated_before = false;
 597   bool is_anticipated_after = false;
 598
 599   bool simulate_input = false;
 600   default_task_runner_->PostTask(
 601       FROM_HERE,
 602       base::Bind(&AnticipationTestTask, scheduler_.get(), simulate_input,
 603                  &is_anticipated_before, &is_anticipated_after));
 604   RunUntilIdle();
 605   // In its default state, without input receipt, the scheduler should indicate
 606   // that no high-priority is anticipated.
 607   EXPECT_FALSE(is_anticipated_before);
 608   EXPECT_FALSE(is_anticipated_after);
 609
 610   simulate_input = true;
 611   default_task_runner_->PostTask(
 612       FROM_HERE,
 613       base::Bind(&AnticipationTestTask, scheduler_.get(), simulate_input,
 614                  &is_anticipated_before, &is_anticipated_after));
 615   RunUntilIdle();
 616   // When input is received, the scheduler should indicate that high-priority
 617   // work is anticipated.
 618   EXPECT_FALSE(is_anticipated_before);
 619   EXPECT_TRUE(is_anticipated_after);
 620
 621   clock_->AdvanceNow(compositor_priority_after_touch_duration() * 2);
 622   simulate_input = false;
 623   default_task_runner_->PostTask(
 624       FROM_HERE,
 625       base::Bind(&AnticipationTestTask, scheduler_.get(), simulate_input,
 626                  &is_anticipated_before, &is_anticipated_after));
 627   RunUntilIdle();
 628   // Without additional input, the scheduler should indicate that high-priority
 629   // work is no longer anticipated.
 630   EXPECT_FALSE(is_anticipated_before);
 631   EXPECT_FALSE(is_anticipated_after);
 632 }
 633
 634 TEST_F(RendererSchedulerImplTest, TestShouldYield) {
 635   bool should_yield_before = false;
 636   bool should_yield_after = false;
 637
 638   default_task_runner_->PostTask(
 639       FROM_HERE, base::Bind(&PostingYieldingTestTask, scheduler_.get(),
 640                             default_task_runner_, false, &should_yield_before,
 641                             &should_yield_after));
 642   RunUntilIdle();
 643   // Posting to default runner shouldn't cause yielding.
 644   EXPECT_FALSE(should_yield_before);
 645   EXPECT_FALSE(should_yield_after);
 646
 647   default_task_runner_->PostTask(
 648       FROM_HERE, base::Bind(&PostingYieldingTestTask, scheduler_.get(),
 649                             compositor_task_runner_, false,
 650                             &should_yield_before, &should_yield_after));
 651   RunUntilIdle();
 652   // Posting while not in compositor priority shouldn't cause yielding.
 653   EXPECT_FALSE(should_yield_before);
 654   EXPECT_FALSE(should_yield_after);
 655
 656   default_task_runner_->PostTask(
 657       FROM_HERE, base::Bind(&PostingYieldingTestTask, scheduler_.get(),
 658                             compositor_task_runner_, true, &should_yield_before,
 659                             &should_yield_after));
 660   RunUntilIdle();
 661   // We should be able to switch to compositor priority mid-task.
 662   EXPECT_FALSE(should_yield_before);
 663   EXPECT_TRUE(should_yield_after);
 664 }
 665
 666 }  // namespace content