Fix a bug that could occasionaly cause setInterval to stop

components/scheduler/base/task_queue_impl.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_impl.h"
 
 #include "base/trace_event/blame_context.h"
 #include "components/scheduler/base/task_queue_manager.h"
 #include "components/scheduler/base/task_queue_manager_delegate.h"
 #include "components/scheduler/base/time_domain.h"
@@ skipping 171 matching lines @@
   DCHECK_GT(delay, base::TimeDelta());
   if (base::PlatformThread::CurrentId() == thread_id_) {
     // Lock-free fast path for delayed tasks posted from the main thread.
     if (!main_thread_only().task_queue_manager)
       return false;
 
     EnqueueOrder sequence_number =
         main_thread_only().task_queue_manager->GetNextSequenceNumber();
 
     base::TimeTicks time_domain_now = main_thread_only().time_domain->Now();
-    base::TimeTicks time_domain_delayed_run_time =
-        main_thread_only().time_domain->ComputeDelayedRunTime(time_domain_now,
-                                                              delay);
+    base::TimeTicks time_domain_delayed_run_time = time_domain_now + delay;
     PushOntoDelayedIncomingQueueFromMainThread(
         Task(from_here, task, time_domain_delayed_run_time, sequence_number,
              task_type != TaskType::NON_NESTABLE),
         time_domain_now);
   } else {
     // NOTE posting a delayed task from a different thread is not expected to
     // be common. This pathway is less optimal than perhaps it could be
     // because it causes two main thread tasks to be run.  Should this
     // assumption prove to be false in future, we may need to revisit this.
     base::AutoLock lock(any_thread_lock_);
     if (!any_thread().task_queue_manager)
       return false;
 
     EnqueueOrder sequence_number =
         any_thread().task_queue_manager->GetNextSequenceNumber();
 
     base::TimeTicks time_domain_now = any_thread().time_domain->Now();
-    base::TimeTicks time_domain_delayed_run_time =
-        any_thread().time_domain->ComputeDelayedRunTime(time_domain_now, delay);
+    base::TimeTicks time_domain_delayed_run_time = time_domain_now + delay;
     PushOntoDelayedIncomingQueueLocked(
         Task(from_here, task, time_domain_delayed_run_time, sequence_number,
              task_type != TaskType::NON_NESTABLE));
   }
   return true;
 }
 
 void TaskQueueImpl::PushOntoDelayedIncomingQueueFromMainThread(
     Task pending_task,
     base::TimeTicks now) {
@@ skipping 219 matching lines @@
                      main_thread_only().delayed_work_queue->Size() +
                      main_thread_only().delayed_incoming_queue.size());
   if (!is_locked)
     any_thread_lock_.Release();
 }
 
 void TaskQueueImpl::SetPumpPolicy(PumpPolicy pump_policy) {
   base::AutoLock lock(any_thread_lock_);
   if (pump_policy == PumpPolicy::AUTO &&
       any_thread().pump_policy != PumpPolicy::AUTO) {
-    PumpQueueLocked(true);
+    LazyNow lazy_now(main_thread_only().time_domain->CreateLazyNow());

[rmcilroy, 2016/07/18 15:22:57]

Just out of interest, wondering why this LazyNow creation was pulled out of
PumpQueueLocked?

[alex clarke (OOO till 29th), 2016/07/18 15:35:52]

There could be many throttled task queues, and
ThrottlingHelper::PumpThrottledTasks pumps each in turn.  Without this change,
each queue would run delayed tasks up to a different point which is undesirable
- in degenerate cases the throttling possibly wouldn't throttle at all.

[rmcilroy, 2016/07/18 16:01:42]

I see, makes sense, thanks.

+    PumpQueueLocked(&lazy_now, true);
   }
   any_thread().pump_policy = pump_policy;
   main_thread_only().pump_policy = pump_policy;
 }
 
 TaskQueue::PumpPolicy TaskQueueImpl::GetPumpPolicy() const {
   return main_thread_only().pump_policy;
 }
 
-void TaskQueueImpl::PumpQueueLocked(bool may_post_dowork) {
+void TaskQueueImpl::PumpQueueLocked(LazyNow* lazy_now, bool may_post_dowork) {
   TRACE_EVENT1(disabled_by_default_tracing_category_,
                "TaskQueueImpl::PumpQueueLocked", "queue", name_);
   TaskQueueManager* task_queue_manager = any_thread().task_queue_manager;
   if (!task_queue_manager)
     return;
 
-  LazyNow lazy_now(main_thread_only().time_domain->CreateLazyNow());
-  MoveReadyDelayedTasksToDelayedWorkQueue(&lazy_now);
+  MoveReadyDelayedTasksToDelayedWorkQueue(lazy_now);
 
   while (!any_thread().immediate_incoming_queue.empty()) {
     main_thread_only().immediate_work_queue->Push(
         std::move(any_thread().immediate_incoming_queue.front()));
     any_thread().immediate_incoming_queue.pop();
   }
 
   // |immediate_incoming_queue| is now empty so TimeDomain::UpdateQueues no
   // longer needs to consider this queue for reloading.
   main_thread_only().time_domain->UnregisterAsUpdatableTaskQueue(this);
 
   if (main_thread_only().immediate_work_queue->Empty() &&
       main_thread_only().delayed_work_queue->Empty()) {
     return;
   }
 
   if (may_post_dowork)
     task_queue_manager->MaybeScheduleImmediateWork(FROM_HERE);
 }
 
-void TaskQueueImpl::PumpQueue(bool may_post_dowork) {
+void TaskQueueImpl::PumpQueue(LazyNow* lazy_now, bool may_post_dowork) {
   base::AutoLock lock(any_thread_lock_);
-  PumpQueueLocked(may_post_dowork);
+  PumpQueueLocked(lazy_now, may_post_dowork);
 }
 
 const char* TaskQueueImpl::GetName() const {
   return name_;
 }
 
 void TaskQueueImpl::SetQueuePriority(QueuePriority priority) {
   if (!main_thread_only().task_queue_manager || priority == GetQueuePriority())
     return;
   main_thread_only().task_queue_manager->selector_.SetQueuePriority(this,
@@ skipping 206 matching lines @@
   state->SetBoolean("nestable", task.nestable);
   state->SetBoolean("is_high_res", task.is_high_res);
   state->SetDouble(
       "delayed_run_time",
       (task.delayed_run_time - base::TimeTicks()).InMicroseconds() / 1000.0L);
   state->EndDictionary();
 }
 
 }  // namespace internal
 }  // namespace scheduler