Change VirtualTimePolicy::PAUSE_IF_NETWORK_FETCHES_PENDING

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/auto_advancing_virtual_time_domain.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, tracing_category)),
+      virtual_time_(false),
       weak_factory_(this) {
-  suspend_timers_when_backgrounded_closure_.Reset(base::Bind(
+  pump_throttled_tasks_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());
 }
 
 ThrottlingHelper::~ThrottlingHelper() {
   // It's possible for queues to be still throttled, so we need to tidy up
@@ skipping 20 matching lines @@
   // We don't enable the queue here because it's throttled and there might be
   // tasks in it's work queue that would execute immediatly rather than after
   // PumpThrottledTasks runs.
   if (!enabled)
     task_queue->SetQueueEnabled(false);
 }
 
 void ThrottlingHelper::IncreaseThrottleRefCount(TaskQueue* task_queue) {
   DCHECK_NE(task_queue, task_runner_.get());
 
+  if (virtual_time_)
+    return;
+
   std::pair<TaskQueueMap::iterator, bool> insert_result =
       throttled_queues_.insert(std::make_pair(
           task_queue, Metadata(1, task_queue->IsQueueEnabled())));
 
   if (insert_result.second) {
     // The insert was succesful so we need to throttle the queue.
     task_queue->SetTimeDomain(time_domain_.get());
     task_queue->SetPumpPolicy(TaskQueue::PumpPolicy::MANUAL);
     task_queue->SetQueueEnabled(false);
 
     if (!task_queue->IsEmpty()) {
       if (task_queue->HasPendingImmediateWork()) {
         OnTimeDomainHasImmediateWork();
       } else {
         OnTimeDomainHasDelayedWork();
       }
     }
   } else {
     // An entry already existed in the map so we need to increment the refcount.
     insert_result.first->second.throttling_ref_count++;
   }
 }
 
 void ThrottlingHelper::DecreaseThrottleRefCount(TaskQueue* task_queue) {
+  if (virtual_time_)
+    return;
+
   TaskQueueMap::iterator iter = throttled_queues_.find(task_queue);
 
   if (iter != throttled_queues_.end() &&
       --iter->second.throttling_ref_count == 0) {
     bool enabled = iter->second.enabled;
     // The refcount has become zero, we need to unthrottle the queue.
     throttled_queues_.erase(iter);
 
     task_queue->SetTimeDomain(renderer_scheduler_->real_time_domain());
     task_queue->SetPumpPolicy(TaskQueue::PumpPolicy::AUTO);
@@ skipping 60 matching lines @@
     base::TimeTicks unthrottled_runtime) {
   const base::TimeDelta one_second = base::TimeDelta::FromSeconds(1);
   return unthrottled_runtime + one_second -
       ((unthrottled_runtime - base::TimeTicks()) % one_second);
 }
 
 void ThrottlingHelper::MaybeSchedulePumpThrottledTasksLocked(
     const tracked_objects::Location& from_here,
     base::TimeTicks now,
     base::TimeTicks unthrottled_runtime) {
+  if (virtual_time_)
+    return;
+
   base::TimeTicks throttled_runtime =
       ThrottledRunTime(std::max(now, unthrottled_runtime));
   // If there is a pending call to PumpThrottledTasks and it's sooner than
   // |unthrottled_runtime| then return.
   if (!pending_pump_throttled_tasks_runtime_.is_null() &&
       throttled_runtime >= pending_pump_throttled_tasks_runtime_) {
     return;
   }
 
   pending_pump_throttled_tasks_runtime_ = throttled_runtime;
 
-  suspend_timers_when_backgrounded_closure_.Cancel();
+  pump_throttled_tasks_closure_.Cancel();
 
   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);
+      from_here, pump_throttled_tasks_closure_.callback(), delay);
+}
+
+void ThrottlingHelper::EnableVirtualTime() {
+  virtual_time_ = true;
+
+  pump_throttled_tasks_closure_.Cancel();
+
+  while (!throttled_queues_.empty()) {
+    TaskQueue* task_queue = throttled_queues_.begin()->first;
+    bool enabled = throttled_queues_.begin()->second.enabled;
+
+    throttled_queues_.erase(throttled_queues_.begin());
+
+    task_queue->SetTimeDomain(renderer_scheduler_->GetVirtualTimeDomain());
+    task_queue->SetPumpPolicy(TaskQueue::PumpPolicy::AUTO);
+    task_queue->SetQueueEnabled(enabled);
+  }
 }
 
 }  // namespace scheduler