scheduler: Make virtual time expiration deterministic

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 291 matching lines @@
 scoped_refptr<TaskQueue> RendererSchedulerImpl::TimerTaskQueue() {
   helper_.CheckOnValidThread();
   return default_timer_task_queue_;
 }
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::ControlTaskQueue() {
   helper_.CheckOnValidThread();
   return helper_.ControlTaskQueue();
 }
 
+scoped_refptr<TaskQueue> RendererSchedulerImpl::VirtualTimeControlTaskQueue() {
+  helper_.CheckOnValidThread();
+  return virtual_time_control_task_queue_;
+}
+
 scoped_refptr<TaskQueue> RendererSchedulerImpl::NewLoadingTaskQueue(
     TaskQueue::QueueType queue_type) {
   helper_.CheckOnValidThread();
   scoped_refptr<TaskQueue> loading_task_queue(helper_.NewTaskQueue(
       TaskQueue::Spec(queue_type)
           .SetShouldMonitorQuiescence(true)
           .SetTimeDomain(GetMainThreadOnly().use_virtual_time
                              ? GetVirtualTimeDomain()
                              : nullptr)));
   auto insert_result = loading_task_runners_.insert(std::make_pair(
@@ skipping 1522 matching lines @@
 }
 
 void RendererSchedulerImpl::EnableVirtualTime() {
   GetMainThreadOnly().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);
 
+  DCHECK(!virtual_time_control_task_queue_);
+  virtual_time_control_task_queue_ =
+      helper_.NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::CONTROL));
+  virtual_time_control_task_queue_->SetQueuePriority(
+      TaskQueue::CONTROL_PRIORITY);
+  virtual_time_control_task_queue_->SetTimeDomain(time_domain);
+
   ForceUpdatePolicy();
 }
 
 void RendererSchedulerImpl::DisableVirtualTimeForTesting() {
   GetMainThreadOnly().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);
+  virtual_time_control_task_queue_->UnregisterTaskQueue();
+  virtual_time_control_task_queue_ = nullptr;
 
   ForceUpdatePolicy();
 }
 
 bool RendererSchedulerImpl::ShouldDisableThrottlingBecauseOfAudio(
     base::TimeTicks now) {
   if (!GetMainThreadOnly().last_audio_state_change)
     return false;
 
   if (GetMainThreadOnly().is_audio_playing)
@@ skipping 69 matching lines @@
     case TimeDomainType::VIRTUAL:
       return "virtual";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink