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 84 matching lines @@
       default_queue_priority(TaskQueue::NORMAL_PRIORITY) {}
 
 RendererSchedulerImpl::MainThreadOnly::MainThreadOnly()
     : loading_task_cost_estimator(kLoadingTaskEstimationSampleCount,
                                   kLoadingTaskEstimationPercentile),
       timer_task_cost_estimator(kTimerTaskEstimationSampleCount,
                                 kTimerTaskEstimationPercentile),
       short_idle_period_duration(kShortIdlePeriodDurationSampleCount),
       current_use_case(UseCase::NONE),
       timer_queue_suspend_count(0),
+      navigation_task_expected_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) {}
 
@@ skipping 509 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_task_expected_count > 0)
+    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 165 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->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);
   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::NavigationTaskPendingIncRef() {
+  helper_.CheckOnValidThread();
+  MainThreadOnly().navigation_task_expected_count++;
+  UpdatePolicy();
+}
+
+void RendererSchedulerImpl::NavigationTaskPendingDecRef() {
+  helper_.CheckOnValidThread();
+  DCHECK_GT(MainThreadOnly().navigation_task_expected_count, 0);
+  if (MainThreadOnly().navigation_task_expected_count > 0)
+    MainThreadOnly().navigation_task_expected_count--;
+  UpdatePolicy();
+}
+
+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 26 matching lines @@
   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());
   AnyThread().user_model.Reset();
   MainThreadOnly().have_seen_a_begin_main_frame = false;
   UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);
 }
 
 }  // namespace scheduler