A better idle time estimator

components/scheduler/renderer/renderer_scheduler_impl.cc

Index: components/scheduler/renderer/renderer_scheduler_impl.cc
diff --git a/components/scheduler/renderer/renderer_scheduler_impl.cc b/components/scheduler/renderer/renderer_scheduler_impl.cc
index 1193339bddd77a356fad476e9166816153690ab1..b2ee0e11a3ff418fa66744dc60267ac56082a903 100644
--- a/components/scheduler/renderer/renderer_scheduler_impl.cc
+++ b/components/scheduler/renderer/renderer_scheduler_impl.cc
@@ -20,7 +20,7 @@ const double kLoadingTaskEstimationPercentile = 90;
 const int kTimerTaskEstimationSampleCount = 200;
 const double kTimerTaskEstimationPercentile = 90;
 const int kShortIdlePeriodDurationSampleCount = 10;
-const double kShortIdlePeriodDurationPercentile = 20;
+const double kShortIdlePeriodDurationPercentile = 50;
 }
 
 RendererSchedulerImpl::RendererSchedulerImpl(
@@ -57,14 +57,13 @@ RendererSchedulerImpl::RendererSchedulerImpl(
   default_loading_task_runner_ = NewLoadingTaskRunner("default_loading_tq");
   default_timer_task_runner_ = NewTimerTaskRunner("default_timer_tq");
 
+  compositor_task_runner_->AddTaskObserver(
+      &MainThreadOnly().idle_time_estimator);
+
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"), "RendererScheduler",
       this);
 
-  // Make sure that we don't initially assume there is no idle time.
-  MainThreadOnly().short_idle_period_duration.InsertSample(
-      cc::BeginFrameArgs::DefaultInterval());
-
   helper_.SetObserver(this);
 }
 
@@ -99,7 +98,8 @@ RendererSchedulerImpl::MainThreadOnly::MainThreadOnly()
                                   kLoadingTaskEstimationPercentile),
       timer_task_cost_estimator(kTimerTaskEstimationSampleCount,
                                 kTimerTaskEstimationPercentile),
-      short_idle_period_duration(kShortIdlePeriodDurationSampleCount),
+      idle_time_estimator(kShortIdlePeriodDurationSampleCount,
+                          kShortIdlePeriodDurationPercentile),
       current_use_case(UseCase::NONE),
       timer_queue_suspend_count(0),
       navigation_task_expected_count(0),
@@ -240,16 +240,9 @@ void RendererSchedulerImpl::DidCommitFrameToCompositor() {
     idle_helper_.StartIdlePeriod(
         IdleHelper::IdlePeriodState::IN_SHORT_IDLE_PERIOD, now,
         MainThreadOnly().estimated_next_frame_begin);
-    MainThreadOnly().short_idle_period_duration.InsertSample(
-        MainThreadOnly().estimated_next_frame_begin - now);
-  } else {
-    // There was no idle time :(
-    MainThreadOnly().short_idle_period_duration.InsertSample(base::TimeDelta());
   }
 
-  MainThreadOnly().expected_short_idle_period_duration =
-      MainThreadOnly().short_idle_period_duration.Percentile(
-          kShortIdlePeriodDurationPercentile);
+  MainThreadOnly().idle_time_estimator.DidCommitFrameToCompositor();
 }
 
 void RendererSchedulerImpl::BeginFrameNotExpectedSoon() {
@@ -561,12 +554,12 @@ void RendererSchedulerImpl::UpdatePolicyLocked(UpdateType update_type) {
 
   bool loading_tasks_seem_expensive =
       MainThreadOnly().loading_task_cost_estimator.expected_task_duration() >
-      MainThreadOnly().expected_short_idle_period_duration;
+      MainThreadOnly().idle_time_estimator.expected_idle_duration();
   MainThreadOnly().loading_tasks_seem_expensive = loading_tasks_seem_expensive;
 
   bool timer_tasks_seem_expensive =
       MainThreadOnly().timer_task_cost_estimator.expected_task_duration() >
-      MainThreadOnly().expected_short_idle_period_duration;
+      MainThreadOnly().idle_time_estimator.expected_idle_duration();
   MainThreadOnly().timer_tasks_seem_expensive = timer_tasks_seem_expensive;
 
   // The |new_policy_duration| is the minimum of |expected_use_case_duration|
@@ -639,7 +632,8 @@ void RendererSchedulerImpl::UpdatePolicyLocked(UpdateType update_type) {
   if (block_expensive_tasks && loading_tasks_seem_expensive)
     new_policy.loading_queue_priority = TaskQueue::DISABLED_PRIORITY;
 
-  if (MainThreadOnly().timer_queue_suspend_count != 0 ||
+  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;
   }
@@ -838,9 +832,10 @@ RendererSchedulerImpl::AsValueLocked(base::TimeTicks optional_now) const {
                        .timer_task_cost_estimator.expected_task_duration()
                        .InMillisecondsF());
   // TODO(skyostil): Can we somehow trace how accurate these estimates were?
-  state->SetDouble(
-      "expected_short_idle_period_duration",
-      MainThreadOnly().expected_short_idle_period_duration.InMillisecondsF());
+  state->SetDouble("idle_time_estimator",

[Sami, 2015/10/03 00:56:15]

nit: expected_idle_duration instead of idle_time_estimator

[alex clarke (OOO till 29th), 2015/10/05 17:32:19]

Done.

+                   MainThreadOnly()
+                       .idle_time_estimator.expected_idle_duration()
+                       .InMillisecondsF());
   state->SetDouble(
       "estimated_next_frame_begin",
       (MainThreadOnly().estimated_next_frame_begin - base::TimeTicks())
@@ -917,10 +912,7 @@ void RendererSchedulerImpl::ResetForNavigationLocked() {
   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().idle_time_estimator.Clear();
   AnyThread().user_model.Reset();
   MainThreadOnly().have_seen_a_begin_main_frame = false;
   UpdatePolicyLocked(UpdateType::MAY_EARLY_OUT_IF_POLICY_UNCHANGED);