scheduler: Suspend timers while virtual time is paused

third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.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 "platform/scheduler/renderer/renderer_scheduler_impl.h"
 
 #include "base/bind.h"
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 1185 matching lines @@
   }
 
   // Make sure if there's no voter that the task queue is enabled.
   DCHECK(task_queue_enabled_voter || old_task_queue_policy.is_enabled);
 
   if (old_task_queue_policy.priority != new_task_queue_policy.priority)
     task_queue->SetQueuePriority(new_task_queue_policy.priority);
 
   if (old_task_queue_policy.time_domain_type !=
       new_task_queue_policy.time_domain_type) {
+    if (old_task_queue_policy.time_domain_type == TimeDomainType::VIRTUAL)
+      task_queue->SetTimeDomain(real_time_domain());

[alex clarke (OOO till 29th), 2017/03/09 11:11:33]

Setting this redundantly is cheap.  Maybe just move this into the two non
virtual if clauses below for clarity?

[Sami, 2017/03/09 11:25:33]

Done. (FWIW setting this takes a lock, but I think this transition happens
rarely enough that it doesn't matter.)

+
     if (old_task_queue_policy.time_domain_type == TimeDomainType::THROTTLED) {
       task_queue_throttler_->DecreaseThrottleRefCount(task_queue);
     } else if (new_task_queue_policy.time_domain_type ==
                TimeDomainType::THROTTLED) {
       task_queue_throttler_->IncreaseThrottleRefCount(task_queue);
     } else if (new_task_queue_policy.time_domain_type ==
                TimeDomainType::VIRTUAL) {
       DCHECK(virtual_time_domain_);
       task_queue->SetTimeDomain(virtual_time_domain_.get());
     }
@@ skipping 599 matching lines @@
   MainThreadOnly().use_virtual_time = true;
 
   // The |unthrottled_task_runners_| are not actively managed by UpdatePolicy().
   AutoAdvancingVirtualTimeDomain* time_domain = GetVirtualTimeDomain();
   for (const scoped_refptr<TaskQueue>& task_queue : unthrottled_task_runners_)
     task_queue->SetTimeDomain(time_domain);
 
   ForceUpdatePolicy();
 }
 
+void RendererSchedulerImpl::DisableVirtualTimeForTesting() {
+  MainThreadOnly().use_virtual_time = false;
+
+  RealTimeDomain* time_domain = real_time_domain();
+  // The |unthrottled_task_runners_| are not actively managed by UpdatePolicy().
+  for (const scoped_refptr<TaskQueue>& task_queue : unthrottled_task_runners_)
+    task_queue->SetTimeDomain(time_domain);
+
+  ForceUpdatePolicy();
+}
+
 bool RendererSchedulerImpl::ShouldDisableThrottlingBecauseOfAudio(
     base::TimeTicks now) {
   if (!MainThreadOnly().last_audio_state_change)
     return false;
 
   if (MainThreadOnly().is_audio_playing)
     return true;
 
   return MainThreadOnly().last_audio_state_change.value() +
              kThrottlingDelayAfterAudioIsPlayed >
@@ skipping 65 matching lines @@
     case TimeDomainType::VIRTUAL:
       return "virtual";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink