Adopt a less severe anti-starvation policy for immediate tasks

components/scheduler/base/task_queue_selector_unittest.cc

 // Copyright 2015 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 "components/scheduler/base/task_queue_selector.h"
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/pending_task.h"
 #include "components/scheduler/base/task_queue_impl.h"
@@ skipping 15 matching lines @@
 
   MOCK_METHOD1(OnTaskQueueEnabled, void(internal::TaskQueueImpl*));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockObserver);
 };
 
 class TaskQueueSelectorForTest : public TaskQueueSelector {
  public:
   using TaskQueueSelector::ChooseOldestWithPriority;
-  using TaskQueueSelector::SetForceSelectImmediateForTest;
+  using TaskQueueSelector::SetImmediateStarvationCountForTest;
 };
 
 class TaskQueueSelectorTest : public testing::Test {
  public:
   TaskQueueSelectorTest()
       : test_closure_(base::Bind(&TaskQueueSelectorTest::TestFunction)) {}
   ~TaskQueueSelectorTest() override {}
 
   void PushTasks(const size_t queue_indices[], size_t num_tasks) {
     std::set<size_t> changed_queue_set;
@@ skipping 230 matching lines @@
   size_t queue_order[] = {0, 1};
   PushTasks(queue_order, 2);
 
   EXPECT_FALSE(selector_.EnabledWorkQueuesEmpty());
   PopTasks();
   EXPECT_TRUE(selector_.EnabledWorkQueuesEmpty());
 }
 
 TEST_F(TaskQueueSelectorTest, ChooseOldestWithPriority_Empty) {
   WorkQueue* chosen_work_queue = nullptr;
+  bool chose_delayed_over_immediate = false;
   EXPECT_FALSE(selector_.ChooseOldestWithPriority(TaskQueue::NORMAL_PRIORITY,
+                                                  &chose_delayed_over_immediate,
                                                   &chosen_work_queue));
+  EXPECT_FALSE(chose_delayed_over_immediate);
 }
 
 TEST_F(TaskQueueSelectorTest, ChooseOldestWithPriority_OnlyDelayed) {
   task_queues_[0]->delayed_work_queue()->PushTaskForTest(TaskQueueImpl::Task(
       FROM_HERE, test_closure_, base::TimeTicks(), 0, true, 0));
   selector_.delayed_task_queue_sets()->OnPushQueue(
       task_queues_[0]->delayed_work_queue());
 
   WorkQueue* chosen_work_queue = nullptr;
+  bool chose_delayed_over_immediate = false;
   EXPECT_TRUE(selector_.ChooseOldestWithPriority(TaskQueue::NORMAL_PRIORITY,
+                                                 &chose_delayed_over_immediate,
                                                  &chosen_work_queue));
   EXPECT_EQ(chosen_work_queue, task_queues_[0]->delayed_work_queue());
+  EXPECT_FALSE(chose_delayed_over_immediate);
 }
 
 TEST_F(TaskQueueSelectorTest, ChooseOldestWithPriority_OnlyImmediate) {
   task_queues_[0]->immediate_work_queue()->PushTaskForTest(TaskQueueImpl::Task(
       FROM_HERE, test_closure_, base::TimeTicks(), 0, true, 0));
   selector_.immediate_task_queue_sets()->OnPushQueue(
       task_queues_[0]->immediate_work_queue());
 
   WorkQueue* chosen_work_queue = nullptr;
+  bool chose_delayed_over_immediate;
   EXPECT_TRUE(selector_.ChooseOldestWithPriority(TaskQueue::NORMAL_PRIORITY,
+                                                 &chose_delayed_over_immediate,
                                                  &chosen_work_queue));
   EXPECT_EQ(chosen_work_queue, task_queues_[0]->immediate_work_queue());
+  EXPECT_FALSE(chose_delayed_over_immediate);
 }
 
 struct ChooseOldestWithPriorityTestParam {
   int delayed_task_enqueue_order;
   int immediate_task_enqueue_order;
-  bool force_select_immediate;
+  int immediate_starvation_count;
   const char* expected_work_queue_name;
+  bool expected_did_starve_immediate_queue;
 };
 
 static const ChooseOldestWithPriorityTestParam
     kChooseOldestWithPriorityTestCases[] = {
-        {1, 2, false, "delayed"},
-        {1, 2, true, "immediate"},
-        {2, 1, false, "immediate"},
-        {2, 1, true, "immediate"},
+        {1, 2, 0, "delayed", true},
+        {1, 2, 1, "delayed", true},
+        {1, 2, 2, "delayed", true},
+        {1, 2, 3, "delayed", true},
+        {1, 2, 4, "immediate", false},
+        {2, 1, 4, "immediate", false},
+        {2, 1, 4, "immediate", false},
 };
 
 class ChooseOldestWithPriorityTest
     : public TaskQueueSelectorTest,
       public testing::WithParamInterface<ChooseOldestWithPriorityTestParam> {};
 
 TEST_P(ChooseOldestWithPriorityTest, RoundRobinTest) {
   task_queues_[0]->immediate_work_queue()->PushTaskForTest(
       TaskQueueImpl::Task(FROM_HERE, test_closure_, base::TimeTicks(),
                           GetParam().immediate_task_enqueue_order, true,
                           GetParam().immediate_task_enqueue_order));
   selector_.immediate_task_queue_sets()->OnPushQueue(
       task_queues_[0]->immediate_work_queue());
 
   task_queues_[0]->delayed_work_queue()->PushTaskForTest(
       TaskQueueImpl::Task(FROM_HERE, test_closure_, base::TimeTicks(),
                           GetParam().delayed_task_enqueue_order, true,
                           GetParam().delayed_task_enqueue_order));
   selector_.delayed_task_queue_sets()->OnPushQueue(
       task_queues_[0]->delayed_work_queue());
 
-  selector_.SetForceSelectImmediateForTest(GetParam().force_select_immediate);
+  selector_.SetImmediateStarvationCountForTest(
+      GetParam().immediate_starvation_count);
 
   WorkQueue* chosen_work_queue = nullptr;
+  bool chose_delayed_over_immediate;
   EXPECT_TRUE(selector_.ChooseOldestWithPriority(TaskQueue::NORMAL_PRIORITY,
+                                                 &chose_delayed_over_immediate,
                                                  &chosen_work_queue));
   EXPECT_EQ(chosen_work_queue->task_queue(), task_queues_[0].get());
   EXPECT_STREQ(chosen_work_queue->name(), GetParam().expected_work_queue_name);
+  EXPECT_EQ(chose_delayed_over_immediate,
+            GetParam().expected_did_starve_immediate_queue);
 }
 
 INSTANTIATE_TEST_CASE_P(ChooseOldestWithPriorityTest,
                         ChooseOldestWithPriorityTest,
                         testing::ValuesIn(kChooseOldestWithPriorityTestCases));
 
 }  // namespace internal
 }  // namespace scheduler