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 185 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),
+      have_seen_input_since_navigation(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 399 matching lines @@
                "type", static_cast<int>(type), "input_event_state",
                InputEventStateToString(input_event_state));
 
   base::TimeDelta unused_policy_duration;
   UseCase previous_use_case =
       ComputeCurrentUseCase(now, &unused_policy_duration);
   bool was_awaiting_touch_start_response =
       AnyThread().awaiting_touch_start_response;
 
   AnyThread().user_model.DidStartProcessingInputEvent(type, now);
+  AnyThread().have_seen_input_since_navigation = true;
 
   if (input_event_state == InputEventState::EVENT_CONSUMED_BY_COMPOSITOR)
     AnyThread().user_model.DidFinishProcessingInputEvent(now);
 
   switch (type) {
     case blink::WebInputEvent::TouchStart:
       AnyThread().awaiting_touch_start_response = true;
       // This is just a fail-safe to reset the state of
       // |last_gesture_was_compositor_driven| to the default. We don't know
       // yet where the gesture will run.
@@ skipping 339 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 and throttling rendering frame rate.
       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 185 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.
+  // Occasionally the meaningful paint fails to be detected, so as a fallback we
+  // treat the presence of input as an indirect signal that there is meaningful
+  // content on the page.
+  if (AnyThread().waiting_for_meaningful_paint &&
+      !AnyThread().have_seen_input_since_navigation) {
+    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 124 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_seen_input_since_navigation",
+                    AnyThread().have_seen_input_since_navigation);
   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 105 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();

[alex clarke (OOO till 29th), 2016/11/24 17:54:23]

Can we call 
  UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED); inside the
lock?

[Sami, 2016/11/24 18:41:37]

Oh, well spotted, thanks!

+}
+
 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::ResumeTimerQueueWhenForegroundedOrResumed() {
   DCHECK(!MainThreadOnly().renderer_backgrounded ||
          (MainThreadOnly().renderer_backgrounded &&
           !MainThreadOnly().renderer_suspended));
   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;
+  AnyThread().have_seen_input_since_navigation = false;
   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;
   for (WebViewSchedulerImpl* web_view_scheduler :
        MainThreadOnly().web_view_schedulers) {
     web_view_scheduler->OnNavigation();
   }
   UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
@@ skipping 229 matching lines @@
     case TimeDomainType::VIRTUAL:
       return "virtual";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink