[scheduler]: Fix a bug with non-nestable tasks.

components/scheduler/child/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 "components/scheduler/child/task_queue_manager.h"
 
 #include "base/location.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/simple_test_tick_clock.h"
@@ skipping 163 matching lines @@
   runners_[0]->PostTask(
       FROM_HERE,
       base::Bind(&PostFromNestedRunloop, message_loop_.get(), runners_[0],
                  base::Unretained(&tasks_to_post_from_nested_loop)));
 
   message_loop_->RunUntilIdle();
   // Note we expect task 3 to run last because it's non-nestable.
   EXPECT_THAT(run_order, ElementsAre(1, 2, 4, 5, 3));
 }
 
+void RepostOnceTestTask(scoped_refptr<base::SingleThreadTaskRunner> runner,
+                       int value, std::vector<int>* out_result) {
+  out_result->push_back(value);
+  runner->PostTask(FROM_HERE, base::Bind(&NullTask));
+}
+
+void PostFromNestedRunloopWithAfterWakeupQueue(
+    base::MessageLoop* message_loop,
+    base::SingleThreadTaskRunner* after_wakeup_runner,
+    base::SingleThreadTaskRunner* wakeup_runner,
+    std::vector<std::pair<base::Closure, bool>>* tasks) {
+  base::MessageLoop::ScopedNestableTaskAllower allow(message_loop);
+  for (std::pair<base::Closure, bool>& pair : *tasks) {
+    if (pair.second) {
+      after_wakeup_runner->PostTask(FROM_HERE, pair.first);
+    } else {
+      after_wakeup_runner->PostNonNestableTask(FROM_HERE, pair.first);
+    }
+  }
+  // Post a task to wake up the after wakeup queue.
+  wakeup_runner->PostTask(FROM_HERE, base::Bind(&NullTask));
+  message_loop->RunUntilIdle();
+}
+
+TEST_F(TaskQueueManagerTest, NonNestableTaskUsesPreviousTaskForUpdateQueues) {
+  InitializeWithRealMessageLoop(2u);
+  runners_[0]->SetPumpPolicy(TaskQueue::PumpPolicy::AFTER_WAKEUP);
+
+  std::vector<int> run_order;
+  std::vector<std::pair<base::Closure, bool>> tasks_to_post_from_nested_loop;
+  // This task posts a task, so that there is something in the incoming queue
+  // of the after wakeup task queue when the non-nestable task runs.
+  tasks_to_post_from_nested_loop.push_back(std::make_pair(
+      base::Bind(&RepostOnceTestTask, runners_[0], 1, &run_order), true));
+  tasks_to_post_from_nested_loop.push_back(
+      std::make_pair(base::Bind(&TestTask, 2, &run_order), false));
+
+  runners_[1]->PostTask(
+      FROM_HERE,
+      base::Bind(&PostFromNestedRunloopWithAfterWakeupQueue,
+                 message_loop_.get(), runners_[0], runners_[1],
+                 base::Unretained(&tasks_to_post_from_nested_loop)));
+
+  message_loop_->RunUntilIdle();
+  EXPECT_THAT(run_order, ElementsAre(1, 2));
+}
+
 TEST_F(TaskQueueManagerTest, QueuePolling) {
   Initialize(1u);
 
   std::vector<int> run_order;
   EXPECT_TRUE(runners_[0]->IsQueueEmpty());
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   EXPECT_FALSE(runners_[0]->IsQueueEmpty());
 
   test_task_runner_->RunUntilIdle();
   EXPECT_TRUE(runners_[0]->IsQueueEmpty());
@@ skipping 920 matching lines @@
 
   // The sequence numbers are a zero-based monotonically incrememting counter
   // which should be set when the task is posted rather than when it's enqueued
   // onto the incomming queue.
   EXPECT_THAT(observer.sequence_numbers(), ElementsAre(3, 2, 1, 0));
 
   manager_->RemoveTaskObserver(&observer);
 }
 
 }  // namespace scheduler