scheduler: Detect load RAIL mode

third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc

Index: third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc b/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc
index 0d5d624c3473fbf9c57ddb54950c5c75b4a7da83..babc1940378cf168b81cf76bb013567ae0027b2c 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc
@@ -195,7 +195,8 @@ RendererSchedulerImpl::AnyThread::AnyThread()
       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() {}
 
@@ -907,8 +908,8 @@ void RendererSchedulerImpl::UpdatePolicyLocked(UpdateType update_type) {
 
     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:
@@ -1101,8 +1102,8 @@ RendererSchedulerImpl::UseCase RendererSchedulerImpl::ComputeCurrentUseCase(
     }
   }
 
-  // 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;
 }
 
@@ -1249,6 +1250,8 @@ RendererSchedulerImpl::AsValueLocked(base::TimeTicks optional_now) const {
   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);
@@ -1263,10 +1266,6 @@ RendererSchedulerImpl::AsValueLocked(base::TimeTicks optional_now) const {
                     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());
@@ -1356,13 +1355,19 @@ 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)
@@ -1386,6 +1391,7 @@ void RendererSchedulerImpl::ResetForNavigationLocked() {
   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();