A better idle time estimator

components/scheduler/renderer/idle_time_estimator.cc

+// Copyright 2015 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/idle_time_estimator.h"
+
+#include "base/time/default_tick_clock.h"
+#include "cc/output/begin_frame_args.h"
+
+namespace scheduler {
+
+IdleTimeEstimator::IdleTimeEstimator(int sample_count,
+                                     double estimation_percentile)
+    : frame_length_(sample_count),
+      per_frame_compositor_task_runtime_(sample_count),
+      time_source_(new base::DefaultTickClock),
+      estimation_percentile_(estimation_percentile),
+      did_commit_(false) {
+  // Make sure that we don't initially assume there is no idle time.
+  frame_length_.InsertSample(cc::BeginFrameArgs::DefaultInterval());
+}
+
+IdleTimeEstimator::~IdleTimeEstimator() {}
+
+base::TimeDelta IdleTimeEstimator::GetExpectedIdleDuration(
+    base::TimeDelta max_frame_length) const {
+  base::TimeDelta expected_frame_length = std::min(

[Sami, 2015/10/09 02:32:18]

Are we getting any information out of this frame length estimation? For the main
thread gesture use case the max is 16.6 ms, and this estimation will basically
never be below that number. In the compositor scrolling use case I'm not sure we
should be even throttling anything since that won't really affect the visible
result anyway. In the idle case (when we're expecting a gesture) maybe just a
constant 50 ms threshold would be enough -- even without subtracting compositing
time since we're not yet compositing anything in that state.

Basically I'm wondering if we should just replace |expected_frame_length| with a
parameter that gets passed in instead of |max_frame_length|? I think the only
time we would end up calling here would be in the main thread gesture case.
WDYT?

[alex clarke (OOO till 29th), 2015/10/15 13:24:01]

Done.

+      frame_length_.Percentile(estimation_percentile_), max_frame_length);
+  base::TimeDelta expected_compositor_task_runtime_ =
+      per_frame_compositor_task_runtime_.Percentile(estimation_percentile_);
+  return std::max(base::TimeDelta(),
+                  expected_frame_length - expected_compositor_task_runtime_);
+}
+
+void IdleTimeEstimator::DidCommitFrameToCompositor() {
+  base::TimeTicks commit_time = time_source_->NowTicks();
+  if (!prev_commit_time_.is_null())
+    frame_length_.InsertSample(commit_time - prev_commit_time_);
+  prev_commit_time_ = commit_time;
+
+  // This will run inside of a WillProcessTask / DidProcessTask pair, let
+  // DidProcessTask know a frame was comitted.
+  did_commit_ = true;
+}
+
+void IdleTimeEstimator::Clear() {
+  task_start_time_ = base::TimeTicks();
+  prev_commit_time_ = base::TimeTicks();
+  cumulative_compositor_runtime_ = base::TimeDelta();
+  frame_length_.Clear();
+  per_frame_compositor_task_runtime_.Clear();
+  did_commit_ = false;
+
+  // Make sure that we don't initially assume there is no idle time.
+  frame_length_.InsertSample(cc::BeginFrameArgs::DefaultInterval());
+}
+
+void IdleTimeEstimator::SetTimeSourceForTesting(
+    scoped_ptr<base::TickClock> time_source) {
+  time_source_ = time_source.Pass();
+}
+
+void IdleTimeEstimator::WillProcessTask(const base::PendingTask& pending_task) {
+  task_start_time_ = time_source_->NowTicks();
+}
+
+void IdleTimeEstimator::DidProcessTask(const base::PendingTask& pending_task) {
+  cumulative_compositor_runtime_ += time_source_->NowTicks() - task_start_time_;
+
+  if (did_commit_) {
+    per_frame_compositor_task_runtime_.InsertSample(
+        cumulative_compositor_runtime_);
+    cumulative_compositor_runtime_ = base::TimeDelta();
+    did_commit_ = false;
+  }
+}
+
+}  // namespace scheduler