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 1186 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::THROTTLED) {
+      task_queue->SetTimeDomain(real_time_domain());
       task_queue_throttler_->DecreaseThrottleRefCount(task_queue);
     } else if (new_task_queue_policy.time_domain_type ==
                TimeDomainType::THROTTLED) {
+      task_queue->SetTimeDomain(real_time_domain());
       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());
+    } else {
+      task_queue->SetTimeDomain(real_time_domain());
     }
   }
 }
 
 RendererSchedulerImpl::UseCase RendererSchedulerImpl::ComputeCurrentUseCase(
     base::TimeTicks now,
     base::TimeDelta* expected_use_case_duration) const {
   any_thread_lock_.AssertAcquired();
   // Special case for flings. This is needed because we don't get notification
   // of a fling ending (although we do for cancellation).
@@ skipping 590 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