Suspend more task queues for background renderers (experimental)

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"
@@ skipping 103 matching lines @@
                           kShortIdlePeriodDurationSampleCount,
                           kShortIdlePeriodDurationPercentile),
       current_use_case(UseCase::NONE),
       timer_queue_suspend_count(0),
       navigation_task_expected_count(0),
       expensive_task_policy(ExpensiveTaskPolicy::RUN),
       renderer_hidden(false),
       renderer_backgrounded(false),
       timer_queue_suspension_when_backgrounded_enabled(false),
       timer_queue_suspended_when_backgrounded(false),
+      queue_suspended(false),
       was_shutdown(false),
       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),
@@ skipping 691 matching lines @@
       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;
   }
 
+  if (MainThreadOnly().queue_suspended) {
+    new_policy.compositor_queue_policy.is_enabled = false;
+    new_policy.loading_queue_policy.is_enabled = false;
+    new_policy.control_queue_policy.is_enabled = false;
+  }
+
   // 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"),
                  "touchstart_expected_soon",
                  MainThreadOnly().touchstart_expected_soon);
@@ skipping 30 matching lines @@
   MainThreadOnly().have_reported_blocking_intervention_in_current_policy =
       false;
 
   // TODO(alexclarke): We shouldn't have to prioritize the default queue, but it
   // appears to be necessary since the order of loading tasks and IPCs (which
   // are mostly dispatched on the default queue) need to be preserved.
   ApplyTaskQueuePolicy(helper_.DefaultTaskRunner().get(),
                        MainThreadOnly().current_policy.default_queue_policy,
                        new_policy.default_queue_policy);
 
-  DCHECK(compositor_task_runner_->IsQueueEnabled());
+  ApplyTaskQueuePolicy(helper_.ControlTaskRunner().get(),
+                       MainThreadOnly().current_policy.control_queue_policy,
+                       new_policy.control_queue_policy);
+  ApplyTaskQueuePolicy(helper_.ControlAfterWakeUpTaskRunner().get(),
+                       MainThreadOnly().current_policy.control_queue_policy,
+                       new_policy.control_queue_policy);
+
   MainThreadOnly().current_policy = new_policy;
 }
 
 void RendererSchedulerImpl::ApplyTaskQueuePolicy(
     TaskQueue* task_queue,
     const TaskQueuePolicy& old_task_queue_policy,
     const TaskQueuePolicy& new_task_queue_policy) const {
   // The ThrottlingHelper also calls SetQueueEnabled, so we can avoid calling
   // this here.
   if (new_task_queue_policy.time_domain_type != TimeDomainType::THROTTLED)
@@ skipping 311 matching lines @@
          base::TimeDelta::FromMilliseconds(
              kIdlePeriodStarvationThresholdMillis);
 }
 
 void RendererSchedulerImpl::SuspendTimerQueueWhenBackgrounded() {
   DCHECK(MainThreadOnly().renderer_backgrounded);
   if (MainThreadOnly().timer_queue_suspended_when_backgrounded)
     return;
 
   MainThreadOnly().timer_queue_suspended_when_backgrounded = true;
+  MainThreadOnly().queue_suspended = true;
   ForceUpdatePolicy();
 }
 
 void RendererSchedulerImpl::ResumeTimerQueueWhenForegrounded() {
   DCHECK(!MainThreadOnly().renderer_backgrounded);
   if (!MainThreadOnly().timer_queue_suspended_when_backgrounded)
     return;
 
   MainThreadOnly().timer_queue_suspended_when_backgrounded = false;
+  MainThreadOnly().queue_suspended = false;
   ForceUpdatePolicy();
 }
 
 void RendererSchedulerImpl::ResetForNavigationLocked() {
   helper_.CheckOnValidThread();
   any_thread_lock_.AssertAcquired();
   AnyThread().user_model.Reset(helper_.scheduler_tqm_delegate()->NowTicks());
   AnyThread().have_seen_touchstart = false;
   MainThreadOnly().loading_task_cost_estimator.Clear();
   MainThreadOnly().timer_task_cost_estimator.Clear();
@@ skipping 81 matching lines @@
     BroadcastConsoleWarning(
         "Blink deferred a task in order to make scrolling smoother. "
         "Your timer tasks should take less than 50ms to run to avoid this. "
         "Please see "
         "https://developers.google.com/web/tools/chrome-devtools/profile/evaluate-performance/rail"
         " and https://crbug.com/574343#c40 for more information.");
   }
 }
 
 }  // namespace scheduler