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

components/scheduler/renderer/throttling_helper.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/renderer/throttling_helper.h"
 
 #include "base/logging.h"
 #include "components/scheduler/base/real_time_domain.h"
 #include "components/scheduler/child/scheduler_tqm_delegate.h"
 #include "components/scheduler/renderer/renderer_scheduler_impl.h"
 #include "components/scheduler/renderer/throttled_time_domain.h"
 #include "components/scheduler/renderer/web_frame_scheduler_impl.h"
 #include "third_party/WebKit/public/platform/WebFrameScheduler.h"
 
 namespace scheduler {
 
 ThrottlingHelper::ThrottlingHelper(RendererSchedulerImpl* renderer_scheduler,
                                    const char* tracing_category)
     : task_runner_(renderer_scheduler->ControlTaskRunner()),
       renderer_scheduler_(renderer_scheduler),
       tick_clock_(renderer_scheduler->tick_clock()),
       tracing_category_(tracing_category),
-      time_domain_(new ThrottledTimeDomain(this, tick_clock_)),
+      time_domain_(new ThrottledTimeDomain(this, tracing_category)),
       weak_factory_(this) {
   suspend_timers_when_backgrounded_closure_.Reset(base::Bind(
       &ThrottlingHelper::PumpThrottledTasks, weak_factory_.GetWeakPtr()));
   forward_immediate_work_closure_ =
       base::Bind(&ThrottlingHelper::OnTimeDomainHasImmediateWork,
                  weak_factory_.GetWeakPtr());
 
   renderer_scheduler_->RegisterTimeDomain(time_domain_.get());
 }
 
@@ skipping 92 matching lines @@
   DCHECK(has_delayed_task);
   base::TimeTicks now = tick_clock_->NowTicks();
   MaybeSchedulePumpThrottledTasksLocked(FROM_HERE, now,
                                         next_scheduled_delayed_task);
 }
 
 void ThrottlingHelper::PumpThrottledTasks() {
   TRACE_EVENT0(tracing_category_, "ThrottlingHelper::PumpThrottledTasks");
   pending_pump_throttled_tasks_runtime_ = base::TimeTicks();
 
-  base::TimeTicks now = tick_clock_->NowTicks();
-  time_domain_->AdvanceTo(now);
+  LazyNow lazy_low(tick_clock_);
   for (const TaskQueueMap::value_type& map_entry : throttled_queues_) {
     TaskQueue* task_queue = map_entry.first;
     if (task_queue->IsEmpty())
       continue;
 
     task_queue->SetQueueEnabled(map_entry.second.enabled);
-    task_queue->PumpQueue(false);
+    task_queue->PumpQueue(&lazy_low, false);
   }
   // Make sure NextScheduledRunTime gives us an up-to date result.
   time_domain_->ClearExpiredWakeups();
 
   base::TimeTicks next_scheduled_delayed_task;
   // Maybe schedule a call to ThrottlingHelper::PumpThrottledTasks if there is
   // a pending delayed task. NOTE posting a non-delayed task in the future will
   // result in ThrottlingHelper::OnTimeDomainHasImmediateWork being called.
   if (time_domain_->NextScheduledRunTime(&next_scheduled_delayed_task)) {
-    MaybeSchedulePumpThrottledTasksLocked(FROM_HERE, now,
+    MaybeSchedulePumpThrottledTasksLocked(FROM_HERE, lazy_low.Now(),
                                           next_scheduled_delayed_task);
   }
 }
 
 /* static */
 base::TimeTicks ThrottlingHelper::ThrottledRunTime(
     base::TimeTicks unthrottled_runtime) {
   const base::TimeDelta one_second = base::TimeDelta::FromSeconds(1);
   return unthrottled_runtime + one_second -
       ((unthrottled_runtime - base::TimeTicks()) % one_second);
@@ skipping 18 matching lines @@
 
   base::TimeDelta delay = pending_pump_throttled_tasks_runtime_ - now;
   TRACE_EVENT1(tracing_category_,
                "ThrottlingHelper::MaybeSchedulePumpThrottledTasksLocked",
                "delay_till_next_pump_ms", delay.InMilliseconds());
   task_runner_->PostDelayedTask(
       from_here, suspend_timers_when_backgrounded_closure_.callback(), delay);
 }
 
 }  // namespace scheduler