content: Add RendererTaskQueueSelector.

content/renderer/scheduler/renderer_scheduler_selector_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/renderer_scheduler_selector.h"
+
+#include "base/bind.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/pending_task.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace content {
+
+class RendererSchedulerSelectorTest : public testing::Test {
+ public:
+  RendererSchedulerSelectorTest()
+      : test_closure_(base::Bind(&RendererSchedulerSelectorTest::TestFunction)),
+        selector_(),

[no sievers, 2014/10/28 01:21:01]

nit: default constructor invocations for selector_ and tasks_queues_ are
redundant

[rmcilroy, 2014/10/28 12:37:42]

Done.

+        task_queues_() {}
+  virtual ~RendererSchedulerSelectorTest() {}

[no sievers, 2014/10/28 01:21:01]

nit: ~RendererSchedulerSelectorTest() override {}

[rmcilroy, 2014/10/28 12:37:42]

Done.

+
+  std::vector<base::PendingTask> GetTasks(int count) {
+    std::vector<base::PendingTask> tasks;
+    for (int i = 0; i < count; i++) {
+      base::PendingTask task = base::PendingTask(FROM_HERE, test_closure_);
+      task.sequence_num = i;
+      tasks.push_back(task);
+    }
+    return tasks;
+  }
+
+  void PushTasks(const std::vector<base::PendingTask>& tasks,
+                 const std::vector<size_t>& queue_indices) {
+    EXPECT_EQ(tasks.size(), queue_indices.size());
+    for (size_t i = 0; i < tasks.size(); i++) {
+      task_queues_[queue_indices[i]]->push(tasks[i]);
+    }
+  }
+
+  std::vector<size_t> SelectedQueueOrder() {

[no sievers, 2014/10/28 01:21:01]

nit: maybe rename this to PopTasks()? Then it would match the above but more
importantly the side effect would be obvious and one would be less likely to add
a bad test below (that wants to test disabled queues for example but really ends
up repeatedly checking an already empty queue).

[rmcilroy, 2014/10/28 12:37:42]

Good point, Done.

+    std::vector<size_t> order;
+    size_t chosen_queue_index;
+    while (selector_.SelectWorkQueueToService(&chosen_queue_index)) {
+      order.push_back(chosen_queue_index);
+      task_queues_[chosen_queue_index]->pop();
+    }
+    return order;
+  }
+
+  static void TestFunction() {}
+
+ protected:
+  virtual void SetUp() {

[no sievers, 2014/10/28 01:21:01]

nit: void SetUp() override (or final)

[rmcilroy, 2014/10/28 12:37:42]

Done.

+    std::vector<const base::TaskQueue*> const_task_queues_;

[no sievers, 2014/10/28 01:21:01]

nit: no trailing '_' i.e. 'const_task_queues'

[rmcilroy, 2014/10/28 12:37:42]

Done.

+    for (size_t i = 0; i < kTaskQueueCount; i++) {
+      scoped_ptr<base::TaskQueue> task_queue =
+          make_scoped_ptr(new base::TaskQueue());

[no sievers, 2014/10/28 01:21:01]

nit: scoped_ptr<base::TaskQueue> task_queue(new base::TaskQueue());

[rmcilroy, 2014/10/28 12:37:42]

Done.

+      const_task_queues_.push_back(task_queue.get());
+      task_queues_.push_back(task_queue.Pass());
+    }
+    selector_.RegisterWorkQueues(const_task_queues_);
+  }
+
+  size_t kTaskQueueCount = 5;

[no sievers, 2014/10/28 01:21:01]

nit: const

[rmcilroy, 2014/10/28 12:37:42]

Done.

+  base::Closure test_closure_;
+  RendererSchedulerSelector selector_;
+  std::vector<scoped_ptr<base::TaskQueue>> task_queues_;
+};
+
+TEST_F(RendererSchedulerSelectorTest, TestDefaultPriority) {
+  std::vector<base::PendingTask> tasks = GetTasks(5);
+  PushTasks(tasks, std::vector<size_t>{4, 3, 2, 1, 0});
+  EXPECT_THAT(SelectedQueueOrder(), testing::ElementsAre(4, 3, 2, 1, 0));
+}
+
+TEST_F(RendererSchedulerSelectorTest, TestHighPriority) {
+  std::vector<base::PendingTask> tasks = GetTasks(5);
+  PushTasks(tasks, std::vector<size_t>{0, 1, 2, 3, 4});
+  selector_.SetQueuePriority(2, RendererSchedulerSelector::kHighPriority);
+  EXPECT_THAT(SelectedQueueOrder(), testing::ElementsAre(2, 0, 1, 3, 4));
+}
+
+TEST_F(RendererSchedulerSelectorTest, TestBestEffortPriority) {
+  std::vector<base::PendingTask> tasks = GetTasks(5);
+  PushTasks(tasks, std::vector<size_t>{0, 1, 2, 3, 4});
+  selector_.SetQueuePriority(0, RendererSchedulerSelector::kBestEffortPriority);
+  selector_.SetQueuePriority(2, RendererSchedulerSelector::kHighPriority);
+  EXPECT_THAT(SelectedQueueOrder(), testing::ElementsAre(2, 1, 3, 4, 0));
+}
+
+TEST_F(RendererSchedulerSelectorTest, TestControlPriority) {
+  std::vector<base::PendingTask> tasks = GetTasks(5);
+  PushTasks(tasks, std::vector<size_t>{0, 1, 2, 3, 4});
+  selector_.SetQueuePriority(4, RendererSchedulerSelector::kControlPriority);
+  selector_.SetQueuePriority(2, RendererSchedulerSelector::kHighPriority);
+  EXPECT_THAT(SelectedQueueOrder(), testing::ElementsAre(4, 2, 0, 1, 3));
+}
+
+TEST_F(RendererSchedulerSelectorTest, TestDisableEnable) {
+  std::vector<base::PendingTask> tasks = GetTasks(5);
+  PushTasks(tasks, std::vector<size_t>{0, 1, 2, 3, 4});
+  selector_.DisableQueue(2);
+  selector_.DisableQueue(4);
+  EXPECT_THAT(SelectedQueueOrder(), testing::ElementsAre(0, 1, 3));
+  selector_.EnableQueue(2, RendererSchedulerSelector::kBestEffortPriority);
+  EXPECT_THAT(SelectedQueueOrder(), testing::ElementsAre(2));
+  selector_.EnableQueue(4, RendererSchedulerSelector::kNormalPriority);
+  EXPECT_THAT(SelectedQueueOrder(), testing::ElementsAre(4));
+}
+
+TEST_F(RendererSchedulerSelectorTest, TestEmptyQueues) {
+  size_t chosen_queue_index = 0;
+  EXPECT_FALSE(selector_.SelectWorkQueueToService(&chosen_queue_index));
+
+  // Test only disabled queues.
+  std::vector<base::PendingTask> tasks = GetTasks(1);
+  PushTasks(tasks, std::vector<size_t>{0});
+  selector_.DisableQueue(0);
+  EXPECT_FALSE(selector_.SelectWorkQueueToService(&chosen_queue_index));
+}
+
+TEST_F(RendererSchedulerSelectorTest, TestDelay) {
+  std::vector<base::PendingTask> tasks = GetTasks(5);
+  tasks[0].delayed_run_time =
+      base::TimeTicks() + base::TimeDelta::FromMilliseconds(200);
+  tasks[3].delayed_run_time =
+      base::TimeTicks() + base::TimeDelta::FromMilliseconds(100);
+  PushTasks(tasks, std::vector<size_t>{0, 1, 2, 3, 4});
+  EXPECT_THAT(SelectedQueueOrder(), testing::ElementsAre(1, 2, 4, 3, 0));
+}
+
+TEST_F(RendererSchedulerSelectorTest, TestControlStarvesOthers) {
+  std::vector<base::PendingTask> tasks = GetTasks(4);
+  PushTasks(tasks, std::vector<size_t>{0, 1, 2, 3});
+  selector_.SetQueuePriority(3, RendererSchedulerSelector::kControlPriority);
+  selector_.SetQueuePriority(2, RendererSchedulerSelector::kHighPriority);
+  selector_.SetQueuePriority(1, RendererSchedulerSelector::kBestEffortPriority);
+  for (int i = 0; i < 100; i++) {
+    size_t chosen_queue_index = 0;
+    EXPECT_TRUE(selector_.SelectWorkQueueToService(&chosen_queue_index));
+    EXPECT_EQ(3ul, chosen_queue_index);
+    // Don't remove task from queue to simulate all queues still being full.
+  }
+}
+
+TEST_F(RendererSchedulerSelectorTest, TestHighPriorityDoesNotStarveNormal) {
+  std::vector<base::PendingTask> tasks = GetTasks(3);
+  PushTasks(tasks, std::vector<size_t>{0, 1, 2});
+  selector_.SetQueuePriority(2, RendererSchedulerSelector::kHighPriority);
+  selector_.SetQueuePriority(1, RendererSchedulerSelector::kBestEffortPriority);
+  std::vector<size_t> counts = {0, 0, 0};
+  for (int i = 0; i < 100; i++) {
+    size_t chosen_queue_index = 0;
+    EXPECT_TRUE(selector_.SelectWorkQueueToService(&chosen_queue_index));
+    counts[chosen_queue_index]++;
+    // Don't remove task from queue to simulate all queues still being full.
+  }
+  EXPECT_GT(counts[0], 0ul);        // Check high doesn't starve normal.
+  EXPECT_GT(counts[2], counts[0]);  // Check high get's more chance to run.
+  EXPECT_EQ(0ul, counts[1]);        // Check best effort is starved.
+}
+
+TEST_F(RendererSchedulerSelectorTest, TestBestEffortGetsStarved) {
+  std::vector<base::PendingTask> tasks = GetTasks(2);
+  PushTasks(tasks, std::vector<size_t>{0, 1});
+  selector_.SetQueuePriority(0, RendererSchedulerSelector::kBestEffortPriority);
+  selector_.SetQueuePriority(1, RendererSchedulerSelector::kNormalPriority);
+  size_t chosen_queue_index = 0;
+  for (int i = 0; i < 100; i++) {
+    EXPECT_TRUE(selector_.SelectWorkQueueToService(&chosen_queue_index));
+    EXPECT_EQ(1ul, chosen_queue_index);
+    // Don't remove task from queue to simulate all queues still being full.
+  }
+  selector_.SetQueuePriority(1, RendererSchedulerSelector::kHighPriority);
+  for (int i = 0; i < 100; i++) {
+    EXPECT_TRUE(selector_.SelectWorkQueueToService(&chosen_queue_index));
+    EXPECT_EQ(1ul, chosen_queue_index);
+    // Don't remove task from queue to simulate all queues still being full.
+  }
+  selector_.SetQueuePriority(1, RendererSchedulerSelector::kControlPriority);
+  for (int i = 0; i < 100; i++) {
+    EXPECT_TRUE(selector_.SelectWorkQueueToService(&chosen_queue_index));
+    EXPECT_EQ(1ul, chosen_queue_index);
+    // Don't remove task from queue to simulate all queues still being full.
+  }
+}
+
+}  // namespace content