scheduler: Tell v8 about the current RAIL mode

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 114 matching lines @@
       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),
-      in_idle_period_for_testing(false) {}
+      in_idle_period_for_testing(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),
       have_seen_touchstart(false) {}
 
 RendererSchedulerImpl::AnyThread::~AnyThread() {}
 
 RendererSchedulerImpl::CompositorThreadOnly::CompositorThreadOnly()
     : last_input_type(blink::WebInputEvent::Undefined) {}
 
 RendererSchedulerImpl::CompositorThreadOnly::~CompositorThreadOnly() {}
 
 void RendererSchedulerImpl::Shutdown() {
   throttling_helper_.reset();
   helper_.Shutdown();
   MainThreadOnly().was_shutdown = true;
+  MainThreadOnly().rail_mode_observer = nullptr;
 }
 
 std::unique_ptr<blink::WebThread> RendererSchedulerImpl::CreateMainThread() {
   return base::WrapUnique(new WebThreadImplForRendererScheduler(this));
 }
 
 scoped_refptr<TaskQueue> RendererSchedulerImpl::DefaultTaskRunner() {
   return helper_.DefaultTaskRunner();
 }
 
@@ skipping 556 matching lines @@
   // Avoid prioritizing main thread compositing (e.g., rAF) if it is extremely
   // slow, because that can cause starvation in other task sources.
   bool main_thread_compositing_is_fast =
       MainThreadOnly().idle_time_estimator.GetExpectedIdleDuration(
           MainThreadOnly().compositor_frame_interval) >
       MainThreadOnly().compositor_frame_interval *
           kFastCompositingIdleTimeThreshold;
 
   Policy new_policy;
   ExpensiveTaskPolicy expensive_task_policy = ExpensiveTaskPolicy::RUN;
+  new_policy.rail_mode = v8::PERFORMANCE_ANIMATION;
+
   switch (use_case) {
     case UseCase::COMPOSITOR_GESTURE:
       if (touchstart_expected_soon) {
+        new_policy.rail_mode = v8::PERFORMANCE_RESPONSE;
         expensive_task_policy = ExpensiveTaskPolicy::BLOCK;
         new_policy.compositor_queue_policy.priority = TaskQueue::HIGH_PRIORITY;
       } else {
         // What we really want to do is priorize loading tasks, but that doesn't
         // seem to be safe. Instead we do that by proxy by deprioritizing
         // compositor tasks. This should be safe since we've already gone to the
         // pain of fixing ordering issues with them.
         new_policy.compositor_queue_policy.priority =
             TaskQueue::BEST_EFFORT_PRIORITY;
       }
       break;
 
     case UseCase::SYNCHRONIZED_GESTURE:
       new_policy.compositor_queue_policy.priority =
           main_thread_compositing_is_fast ? TaskQueue::HIGH_PRIORITY
                                           : TaskQueue::NORMAL_PRIORITY;
       if (touchstart_expected_soon) {
+        new_policy.rail_mode = v8::PERFORMANCE_RESPONSE;
         expensive_task_policy = ExpensiveTaskPolicy::BLOCK;
       } else {
         expensive_task_policy = ExpensiveTaskPolicy::THROTTLE;
       }
       break;
 
     case UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING:
       // In main thread input handling scenarios we don't have perfect knowledge
       // about which things we should be prioritizing, so we don't attempt to
       // block expensive tasks because we don't know whether they were integral
       // to the page's functionality or not.
       new_policy.compositor_queue_policy.priority =
           main_thread_compositing_is_fast ? TaskQueue::HIGH_PRIORITY
                                           : TaskQueue::NORMAL_PRIORITY;
       break;
 
     case UseCase::MAIN_THREAD_GESTURE:
       // A main thread gesture is for example a scroll gesture which is handled
       // by the main thread. Since we know the established gesture type, we can
       // be a little more aggressive about prioritizing compositing and input
       // handling over other tasks.
       new_policy.compositor_queue_policy.priority = TaskQueue::HIGH_PRIORITY;
       if (touchstart_expected_soon) {
+        new_policy.rail_mode = v8::PERFORMANCE_RESPONSE;
         expensive_task_policy = ExpensiveTaskPolicy::BLOCK;
       } else {
         expensive_task_policy = ExpensiveTaskPolicy::THROTTLE;
       }
       break;
 
     case UseCase::TOUCHSTART:
+      new_policy.rail_mode = v8::PERFORMANCE_RESPONSE;
       new_policy.compositor_queue_policy.priority = TaskQueue::HIGH_PRIORITY;
       new_policy.loading_queue_policy.is_enabled = false;
       new_policy.timer_queue_policy.is_enabled = false;
       // NOTE this is a nop due to the above.
       expensive_task_policy = ExpensiveTaskPolicy::BLOCK;
       break;
 
     case UseCase::NONE:
       // It's only safe to block tasks that if we are expecting a compositor
       // driven gesture.
       if (touchstart_expected_soon &&
           AnyThread().last_gesture_was_compositor_driven) {
+        new_policy.rail_mode = v8::PERFORMANCE_RESPONSE;
         expensive_task_policy = ExpensiveTaskPolicy::BLOCK;
       }
       break;
 
     case UseCase::LOADING:
+      new_policy.rail_mode = v8::PERFORMANCE_LOAD;
       new_policy.loading_queue_policy.priority = TaskQueue::HIGH_PRIORITY;
       new_policy.default_queue_policy.priority = TaskQueue::HIGH_PRIORITY;
       break;
 
     default:
       NOTREACHED();
   }
 
+  // TODO(skyostil): Add an idle state for foreground tabs too.
+  if (MainThreadOnly().renderer_hidden)
+    new_policy.rail_mode = v8::PERFORMANCE_IDLE;
+
   if (expensive_task_policy == ExpensiveTaskPolicy::BLOCK &&
       (!MainThreadOnly().expensive_task_blocking_allowed ||
        !MainThreadOnly().have_seen_a_begin_main_frame ||
        MainThreadOnly().navigation_task_expected_count > 0)) {
     expensive_task_policy = ExpensiveTaskPolicy::RUN;
   }
 
   switch (expensive_task_policy) {
     case ExpensiveTaskPolicy::RUN:
       break;
@@ skipping 30 matching lines @@
     DCHECK(!new_policy.timer_queue_policy.is_enabled);
   }
 
   // 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"),
                  "touchstart_expected_soon",
                  MainThreadOnly().touchstart_expected_soon);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "expensive_task_policy", expensive_task_policy);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "RendererScheduler.loading_tasks_seem_expensive",
                  MainThreadOnly().loading_tasks_seem_expensive);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "RendererScheduler.timer_tasks_seem_expensive",
@@ skipping 22 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);
+  if (MainThreadOnly().rail_mode_observer &&
+      new_policy.rail_mode != MainThreadOnly().current_policy.rail_mode) {
+    MainThreadOnly().rail_mode_observer->OnRAILModeChanged(
+        new_policy.rail_mode);
+  }
 
   DCHECK(compositor_task_runner_->IsQueueEnabled());
   MainThreadOnly().current_policy = new_policy;
 }
 
 void RendererSchedulerImpl::ApplyTaskQueuePolicy(
     TaskQueue* task_queue,
     const TaskQueuePolicy& old_task_queue_policy,
     const TaskQueuePolicy& new_task_queue_policy) const {
   if (old_task_queue_policy.is_enabled != new_task_queue_policy.is_enabled) {
@@ skipping 176 matching lines @@
 
   if (optional_now.is_null())
     optional_now = helper_.scheduler_tqm_delegate()->NowTicks();
   std::unique_ptr<base::trace_event::TracedValue> state(
       new base::trace_event::TracedValue());
   state->SetBoolean(
       "has_visible_render_widget_with_touch_handler",
       MainThreadOnly().has_visible_render_widget_with_touch_handler);
   state->SetString("current_use_case",
                    UseCaseToString(MainThreadOnly().current_use_case));
+  state->SetString("rail_mode",
+                   RAILModeToString(MainThreadOnly().current_policy.rail_mode));
   state->SetBoolean("expensive_task_blocking_allowed",
                     MainThreadOnly().expensive_task_blocking_allowed);
   state->SetBoolean("loading_tasks_seem_expensive",
                     MainThreadOnly().loading_tasks_seem_expensive);
   state->SetBoolean("timer_tasks_seem_expensive",
                     MainThreadOnly().timer_tasks_seem_expensive);
   state->SetBoolean("begin_frame_not_expected_soon",
                     MainThreadOnly().begin_frame_not_expected_soon);
   state->SetBoolean("touchstart_expected_soon",
                     MainThreadOnly().touchstart_expected_soon);
@@ skipping 159 matching lines @@
   // Per-frame task runners (loading, timers, etc.) are configured with a more
   // specific blame context by WebFrameSchedulerImpl.
   control_task_runner_->SetBlameContext(blame_context);
   DefaultTaskRunner()->SetBlameContext(blame_context);
   default_loading_task_runner_->SetBlameContext(blame_context);
   default_timer_task_runner_->SetBlameContext(blame_context);
   compositor_task_runner_->SetBlameContext(blame_context);
   idle_helper_.IdleTaskRunner()->SetBlameContext(blame_context);
 }
 
+void RendererSchedulerImpl::SetRAILModeObserver(RAILModeObserver* observer) {
+  MainThreadOnly().rail_mode_observer = observer;
+}
+
 void RendererSchedulerImpl::RegisterTimeDomain(TimeDomain* time_domain) {
   helper_.RegisterTimeDomain(time_domain);
 }
 
 void RendererSchedulerImpl::UnregisterTimeDomain(TimeDomain* time_domain) {
   helper_.UnregisterTimeDomain(time_domain);
 }
 
 void RendererSchedulerImpl::SetExpensiveTaskBlockingAllowed(bool allowed) {
   MainThreadOnly().expensive_task_blocking_allowed = allowed;
 }
 
 base::TickClock* RendererSchedulerImpl::tick_clock() const {
   return helper_.scheduler_tqm_delegate().get();
 }
 
 void RendererSchedulerImpl::AddWebViewScheduler(
     WebViewSchedulerImpl* web_view_scheduler) {
-  MainThreadOnly().web_view_schedulers_.insert(web_view_scheduler);
+  MainThreadOnly().web_view_schedulers.insert(web_view_scheduler);
 }
 
 void RendererSchedulerImpl::RemoveWebViewScheduler(
     WebViewSchedulerImpl* web_view_scheduler) {
-  DCHECK(MainThreadOnly().web_view_schedulers_.find(web_view_scheduler) !=
-         MainThreadOnly().web_view_schedulers_.end());
-  MainThreadOnly().web_view_schedulers_.erase(web_view_scheduler);
+  DCHECK(MainThreadOnly().web_view_schedulers.find(web_view_scheduler) !=
+         MainThreadOnly().web_view_schedulers.end());
+  MainThreadOnly().web_view_schedulers.erase(web_view_scheduler);
 }
 
 void RendererSchedulerImpl::BroadcastConsoleWarning(
     const std::string& message) {
   helper_.CheckOnValidThread();
-  for (auto& web_view_scheduler : MainThreadOnly().web_view_schedulers_)
+  for (auto& web_view_scheduler : MainThreadOnly().web_view_schedulers)
     web_view_scheduler->AddConsoleWarning(message);
 }
 
 void RendererSchedulerImpl::OnTriedToExecuteBlockedTask(
     const TaskQueue& queue,
     const base::PendingTask& task) {
   if (!MainThreadOnly().expensive_task_blocking_allowed ||
       MainThreadOnly().current_use_case == UseCase::TOUCHSTART ||
       MainThreadOnly().longest_jank_free_task_duration <
           base::TimeDelta::FromMilliseconds(kRailsResponseTimeMillis) ||
@@ skipping 23 matching lines @@
         true;
     BroadcastConsoleWarning(
         "Blink deferred a task in order to make scrolling smoother. "
         "Your timer and network 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.");
   }
 }
 
+// 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:
+      return "synchronized_gesture";
+    case UseCase::TOUCHSTART:
+      return "touchstart";
+    case UseCase::LOADING:
+      return "loading";
+    case UseCase::MAIN_THREAD_GESTURE:
+      return "main_thread_gesture";
+    default:
+      NOTREACHED();
+      return nullptr;
+  }
+}
+
+// static
+const char* RendererSchedulerImpl::RAILModeToString(v8::RAILMode rail_mode) {
+  switch (rail_mode) {
+    case v8::PERFORMANCE_RESPONSE:
+      return "response";
+    case v8::PERFORMANCE_ANIMATION:
+      return "animation";
+    case v8::PERFORMANCE_IDLE:
+      return "idle";
+    case v8::PERFORMANCE_LOAD:
+      return "load";
+    default:
+      NOTREACHED();
+      return nullptr;
+  }
+}
+
 }  // namespace scheduler