[scheduler] Monitor renderer load level.

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

Index: third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc
diff --git a/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc b/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc
index 9c5e33a261fef355db3ff3399cc626aa9141ce70..1f628cdfb0b20ad6db29dea897290f210ceeb4eb 100644
--- a/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc
+++ b/third_party/WebKit/Source/platform/scheduler/renderer/renderer_scheduler_impl.cc
@@ -36,6 +36,17 @@ const double kShortIdlePeriodDurationPercentile = 50;
 // Amount of idle time left in a frame (as a ratio of the vsync interval) above
 // which main thread compositing can be considered fast.
 const double kFastCompositingIdleTimeThreshold = .2;
+
+void ReportForegroundRendererTaskLoad(base::TimeTicks time, double load) {
+  UMA_HISTOGRAM_PERCENTAGE("RendererScheduler.ForegroundRendererLoad",

[Sami, 2016/08/22 16:35:40]

Please consider adding a disabled-by-default trace counter for this too -- makes
it easier to debug things later.

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

Done, thanks!

+                           static_cast<int>(load * 100));
+}
+
+void ReportBackgroundRendererTaskLoad(base::TimeTicks time, double load) {
+  UMA_HISTOGRAM_PERCENTAGE("RendererScheduler.BackgroundRendererLoad",
+                           static_cast<int>(load * 100));
+}
+
 }  // namespace
 
 RendererSchedulerImpl::RendererSchedulerImpl(
@@ -60,7 +71,8 @@ RendererSchedulerImpl::RendererSchedulerImpl(
           helper_.ControlTaskRunner()),
       main_thread_only_(this,
                         compositor_task_runner_,
-                        helper_.scheduler_tqm_delegate().get()),
+                        helper_.scheduler_tqm_delegate().get(),
+                        helper_.scheduler_tqm_delegate()->NowTicks()),
       policy_may_need_update_(&any_thread_lock_),
       weak_factory_(this) {
   throttling_helper_.reset(new ThrottlingHelper(this, "renderer.scheduler"));
@@ -110,7 +122,8 @@ RendererSchedulerImpl::~RendererSchedulerImpl() {
 RendererSchedulerImpl::MainThreadOnly::MainThreadOnly(
     RendererSchedulerImpl* renderer_scheduler_impl,
     const scoped_refptr<TaskQueue>& compositor_task_runner,
-    base::TickClock* time_source)
+    base::TickClock* time_source,
+    base::TimeTicks now)
     : loading_task_cost_estimator(time_source,
                                   kLoadingTaskEstimationSampleCount,
                                   kLoadingTaskEstimationPercentile),
@@ -123,6 +136,12 @@ RendererSchedulerImpl::MainThreadOnly::MainThreadOnly(
                           time_source,
                           kShortIdlePeriodDurationSampleCount,
                           kShortIdlePeriodDurationPercentile),
+      background_main_thread_load_tracker(
+          now,
+          base::Bind(&ReportBackgroundRendererTaskLoad)),
+      foreground_main_thread_load_tracker(
+          now,
+          base::Bind(&ReportForegroundRendererTaskLoad)),
       current_use_case(UseCase::NONE),
       timer_queue_suspend_count(0),
       navigation_task_expected_count(0),
@@ -163,6 +182,10 @@ RendererSchedulerImpl::CompositorThreadOnly::CompositorThreadOnly()
 RendererSchedulerImpl::CompositorThreadOnly::~CompositorThreadOnly() {}
 
 void RendererSchedulerImpl::Shutdown() {
+  base::TimeTicks now = tick_clock()->NowTicks();
+  MainThreadOnly().background_main_thread_load_tracker.RecordIdle(now);
+  MainThreadOnly().foreground_main_thread_load_tracker.RecordIdle(now);
+
   throttling_helper_.reset();
   helper_.Shutdown();
   MainThreadOnly().was_shutdown = true;
@@ -405,6 +428,11 @@ void RendererSchedulerImpl::OnRendererBackgrounded() {
     return;
 
   MainThreadOnly().renderer_backgrounded = true;
+
+  base::TimeTicks now = tick_clock()->NowTicks();
+  MainThreadOnly().foreground_main_thread_load_tracker.Pause(now);
+  MainThreadOnly().background_main_thread_load_tracker.Resume(now);
+
   if (!MainThreadOnly().timer_queue_suspension_when_backgrounded_enabled)
     return;
 
@@ -426,6 +454,11 @@ void RendererSchedulerImpl::OnRendererForegrounded() {
 
   MainThreadOnly().renderer_backgrounded = false;
   MainThreadOnly().renderer_suspended = false;
+
+  base::TimeTicks now = tick_clock()->NowTicks();
+  MainThreadOnly().foreground_main_thread_load_tracker.Resume(now);
+  MainThreadOnly().background_main_thread_load_tracker.Pause(now);
+
   suspend_timers_when_backgrounded_closure_.Cancel();
   ResumeTimerQueueWhenForegrounded();
 }
@@ -1413,6 +1446,12 @@ void RendererSchedulerImpl::ReportTaskTime(base::TimeTicks start_time,
                                                                    end_time);
   MainThreadOnly().long_task_tracker.RecordLongTask(
       start_time, end_time - start_time);
+  // We want to measure thread time here, but for efficiency reasons
+  // we stick with wall time.
+  MainThreadOnly().foreground_main_thread_load_tracker.RecordTaskTime(
+      start_time, end_time);
+  MainThreadOnly().background_main_thread_load_tracker.RecordTaskTime(
+      start_time, end_time);
   UMA_HISTOGRAM_CUSTOM_COUNTS("RendererScheduler.TaskTime",
                               (end_time - start_time).InMicroseconds(), 1,
                               1000000, 50);