Run task queue manager work in batches

content/renderer/scheduler/task_queue_manager_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/scheduler/task_queue_manager.h"
 
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread.h"
+#include "cc/test/test_now_source.h"
 #include "content/renderer/scheduler/task_queue_selector.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using testing::ElementsAre;
 
 namespace content {
 namespace {
 
 class SelectorForTest : public TaskQueueSelector {
  public:
@@ skipping 230 matching lines @@
   test_task_runner_->RunPendingTasks();
   EXPECT_FALSE(manager_->IsQueueEmpty(0));
   EXPECT_TRUE(run_order.empty());
 
   // After the delay the task runs normally.
   selector_->AppendQueueToService(0);
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1));
 }
 
+TEST_F(TaskQueueManagerTest, DelayedTaskDoesNotStayDelayed) {
+  Initialize(1u);
+
+  std::vector<int> run_order;
+  scoped_refptr<base::SingleThreadTaskRunner> runner =
+      manager_->TaskRunnerForQueue(0);
+
+  selector_->AppendQueueToService(0);
+
+  base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10));
+  runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
+                          delay);
+  test_task_runner_->RunPendingTasks();
+
+  // Reload the work queue so we see the next pending task. It should no longer
+  // be marked as delayed.
+  manager_->PumpQueue(0);
+  EXPECT_TRUE(selector_->work_queues()[0]->front().delayed_run_time.is_null());
+
+  // Let the task run normally.
+  selector_->AppendQueueToService(0);
+  test_task_runner_->RunUntilIdle();
+  EXPECT_THAT(run_order, ElementsAre(1));
+}
+
 TEST_F(TaskQueueManagerTest, ManualPumping) {
   Initialize(1u);
   manager_->SetAutoPump(0, false);
 
   std::vector<int> run_order;
   scoped_refptr<base::SingleThreadTaskRunner> runner =
       manager_->TaskRunnerForQueue(0);
 
   // Posting a task when pumping is disabled doesn't result in work getting
   // posted.
@@ skipping 204 matching lines @@
   runner->PostTask(
       FROM_HERE, base::Bind(&PostFromNestedRunloop, message_loop_.get(), runner,
                             base::Unretained(&tasks_to_post_from_nested_loop)));
   runner->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
 
   message_loop_->RunUntilIdle();
 
   EXPECT_THAT(run_order, ElementsAre(0, 2, 1));
 }
 
+TEST_F(TaskQueueManagerTest, WorkBatching) {
+  Initialize(1u);
+
+  manager_->SetWorkBatchSize(2);
+
+  std::vector<int> run_order;
+  scoped_refptr<base::SingleThreadTaskRunner> runner =
+      manager_->TaskRunnerForQueue(0);
+
+  selector_->AppendQueueToService(0);
+  selector_->AppendQueueToService(0);
+  selector_->AppendQueueToService(0);
+  selector_->AppendQueueToService(0);
+
+  runner->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
+  runner->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
+  runner->PostTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order));
+  runner->PostTask(FROM_HERE, base::Bind(&TestTask, 4, &run_order));
+
+  // Running one task in the host message loop should cause two posted tasks to
+  // get executed.
+  EXPECT_EQ(test_task_runner_->GetPendingTasks().size(), 1u);
+  test_task_runner_->RunPendingTasks();
+  EXPECT_THAT(run_order, ElementsAre(1, 2));
+
+  // The second task runs the remaining two posted tasks.
+  EXPECT_EQ(test_task_runner_->GetPendingTasks().size(), 1u);
+  test_task_runner_->RunPendingTasks();
+  EXPECT_THAT(run_order, ElementsAre(1, 2, 3, 4));
+}
+
+void AdvanceNowTestTask(int value,
+                        std::vector<int>* out_result,
+                        scoped_refptr<cc::TestNowSource> time_source,
+                        base::TimeDelta delta) {
+  TestTask(value, out_result);
+  time_source->AdvanceNow(delta);
+}
+
+TEST_F(TaskQueueManagerTest, InterruptWorkBatchForDelayedTask) {
+  scoped_refptr<cc::TestNowSource> clock(cc::TestNowSource::Create());
+  Initialize(1u);
+
+  manager_->SetWorkBatchSize(2);
+  manager_->SetTimeSourceForTesting(clock);
+
+  std::vector<int> run_order;
+  scoped_refptr<base::SingleThreadTaskRunner> runner =
+      manager_->TaskRunnerForQueue(0);
+
+  selector_->AppendQueueToService(0);
+  selector_->AppendQueueToService(0);
+  selector_->AppendQueueToService(0);
+
+  base::TimeDelta delta(base::TimeDelta::FromMilliseconds(10));
+  runner->PostTask(
+      FROM_HERE, base::Bind(&AdvanceNowTestTask, 2, &run_order, clock, delta));
+  runner->PostTask(
+      FROM_HERE, base::Bind(&AdvanceNowTestTask, 3, &run_order, clock, delta));
+
+  base::TimeDelta delay(base::TimeDelta::FromMilliseconds(5));
+  runner->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
+                          delay);
+
+  // At this point we have two posted tasks: one for DoWork and one of the
+  // delayed task. Only the first non-delayed task should get executed because
+  // the work batch is interrupted by the pending delayed task.
+  EXPECT_EQ(test_task_runner_->GetPendingTasks().size(), 2u);
+  test_task_runner_->RunPendingTasks();
+  EXPECT_THAT(run_order, ElementsAre(2));
+
+  // Running all remaining tasks should execute both pending tasks.
+  test_task_runner_->RunUntilIdle();
+  EXPECT_THAT(run_order, ElementsAre(2, 3, 1));
+}
+
 }  // namespace
 }  // namespace content