scheduler: Detect load RAIL mode

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 177 matching lines @@
       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) {}
+      have_seen_touchstart(false),
+      waiting_for_meaningful_paint(false) {}
 
 RendererSchedulerImpl::AnyThread::~AnyThread() {}
 
 RendererSchedulerImpl::CompositorThreadOnly::CompositorThreadOnly()
     : last_input_type(blink::WebInputEvent::Undefined) {}
 
 RendererSchedulerImpl::CompositorThreadOnly::~CompositorThreadOnly() {}
 
 void RendererSchedulerImpl::Shutdown() {
   base::TimeTicks now = tick_clock()->NowTicks();
@@ skipping 691 matching lines @@
       // 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;
+      // TODO(skyostil): Experiment with increasing loading and default queue
+      // priorities.

[alex clarke (OOO till 29th), 2016/10/11 10:32:50]

This is probably sensible for now. Presumably we'd want to throttle compositing
somehow, although I note the current throttling is likely too harsh, rather
limiting compositing to say 50% of CPU seems reasonable?

[Sami, 2016/10/12 04:21:40]

Yeah, something like that might be interesting. Although, if nothing else is
competing for CPU during loading I think we might still want to let rendering
happen at full speed. Added this as a reminder in the comment here.

       break;
 
     default:
       NOTREACHED();
   }
 
   // TODO(skyostil): Add an idle state for foreground tabs too.
   if (MainThreadOnly().renderer_hidden)
     new_policy.rail_mode = v8::PERFORMANCE_IDLE;
 
@@ skipping 172 matching lines @@
         return UseCase::COMPOSITOR_GESTURE;
       }
     }
     if (AnyThread().default_gesture_prevented) {
       return UseCase::MAIN_THREAD_CUSTOM_INPUT_HANDLING;
     } else {
       return UseCase::MAIN_THREAD_GESTURE;
     }
   }
 
-  // TODO(alexclarke): return UseCase::LOADING if signals suggest the system is
-  // in the initial 1s of RAIL loading.
+  if (AnyThread().waiting_for_meaningful_paint)

[alex clarke (OOO till 29th), 2016/10/11 10:32:50]

So until first meaningful paint, if the user isn't trying to scroll, we'll enter
loading policy.  Is that the right thing to do? Should we abandon loading policy
after the user has interacted, or is this OK?

What if a desktop user presses a key? Currently we don't notice that and we'd
stay in loading policy.

[Sami, 2016/10/12 04:21:40]

Right, this implementation of 'L' is very greedy in the sense that it can remain
in loading mode for much longer than necessary (possibly forever). For now I
think this is fine because v8 takes precautions against it.

I think the way to fix this in the long term is to make the first meaningful
paint signal more reliable instead of trying to double-guess things here in the
scheduler. If the user presses a key or tries to otherwise interact with the
page before FMP, we should be able to assume that loading is still in progress
because there's nothing meaningful on the screen yet.

What we can and should do (and already do in this patch) is to let gestures take
us temporarily into other use cases so that things work nicely even if FMP is
wrong. Once we start doing actual prioritization I suspect we'll need bit more
of a safety net for pages where FMP isn't realiable (e.g., someone mentioned the
facebook chat widget which is basically always loading).

+    return UseCase::LOADING;
   return UseCase::NONE;
 }
 
 base::TimeDelta RendererSchedulerImpl::EstimateLongestJankFreeTaskDuration()
     const {
   switch (MainThreadOnly().current_use_case) {
     case UseCase::TOUCHSTART:
     case UseCase::COMPOSITOR_GESTURE:
     case UseCase::LOADING:
     case UseCase::NONE:
@@ skipping 126 matching lines @@
   state->SetBoolean("begin_frame_not_expected_soon",
                     MainThreadOnly().begin_frame_not_expected_soon);
   state->SetBoolean("touchstart_expected_soon",
                     MainThreadOnly().touchstart_expected_soon);
   state->SetString("idle_period_state",
                    IdleHelper::IdlePeriodStateToString(
                        idle_helper_.SchedulerIdlePeriodState()));
   state->SetBoolean("renderer_hidden", MainThreadOnly().renderer_hidden);
   state->SetBoolean("have_seen_a_begin_main_frame",
                     MainThreadOnly().have_seen_a_begin_main_frame);
+  state->SetBoolean("waiting_for_meaningful_paint",
+                    AnyThread().waiting_for_meaningful_paint);
   state->SetBoolean(
       "have_reported_blocking_intervention_in_current_policy",
       MainThreadOnly().have_reported_blocking_intervention_in_current_policy);
   state->SetBoolean(
       "have_reported_blocking_intervention_since_navigation",
       MainThreadOnly().have_reported_blocking_intervention_since_navigation);
   state->SetBoolean("renderer_backgrounded",
                     MainThreadOnly().renderer_backgrounded);
   state->SetBoolean("timer_queue_suspended_when_backgrounded",
                     MainThreadOnly().timer_queue_suspended_when_backgrounded);
   state->SetInteger("timer_queue_suspend_count",
                     MainThreadOnly().timer_queue_suspend_count);
   state->SetDouble("now", (optional_now - base::TimeTicks()).InMillisecondsF());
   state->SetDouble(
-      "rails_loading_priority_deadline",
-      (AnyThread().rails_loading_priority_deadline - base::TimeTicks())
-          .InMillisecondsF());
-  state->SetDouble(
       "fling_compositor_escalation_deadline",
       (AnyThread().fling_compositor_escalation_deadline - base::TimeTicks())
           .InMillisecondsF());
   state->SetInteger("navigation_task_expected_count",
                     MainThreadOnly().navigation_task_expected_count);
   state->SetDouble("last_idle_period_end_time",
                    (AnyThread().last_idle_period_end_time - base::TimeTicks())
                        .InMillisecondsF());
   state->SetBoolean("awaiting_touch_start_response",
                     AnyThread().awaiting_touch_start_response);
@@ skipping 69 matching lines @@
       MainThreadOnly().navigation_task_expected_count > 0) {
     MainThreadOnly().navigation_task_expected_count--;
     UpdatePolicy();
   }
 }
 
 void RendererSchedulerImpl::OnNavigationStarted() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::OnNavigationStarted");
   base::AutoLock lock(any_thread_lock_);
-  AnyThread().rails_loading_priority_deadline =
-      helper_.scheduler_tqm_delegate()->NowTicks() +
-      base::TimeDelta::FromMilliseconds(
-          kRailsInitialLoadingPrioritizationMillis);
   ResetForNavigationLocked();
 }
 
+void RendererSchedulerImpl::OnFirstMeaningfulPaint() {
+  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
+               "RendererSchedulerImpl::OnFirstMeaningfulPaint");
+  {
+    base::AutoLock lock(any_thread_lock_);
+    AnyThread().waiting_for_meaningful_paint = false;
+  }
+  UpdatePolicy();
+}
+
 void RendererSchedulerImpl::SuspendTimerQueueWhenBackgrounded() {
   DCHECK(MainThreadOnly().renderer_backgrounded);
   if (MainThreadOnly().timer_queue_suspended_when_backgrounded)
     return;
 
   MainThreadOnly().timer_queue_suspended_when_backgrounded = true;
   ForceUpdatePolicy();
 }
 
 void RendererSchedulerImpl::ResumeTimerQueueWhenForegrounded() {
   DCHECK(!MainThreadOnly().renderer_backgrounded);
   if (!MainThreadOnly().timer_queue_suspended_when_backgrounded)
     return;
 
   MainThreadOnly().timer_queue_suspended_when_backgrounded = 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;
+  AnyThread().waiting_for_meaningful_paint = true;
   MainThreadOnly().loading_task_cost_estimator.Clear();
   MainThreadOnly().timer_task_cost_estimator.Clear();
   MainThreadOnly().idle_time_estimator.Clear();
   MainThreadOnly().have_seen_a_begin_main_frame = false;
   MainThreadOnly().have_reported_blocking_intervention_since_navigation = false;
   UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
 }
 
 void RendererSchedulerImpl::SetTopLevelBlameContext(
     base::trace_event::BlameContext* blame_context) {
@@ skipping 187 matching lines @@
     case v8::PERFORMANCE_LOAD:
       return "load";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink