(Merge) Fix a bug that could occasionaly cause setInterval to stop

components/scheduler/base/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/base/task_queue_manager.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 373 matching lines @@
   std::vector<EnqueueOrder> run_order;
   // Posting a task when pumping is disabled doesn't result in work getting
   // posted.
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   EXPECT_FALSE(test_task_runner_->HasPendingTasks());
 
   // However polling still works.
   EXPECT_TRUE(runners_[0]->HasPendingImmediateWork());
 
   // After pumping the task runs normally.
-  runners_[0]->PumpQueue(true);
+  LazyNow lazy_now(now_src_.get());
+  runners_[0]->PumpQueue(&lazy_now, true);
   EXPECT_TRUE(test_task_runner_->HasPendingTasks());
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1));
 }
 
 TEST_F(TaskQueueManagerTest, ManualPumpingToggle) {
   Initialize(1u);
   runners_[0]->SetPumpPolicy(TaskQueue::PumpPolicy::MANUAL);
 
   std::vector<EnqueueOrder> run_order;
@@ skipping 61 matching lines @@
   runners_[0]->SetPumpPolicy(TaskQueue::PumpPolicy::MANUAL);
 
   std::vector<EnqueueOrder> run_order;
   // Posting a delayed task when pumping will apply the delay, but won't cause
   // work to executed afterwards.
   base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
                                delay);
 
   // After pumping but before the delay period has expired, task does not run.
-  runners_[0]->PumpQueue(true);
+  LazyNow lazy_now1(now_src_.get());
+  runners_[0]->PumpQueue(&lazy_now1, true);
   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(5));
   EXPECT_TRUE(run_order.empty());
 
   // Once the delay has expired, pumping causes the task to run.
   now_src_->Advance(base::TimeDelta::FromMilliseconds(5));
-  runners_[0]->PumpQueue(true);
+  LazyNow lazy_now2(now_src_.get());
+  runners_[0]->PumpQueue(&lazy_now2, true);
   EXPECT_TRUE(test_task_runner_->HasPendingTasks());
   test_task_runner_->RunPendingTasks();
   EXPECT_THAT(run_order, ElementsAre(1));
 }
 
 TEST_F(TaskQueueManagerTest, ManualPumpingWithMultipleDelayedTasks) {
   Initialize(1u);
   runners_[0]->SetPumpPolicy(TaskQueue::PumpPolicy::MANUAL);
 
   std::vector<EnqueueOrder> run_order;
   // Posting a delayed task when pumping will apply the delay, but won't cause
   // work to executed afterwards.
   base::TimeDelta delay1(base::TimeDelta::FromMilliseconds(1));
   base::TimeDelta delay2(base::TimeDelta::FromMilliseconds(10));
   base::TimeDelta delay3(base::TimeDelta::FromMilliseconds(20));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
                                delay1);
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order),
                                delay2);
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 3, &run_order),
                                delay3);
 
   now_src_->Advance(base::TimeDelta::FromMilliseconds(15));
   test_task_runner_->RunUntilIdle();
   EXPECT_TRUE(run_order.empty());
 
   // Once the delay has expired, pumping causes the task to run.
-  runners_[0]->PumpQueue(true);
+  LazyNow lazy_now(now_src_.get());
+  runners_[0]->PumpQueue(&lazy_now, true);
   test_task_runner_->RunUntilIdle();
   EXPECT_THAT(run_order, ElementsAre(1, 2));
 }
 
 TEST_F(TaskQueueManagerTest, DelayedTasksDontAutoRunWithManualPumping) {
   Initialize(1u);
   runners_[0]->SetPumpPolicy(TaskQueue::PumpPolicy::MANUAL);
 
   std::vector<EnqueueOrder> run_order;
   base::TimeDelta delay(base::TimeDelta::FromMilliseconds(10));
   runners_[0]->PostDelayedTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order),
                                delay);
 
   test_task_runner_->RunForPeriod(base::TimeDelta::FromMilliseconds(10));
   EXPECT_TRUE(run_order.empty());
 }
 
 TEST_F(TaskQueueManagerTest, ManualPumpingWithNonEmptyWorkQueue) {
   Initialize(1u);
   runners_[0]->SetPumpPolicy(TaskQueue::PumpPolicy::MANUAL);
 
   std::vector<EnqueueOrder> run_order;
   // Posting two tasks and pumping twice should result in two tasks in the work
   // queue.
+  LazyNow lazy_now(now_src_.get());
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
-  runners_[0]->PumpQueue(true);
+  runners_[0]->PumpQueue(&lazy_now, true);
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
-  runners_[0]->PumpQueue(true);
+  runners_[0]->PumpQueue(&lazy_now, true);
 
   EXPECT_EQ(2u, runners_[0]->immediate_work_queue()->Size());
 }
 
 void ReentrantTestTask(scoped_refptr<base::SingleThreadTaskRunner> runner,
                        int countdown,
                        std::vector<EnqueueOrder>* out_result) {
   out_result->push_back(countdown);
   if (--countdown) {
     runner->PostTask(FROM_HERE,
@@ skipping 146 matching lines @@
   std::vector<EnqueueOrder> run_order;
   runners_[0]->PostTask(FROM_HERE, base::Bind(&TestTask, 1, &run_order));
   test_task_runner_->RunUntilIdle();
   EXPECT_TRUE(run_order.empty());  // Shouldn't run - no other task to wake TQM.
 
   runners_[1]->PostTask(FROM_HERE, base::Bind(&TestTask, 2, &run_order));
   test_task_runner_->RunUntilIdle();
   // This still shouldn't wake TQM as manual queue was not pumped.
   EXPECT_TRUE(run_order.empty());
 
-  runners_[1]->PumpQueue(true);
+  LazyNow lazy_now(now_src_.get());
+  runners_[1]->PumpQueue(&lazy_now, true);
   test_task_runner_->RunUntilIdle();
   // Executing a task on an auto pumped queue should wake the TQM.
   EXPECT_THAT(run_order, ElementsAre(2, 1));
 }
 
 void TestPostingTask(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
                      base::Closure task) {
   task_runner->PostTask(FROM_HERE, task);
 }
 
@@ skipping 312 matching lines @@
 
   queue0->PostTask(FROM_HERE, base::Bind(NullTask));
   queue1->PostTask(FROM_HERE, base::Bind(NullTask));
   EXPECT_TRUE(queue0->HasPendingImmediateWork());
   EXPECT_TRUE(queue1->HasPendingImmediateWork());
 
   test_task_runner_->RunUntilIdle();
   EXPECT_FALSE(queue0->HasPendingImmediateWork());
   EXPECT_TRUE(queue1->HasPendingImmediateWork());
 
-  queue1->PumpQueue(true);
+  LazyNow lazy_now(now_src_.get());
+  queue1->PumpQueue(&lazy_now, true);
   EXPECT_FALSE(queue0->HasPendingImmediateWork());
   EXPECT_TRUE(queue1->HasPendingImmediateWork());
 
   test_task_runner_->RunUntilIdle();
   EXPECT_FALSE(queue0->HasPendingImmediateWork());
   EXPECT_FALSE(queue1->HasPendingImmediateWork());
 }
 
 TEST_F(TaskQueueManagerTest, HasPendingImmediateWorkAndNeedsPumping) {
   Initialize(2u);
@@ skipping 22 matching lines @@
   EXPECT_TRUE(queue1->HasPendingImmediateWork());
   EXPECT_TRUE(queue1->NeedsPumping());
 
   test_task_runner_->ClearRunTaskLimit();
   test_task_runner_->RunUntilIdle();
   EXPECT_FALSE(queue0->HasPendingImmediateWork());
   EXPECT_FALSE(queue0->NeedsPumping());
   EXPECT_TRUE(queue1->HasPendingImmediateWork());
   EXPECT_TRUE(queue1->NeedsPumping());
 
-  queue1->PumpQueue(true);
+  LazyNow lazy_now(now_src_.get());
+  queue1->PumpQueue(&lazy_now, true);
   EXPECT_FALSE(queue0->HasPendingImmediateWork());
   EXPECT_FALSE(queue0->NeedsPumping());
   EXPECT_TRUE(queue1->HasPendingImmediateWork());
   EXPECT_FALSE(queue1->NeedsPumping());
 
   test_task_runner_->RunUntilIdle();
   EXPECT_FALSE(queue0->HasPendingImmediateWork());
   EXPECT_FALSE(queue0->NeedsPumping());
   EXPECT_FALSE(queue1->HasPendingImmediateWork());
   EXPECT_FALSE(queue1->NeedsPumping());
@@ skipping 820 matching lines @@
 
   trace_analyzer::TraceEventVector events;
   Query q = Query::EventPhaseIs(TRACE_EVENT_PHASE_ENTER_CONTEXT) ||
             Query::EventPhaseIs(TRACE_EVENT_PHASE_LEAVE_CONTEXT);
   analyzer->FindEvents(q, &events);
 
   EXPECT_EQ(2u, events.size());
 }
 
 }  // namespace scheduler