[scheduler] Monitor renderer load level.

third_party/WebKit/Source/platform/scheduler/renderer/renderer_load_tracker.cc

+#include "platform/scheduler/renderer/renderer_load_tracker.h"
+
+namespace blink {
+namespace scheduler {
+
+namespace {
+
+const int kLoadReportingIntervalInMilliseconds = 1000;
+const int kWaitingPeriodBeforeReportingInSeconds = 10;
+
+}  // namespace
+
+RendererLoadTracker::RendererLoadTracker(base::TimeTicks now,
+                                         const Callback& callback)
+    : current_time_(now),
+      next_reporting_time_(now),
+      active_(true),
+      last_status_change_time_(now),
+      waiting_period_(
+          base::TimeDelta::FromSeconds(kWaitingPeriodBeforeReportingInSeconds)),
+      reporting_interval_(base::TimeDelta::FromMilliseconds(
+          kLoadReportingIntervalInMilliseconds)),
+      callback_(callback) {}
+
+RendererLoadTracker::~RendererLoadTracker() {}
+
+void RendererLoadTracker::Pause(base::TimeTicks now) {
+  Advance(now, true, false);
+  active_ = false;
+  last_status_change_time_ = now;
+}
+
+void RendererLoadTracker::Resume(base::TimeTicks now) {
+  Advance(now, false, false);
+  active_ = true;
+  last_status_change_time_ = now;
+}
+
+void RendererLoadTracker::RecordTaskTime(base::TimeTicks start_time,
+                                         base::TimeTicks end_time) {
+  start_time = std::max(last_status_change_time_, start_time);
+  end_time = std::max(last_status_change_time_, end_time);
+
+  Advance(start_time, active_, false);
+  Advance(end_time, active_, true);
+}
+
+void RendererLoadTracker::RecordIdle(base::TimeTicks now) {
+  Advance(now, active_, false);
+}
+
+void RendererLoadTracker::Advance(base::TimeTicks now,
+                                  bool is_active,

[Sami, 2016/08/22 14:33:16]

nit: The call sites would be a bit easier to read if these were enums.

[altimin, 2016/08/22 15:36:23]

Done.

+                                  bool is_task_running) {
+  if (current_time_ > now) {
+    return;
+  }
+
+  while (true) {
+    base::TimeTicks next_current_time = std::min(next_reporting_time_, now);
+
+    base::TimeDelta delta = next_current_time - current_time_;
+
+    if (is_active) {
+      total_time_ += delta;
+      if (is_task_running) {
+        total_runtime_ += delta;
+      }
+    }
+    current_time_ = next_current_time;
+
+    if (current_time_ == next_reporting_time_) {
+      if (is_active && total_time_ >= waiting_period_) {
+        callback_.Run(current_time_, Load());
+      }
+      next_reporting_time_ += reporting_interval_;
+    } else {
+      break;
+    }
+  }
+}
+
+double RendererLoadTracker::Load() {
+  if (total_time_.is_zero()) {
+    return 0;
+  }
+  return total_runtime_.InSecondsF() / total_time_.InSecondsF();
+}
+
+}  // namespace scheduler
+}  // namespace blink