Add a signal to the scheduler that a navigation is expected

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/trace_event/trace_event.h"
 #include "base/trace_event/trace_event_argument.h"
@@ skipping 93 matching lines @@
       current_use_case(UseCase::NONE),
       timer_queue_suspend_count(0),
       renderer_hidden(false),
       renderer_backgrounded(false),
       timer_queue_suspension_when_backgrounded_enabled(false),
       timer_queue_suspended_when_backgrounded(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_seen_a_begin_main_frame(false),
+      navigation_expected(false) {}
 
 RendererSchedulerImpl::MainThreadOnly::~MainThreadOnly() {}
 
 RendererSchedulerImpl::AnyThread::AnyThread()
     : awaiting_touch_start_response(false),
       in_idle_period(false),
       begin_main_frame_on_critical_path(false) {}
 
 RendererSchedulerImpl::CompositorThreadOnly::CompositorThreadOnly()
     : last_input_type(blink::WebInputEvent::Undefined) {}
@@ skipping 461 matching lines @@
       break;
 
     default:
       NOTREACHED();
   }
 
   // Don't block expensive tasks unless we have actually seen something.
   if (!MainThreadOnly().have_seen_a_begin_main_frame)
     block_expensive_tasks = false;
 
+  // Don't block expensive tasks if we are expecting a navigation.
+  if (MainThreadOnly().navigation_expected)
+    block_expensive_tasks = false;
+
   if (block_expensive_tasks && loading_tasks_seem_expensive)
     new_policy.loading_queue_priority = TaskQueue::DISABLED_PRIORITY;
 
   if ((block_expensive_tasks && timer_tasks_seem_expensive) ||
       MainThreadOnly().timer_queue_suspend_count != 0 ||
       MainThreadOnly().timer_queue_suspended_when_backgrounded) {
     new_policy.timer_queue_priority = TaskQueue::DISABLED_PRIORITY;
   }
 
   // Tracing is done before the early out check, because it's quite possible we
@@ skipping 156 matching lines @@
                     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->SetBoolean("navigation_expected",
+                    MainThreadOnly().navigation_expected);
   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);
   state->SetBoolean("begin_main_frame_on_critical_path",
                     AnyThread().begin_main_frame_on_critical_path);
   state->SetDouble("expected_loading_task_duration",
                    MainThreadOnly()
                        .loading_task_cost_estimator.expected_task_duration()
@@ skipping 22 matching lines @@
   UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
 }
 
 void RendererSchedulerImpl::OnIdlePeriodEnded() {
   base::AutoLock lock(any_thread_lock_);
   AnyThread().last_idle_period_end_time = helper_.Now();
   AnyThread().in_idle_period = false;
   UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
 }
 
-void RendererSchedulerImpl::OnPageLoadStarted() {
+void RendererSchedulerImpl::OnNavigationExpected() {
+  helper_.CheckOnValidThread();
+  base::AutoLock lock(any_thread_lock_);

[Sami, 2015/09/24 15:16:15]

nit: Just call UpdatePolicy() to avoid some boilerplate?

[alex clarke (OOO till 29th), 2015/09/24 15:37:14]

Done.

+  MainThreadOnly().navigation_expected = true;
+  UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
+}
+
+void RendererSchedulerImpl::OnNavigationCanceled() {
+  helper_.CheckOnValidThread();
+  base::AutoLock lock(any_thread_lock_);

[Sami, 2015/09/24 15:16:15]

Ditto.

[alex clarke (OOO till 29th), 2015/09/24 15:37:14]

Done.

+  MainThreadOnly().navigation_expected = false;
+  UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
+}
+
+void RendererSchedulerImpl::OnNavigationStarted() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
-               "RendererSchedulerImpl::OnPageLoadStarted");
+               "RendererSchedulerImpl::OnNavigationStarted");
   base::AutoLock lock(any_thread_lock_);
   AnyThread().rails_loading_priority_deadline =
       helper_.Now() + base::TimeDelta::FromMilliseconds(
                           kRailsInitialLoadingPrioritizationMillis);
   ResetForNavigationLocked();
 }
 
 bool RendererSchedulerImpl::HadAnIdlePeriodRecently(base::TimeTicks now) const {
   return (now - AnyThread().last_idle_period_end_time) <=
          base::TimeDelta::FromMilliseconds(
@@ skipping 20 matching lines @@
 
 void RendererSchedulerImpl::ResetForNavigationLocked() {
   helper_.CheckOnValidThread();
   any_thread_lock_.AssertAcquired();
   MainThreadOnly().loading_task_cost_estimator.Clear();
   MainThreadOnly().timer_task_cost_estimator.Clear();
   MainThreadOnly().short_idle_period_duration.Clear();
   // Make sure that we don't initially assume there is no idle time.
   MainThreadOnly().short_idle_period_duration.InsertSample(
       cc::BeginFrameArgs::DefaultInterval());
+  MainThreadOnly().navigation_expected = false;
   AnyThread().user_model.Reset();
   MainThreadOnly().have_seen_a_begin_main_frame = false;
   UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
 }
 
 }  // namespace scheduler