[scheduler] Monitor renderer load level.

third_party/WebKit/Source/platform/scheduler/base/thread_load_tracker.h

+// Copyright 2016 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.
+
+#ifndef THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_RENDERER_RENDERER_LOAD_TRACKER_H_
+#define THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_RENDERER_RENDERER_LOAD_TRACKER_H_
+
+#include "base/callback.h"
+#include "base/macros.h"
+#include "base/time/time.h"
+#include "public/platform/WebCommon.h"
+
+namespace blink {
+namespace scheduler {
+
+// This class tracks renderer load level, e.g. percentage of wall time spent

[alex clarke (OOO till 29th), 2016/08/22 16:13:13]

nit:  i.e. the percentage...

[altimin, 2016/08/22 17:02:22]

I meant that we also are going to track wakeups and other things :)

+// running tasks.
+// In order to avoid bias it reports load level at regular intervals.
+class BLINK_PLATFORM_EXPORT ThreadLoadTracker {
+ public:
+  // Callback is called with (current_time, load_level) parameters.
+  using Callback = base::Callback<void(base::TimeTicks, double)>;
+
+  ThreadLoadTracker(base::TimeTicks now, const Callback& callback);
+  ~ThreadLoadTracker();
+
+  void Pause(base::TimeTicks now);
+  void Resume(base::TimeTicks now);
+
+  void RecordTaskTime(base::TimeTicks start_time, base::TimeTicks end_time);
+
+  void RecordIdle(base::TimeTicks now);
+
+  // TODO(altimin): Count wakeups.
+
+ private:
+  enum class ThreadState {
+    ACTIVE, PAUSED
+  };
+
+  enum class TaskState {
+    TASK_RUNNING, IDLE
+  };
+
+  void Advance(base::TimeTicks now, TaskState task_state);

[alex clarke (OOO till 29th), 2016/08/22 16:13:13]

Please add a comment explaining what this does.  You should probably mention
that the Callback could be issued multiple times.

bike-shed: If there was a very long interval between calling Advance, the
callback might be issued many times (assuming I'm reading the code right). Are
we comfortable with that? If not should we change the Callback to specify how
long it's been it's been in the current state?

[altimin, 2016/08/22 17:02:22]

Comment added (also commented source in .cc file).

Yes, that was intentional to call callback multiple times here. We can't update
metrics based on tasks being run due to bias from task frequency (we will have
more data points when more tasks are run) and we can't post task to take metrics
every second due to obvious reasons (overhead, we do not want to wake up
renderer, etc). So here we're emulating callback being called every second, even
with delays.

base::TimeTicks parameter in callback helps to address this problem with delays.

+
+  double Load();
+
+  base::TimeTicks current_time_;

[alex clarke (OOO till 29th), 2016/08/22 16:13:13]

Nit: This can't actually be the current time since the moment it's recorded it's
out of date ;)

[altimin, 2016/08/22 17:02:22]

Done.

+  base::TimeTicks next_reporting_time_;
+
+  ThreadState thread_state_;
+  base::TimeTicks last_state_change_time_;
+
+  base::TimeDelta total_time_;
+  base::TimeDelta total_runtime_;
+
+  // Start reporting values after |waiting_period_|.
+  base::TimeDelta waiting_period_;
+  base::TimeDelta reporting_interval_;
+
+  Callback callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(ThreadLoadTracker);
+};
+
+}  // namespace scheduler
+}  // namespace blink
+
+#endif  // THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_RENDERER_RENDERER_LOAD_TRACKER_H_