Change VirtualTimePolicy::PAUSE_IF_NETWORK_FETCHES_PENDING

components/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 "components/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"
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
 #include "cc/output/begin_frame_args.h"
 #include "components/scheduler/base/task_queue_impl.h"
 #include "components/scheduler/base/task_queue_selector.h"
 #include "components/scheduler/base/virtual_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/web_view_scheduler_impl.h"
 #include "components/scheduler/renderer/webthread_impl_for_renderer_scheduler.h"
 
 namespace scheduler {
 namespace {
 // The run time of loading tasks is strongly bimodal.  The vast majority are
 // very cheap, but there are usually a handful of very expensive tasks (e.g ~1
 // second on a mobile device) so we take a very pessimistic view when estimating
 // the cost of loading tasks.
 const int kLoadingTaskEstimationSampleCount = 1000;
@@ skipping 60 matching lines @@
 
   for (const scoped_refptr<TaskQueue>& loading_queue : loading_task_runners_) {
     loading_queue->RemoveTaskObserver(
         &MainThreadOnly().loading_task_cost_estimator);
   }
   for (const scoped_refptr<TaskQueue>& timer_queue : timer_task_runners_) {
     timer_queue->RemoveTaskObserver(
         &MainThreadOnly().timer_task_cost_estimator);
   }
 
+  if (virtual_time_domain_)
+    UnregisterTimeDomain(virtual_time_domain_.get());
+
   // Ensure the renderer scheduler was shut down explicitly, because otherwise
   // we could end up having stale pointers to the Blink heap which has been
   // terminated by this point.
   DCHECK(MainThreadOnly().was_shutdown);
 }
 
 RendererSchedulerImpl::MainThreadOnly::MainThreadOnly(
     RendererSchedulerImpl* renderer_scheduler_impl,
     const scoped_refptr<TaskQueue>& compositor_task_runner,
     base::TickClock* time_source)
@@ skipping 22 matching lines @@
       loading_tasks_seem_expensive(false),
       timer_tasks_seem_expensive(false),
       touchstart_expected_soon(false),
       have_seen_a_begin_main_frame(false),
       have_reported_blocking_intervention_in_current_policy(false),
       have_reported_blocking_intervention_since_navigation(false),
       has_visible_render_widget_with_touch_handler(false),
       begin_frame_not_expected_soon(false),
       expensive_task_blocking_allowed(true),
       in_idle_period_for_testing(false),
+      use_virtual_time(false),
       rail_mode_observer(nullptr) {}
 
 RendererSchedulerImpl::MainThreadOnly::~MainThreadOnly() {}
 
 RendererSchedulerImpl::AnyThread::AnyThread()
     : awaiting_touch_start_response(false),
       in_idle_period(false),
       begin_main_frame_on_critical_path(false),
       last_gesture_was_compositor_driven(false),
       default_gesture_prevented(true),
@@ skipping 43 matching lines @@
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::ControlTaskRunner() {
   helper_.CheckOnValidThread();
   return helper_.ControlTaskRunner();
 }
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::NewLoadingTaskRunner(
     const char* name) {
   helper_.CheckOnValidThread();
   scoped_refptr<TaskQueue> loading_task_queue(helper_.NewTaskQueue(
-      TaskQueue::Spec(name).SetShouldMonitorQuiescence(true)));
+      TaskQueue::Spec(name).SetShouldMonitorQuiescence(true).SetTimeDomain(
+          MainThreadOnly().use_virtual_time ? GetVirtualTimeDomain()
+                                            : nullptr)));
   loading_task_runners_.insert(loading_task_queue);
   loading_task_queue->SetQueueEnabled(
       MainThreadOnly().current_policy.loading_queue_policy.is_enabled);
   loading_task_queue->SetQueuePriority(
       MainThreadOnly().current_policy.loading_queue_policy.priority);
   if (MainThreadOnly().current_policy.loading_queue_policy.time_domain_type ==
       TimeDomainType::THROTTLED) {
     throttling_helper_->IncreaseThrottleRefCount(loading_task_queue.get());
   }
   loading_task_queue->AddTaskObserver(
       &MainThreadOnly().loading_task_cost_estimator);
   return loading_task_queue;
 }
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::NewTimerTaskRunner(
     const char* name) {
   helper_.CheckOnValidThread();
+  // TODO(alexclarke): Consider using ApplyTaskQueuePolicy() for brevity.
   scoped_refptr<TaskQueue> timer_task_queue(
       helper_.NewTaskQueue(TaskQueue::Spec(name)
                                .SetShouldMonitorQuiescence(true)
-                               .SetShouldReportWhenExecutionBlocked(true)));
+                               .SetShouldReportWhenExecutionBlocked(true)
+                               .SetTimeDomain(MainThreadOnly().use_virtual_time
+                                                  ? GetVirtualTimeDomain()
+                                                  : nullptr)));
   timer_task_runners_.insert(timer_task_queue);
   timer_task_queue->SetQueueEnabled(
       MainThreadOnly().current_policy.timer_queue_policy.is_enabled);
   timer_task_queue->SetQueuePriority(
       MainThreadOnly().current_policy.timer_queue_policy.priority);
   if (MainThreadOnly().current_policy.timer_queue_policy.time_domain_type ==
       TimeDomainType::THROTTLED) {
     throttling_helper_->IncreaseThrottleRefCount(timer_task_queue.get());
   }
   timer_task_queue->AddTaskObserver(
       &MainThreadOnly().timer_task_cost_estimator);
   return timer_task_queue;
 }
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::NewUnthrottledTaskRunner(
     const char* name) {
   helper_.CheckOnValidThread();
   scoped_refptr<TaskQueue> unthrottled_task_queue(helper_.NewTaskQueue(
-      TaskQueue::Spec(name).SetShouldMonitorQuiescence(true)));
+      TaskQueue::Spec(name).SetShouldMonitorQuiescence(true).SetTimeDomain(
+          MainThreadOnly().use_virtual_time ? GetVirtualTimeDomain()
+                                            : nullptr)));
+  unthrottled_task_runners_.insert(unthrottled_task_queue);
   return unthrottled_task_queue;
 }
 
 std::unique_ptr<RenderWidgetSchedulingState>
 RendererSchedulerImpl::NewRenderWidgetSchedulingState() {
   return render_widget_scheduler_signals_.NewRenderWidgetSchedulingState();
 }
 
 void RendererSchedulerImpl::OnUnregisterTaskQueue(
     const scoped_refptr<TaskQueue>& task_queue) {
   if (throttling_helper_.get())
     throttling_helper_->UnregisterTaskQueue(task_queue.get());
 
   if (loading_task_runners_.find(task_queue) != loading_task_runners_.end()) {
     task_queue->RemoveTaskObserver(
         &MainThreadOnly().loading_task_cost_estimator);
     loading_task_runners_.erase(task_queue);
   } else if (timer_task_runners_.find(task_queue) !=
              timer_task_runners_.end()) {
     task_queue->RemoveTaskObserver(&MainThreadOnly().timer_task_cost_estimator);
     timer_task_runners_.erase(task_queue);
+  } else if (unthrottled_task_runners_.find(task_queue) !=
+             unthrottled_task_runners_.end()) {
+    unthrottled_task_runners_.erase(task_queue);
   }
 }
 
 bool RendererSchedulerImpl::CanExceedIdleDeadlineIfRequired() const {
   return idle_helper_.CanExceedIdleDeadlineIfRequired();
 }
 
 void RendererSchedulerImpl::AddTaskObserver(
     base::MessageLoop::TaskObserver* task_observer) {
   helper_.AddTaskObserver(task_observer);
@@ skipping 579 matching lines @@
       if (loading_tasks_seem_expensive) {
         new_policy.loading_queue_policy.time_domain_type =
             TimeDomainType::THROTTLED;
       }
       if (timer_tasks_seem_expensive) {
         new_policy.timer_queue_policy.time_domain_type =
             TimeDomainType::THROTTLED;
       }
       break;
   }
-
   MainThreadOnly().expensive_task_policy = expensive_task_policy;
 
   if (MainThreadOnly().timer_queue_suspend_count != 0 ||
       MainThreadOnly().timer_queue_suspended_when_backgrounded) {
     new_policy.timer_queue_policy.is_enabled = false;
+    // TODO(alexclarke): Figure out if we really need to do this.
     new_policy.timer_queue_policy.time_domain_type = TimeDomainType::REAL;
   }
 
   if (MainThreadOnly().renderer_suspended) {
     new_policy.loading_queue_policy.is_enabled = false;
     DCHECK(!new_policy.timer_queue_policy.is_enabled);
   }
 
+  if (MainThreadOnly().use_virtual_time) {
+    new_policy.compositor_queue_policy.time_domain_type =
+        TimeDomainType::VIRTUAL;
+    new_policy.default_queue_policy.time_domain_type = TimeDomainType::VIRTUAL;
+    new_policy.loading_queue_policy.time_domain_type = TimeDomainType::VIRTUAL;
+    new_policy.timer_queue_policy.time_domain_type = TimeDomainType::VIRTUAL;
+  }
+
   // Tracing is done before the early out check, because it's quite possible we
   // will otherwise miss this information in traces.
   TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this, AsValueLocked(now));
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "use_case",
                  use_case);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "rail_mode",
                  new_policy.rail_mode);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
@@ skipping 55 matching lines @@
   if (old_task_queue_policy.is_enabled != new_task_queue_policy.is_enabled) {
     throttling_helper_->SetQueueEnabled(task_queue,
                                         new_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 (new_task_queue_policy.time_domain_type == TimeDomainType::THROTTLED) {
+    if (old_task_queue_policy.time_domain_type == TimeDomainType::THROTTLED) {
+      throttling_helper_->DecreaseThrottleRefCount(task_queue);
+    } else if (new_task_queue_policy.time_domain_type ==
+               TimeDomainType::THROTTLED) {
       throttling_helper_->IncreaseThrottleRefCount(task_queue);
-    } else if (old_task_queue_policy.time_domain_type ==
-               TimeDomainType::THROTTLED) {
-      throttling_helper_->DecreaseThrottleRefCount(task_queue);
+    } else if (new_task_queue_policy.time_domain_type ==
+               TimeDomainType::VIRTUAL) {
+      DCHECK(virtual_time_domain_);
+      task_queue->SetTimeDomain(virtual_time_domain_.get());
     }
   }
 }
 
 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 433 matching lines @@
 
 void RendererSchedulerImpl::OnQueueingTimeForWindowEstimated(
     base::TimeDelta queueing_time) {
   UMA_HISTOGRAM_TIMES("RendererScheduler.ExpectedTaskQueueingDuration",
                       queueing_time);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "estimated_queueing_time_for_window",
                  queueing_time.InMillisecondsF());
 }
 
+AutoAdvancingVirtualTimeDomain* RendererSchedulerImpl::GetVirtualTimeDomain() {
+  if (!virtual_time_domain_) {
+    virtual_time_domain_.reset(
+        new AutoAdvancingVirtualTimeDomain(tick_clock()->NowTicks()));
+    RegisterTimeDomain(virtual_time_domain_.get());
+  }
+  return virtual_time_domain_.get();
+}
+
+void RendererSchedulerImpl::EnableVirtualTime() {
+  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);
+
+  throttling_helper_->EnableVirtualTime();
+
+  ForceUpdatePolicy();
+}
+
 // static
 const char* RendererSchedulerImpl::UseCaseToString(UseCase use_case) {
   switch (use_case) {
     case UseCase::NONE:
       return "none";
     case UseCase::COMPOSITOR_GESTURE:
       return "compositor_gesture";
     case UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING:
       return "main_thread_custom_input_handling";
     case UseCase::SYNCHRONIZED_GESTURE:
@@ skipping 21 matching lines @@
       return "idle";
     case v8::PERFORMANCE_LOAD:
       return "load";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler