[Blink-Scheduler] Distinguish between normal and foreground-only renderers for monitoring load.

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

 // Copyright 2014 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 "platform/scheduler/renderer/renderer_scheduler_impl.h"
 
 #include "base/bind.h"
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
@@ skipping 46 matching lines @@
 constexpr base::TimeDelta kMaxTaskDurationForReporting =
     base::TimeDelta::FromMinutes(1);
 
 void ReportForegroundRendererTaskLoad(base::TimeTicks time, double load) {
   if (!blink::RuntimeEnabledFeatures::timerThrottlingForBackgroundTabsEnabled())
     return;
 
   int load_percentage = static_cast<int>(load * 100);
   DCHECK_LE(load_percentage, 100);
 
-  UMA_HISTOGRAM_PERCENTAGE("RendererScheduler.ForegroundRendererMainThreadLoad",
-                           load_percentage);
+  UMA_HISTOGRAM_PERCENTAGE(
+      "RendererScheduler.ForegroundRendererMainThreadLoad2", load_percentage);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "RendererScheduler.ForegroundRendererLoad", load_percentage);
 }
 
 void ReportBackgroundRendererTaskLoad(base::TimeTicks time, double load) {
   if (!blink::RuntimeEnabledFeatures::timerThrottlingForBackgroundTabsEnabled())
     return;
 
   int load_percentage = static_cast<int>(load * 100);
   DCHECK_LE(load_percentage, 100);
 
   UMA_HISTOGRAM_PERCENTAGE("RendererScheduler.BackgroundRendererMainThreadLoad",
                            load_percentage);
   TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                  "RendererScheduler.BackgroundRendererLoad", load_percentage);
 }
 
+void ReportForegroundOnlyRendererTaskLoad(base::TimeTicks time, double load) {
+  if (!blink::RuntimeEnabledFeatures::timerThrottlingForBackgroundTabsEnabled())
+    return;
+
+  int load_percentage = static_cast<int>(load * 100);
+  DCHECK_LE(load_percentage, 100);
+
+  UMA_HISTOGRAM_PERCENTAGE(
+      "RendererScheduler.ForegroundOnlyRendererMainThreadLoad",
+      load_percentage);
+  TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
+                 "RendererScheduler.ForegroundOnlyRendererLoad",
+                 load_percentage);
+}
+
 }  // namespace
 
 RendererSchedulerImpl::RendererSchedulerImpl(
-    scoped_refptr<SchedulerTqmDelegate> main_task_runner)
+    scoped_refptr<SchedulerTqmDelegate> main_task_runner,
+    RendererType type)
     : helper_(main_task_runner),
       idle_helper_(&helper_,
                    this,
                    "RendererSchedulerIdlePeriod",
                    base::TimeDelta()),
       idle_canceled_delayed_task_sweeper_(&helper_,
                                           idle_helper_.IdleTaskRunner()),
       render_widget_scheduler_signals_(this),
       control_task_queue_(helper_.ControlTaskQueue()),
       compositor_task_queue_(
           helper_.NewTaskQueue(TaskQueue::Spec(TaskQueue::QueueType::COMPOSITOR)
                                    .SetShouldMonitorQuiescence(true))),
       compositor_task_queue_enabled_voter_(
           compositor_task_queue_->CreateQueueEnabledVoter()),
       delayed_update_policy_runner_(
           base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                      base::Unretained(this)),
           helper_.ControlTaskQueue()),
       seqlock_queueing_time_estimator_(
           QueueingTimeEstimator(this, kQueueingTimeWindowDuration, 20)),
+      type_(type),
       main_thread_only_(this,
                         compositor_task_queue_,
                         helper_.scheduler_tqm_delegate().get(),
-                        helper_.scheduler_tqm_delegate()->NowTicks()),
+                        helper_.scheduler_tqm_delegate()->NowTicks(),
+                        type),
       policy_may_need_update_(&any_thread_lock_),
       weak_factory_(this) {
   task_queue_throttler_.reset(new TaskQueueThrottler(this));
   update_policy_closure_ = base::Bind(&RendererSchedulerImpl::UpdatePolicy,
                                       weak_factory_.GetWeakPtr());
   end_renderer_hidden_idle_period_closure_.Reset(base::Bind(
       &RendererSchedulerImpl::EndIdlePeriod, weak_factory_.GetWeakPtr()));
 
   suspend_timers_when_backgrounded_closure_.Reset(
       base::Bind(&RendererSchedulerImpl::SuspendTimerQueueWhenBackgrounded,
@@ skipping 44 matching lines @@
   // Ensure the renderer scheduler was shut down explicitly, because otherwise
   // we could end up having stale pointers to the Blink heap which has been
   // terminated by this point.
   DCHECK(GetMainThreadOnly().was_shutdown);
 }
 
 RendererSchedulerImpl::MainThreadOnly::MainThreadOnly(
     RendererSchedulerImpl* renderer_scheduler_impl,
     const scoped_refptr<TaskQueue>& compositor_task_runner,
     base::TickClock* time_source,
-    base::TimeTicks now)
+    base::TimeTicks now,
+    RendererType type)
     : loading_task_cost_estimator(time_source,
                                   kLoadingTaskEstimationSampleCount,
                                   kLoadingTaskEstimationPercentile),
       timer_task_cost_estimator(time_source,
                                 kTimerTaskEstimationSampleCount,
                                 kTimerTaskEstimationPercentile),
       idle_time_estimator(compositor_task_runner,
                           time_source,
                           kShortIdlePeriodDurationSampleCount,
                           kShortIdlePeriodDurationPercentile),
-      background_main_thread_load_tracker(
-          now,
-          base::Bind(&ReportBackgroundRendererTaskLoad),
-          kThreadLoadTrackerReportingInterval,
-          kThreadLoadTrackerWaitingPeriodBeforeReporting),
-      foreground_main_thread_load_tracker(
-          now,
-          base::Bind(&ReportForegroundRendererTaskLoad),
-          kThreadLoadTrackerReportingInterval,
-          kThreadLoadTrackerWaitingPeriodBeforeReporting),
       current_use_case(UseCase::NONE),
       timer_queue_suspend_count(0),
       navigation_task_expected_count(0),
       expensive_task_policy(ExpensiveTaskPolicy::RUN),
       renderer_hidden(false),
       renderer_backgrounded(false),
       renderer_suspended(false),
       timer_queue_suspension_when_backgrounded_enabled(false),
       timer_queue_suspended_when_backgrounded(false),
       was_shutdown(false),
       loading_tasks_seem_expensive(false),
       timer_tasks_seem_expensive(false),
       touchstart_expected_soon(false),
       have_seen_a_begin_main_frame(false),
       have_reported_blocking_intervention_in_current_policy(false),
       have_reported_blocking_intervention_since_navigation(false),
       has_visible_render_widget_with_touch_handler(false),
       begin_frame_not_expected_soon(false),
       in_idle_period_for_testing(false),
       use_virtual_time(false),
       is_audio_playing(false),
       rail_mode_observer(nullptr),
       wake_up_budget_pool(nullptr),
       task_duration_per_queue_type_histogram(base::Histogram::FactoryGet(
           "RendererScheduler.TaskDurationPerQueueType",
           1,
           static_cast<int>(TaskQueue::QueueType::COUNT),
           static_cast<int>(TaskQueue::QueueType::COUNT) + 1,
           base::HistogramBase::kUmaTargetedHistogramFlag)) {
-  foreground_main_thread_load_tracker.Resume(now);
+  if (type == RendererType::kForegroundAndBackground) {
+    background_main_thread_load_tracker = base::MakeUnique<ThreadLoadTracker>(
+        now, base::Bind(&ReportBackgroundRendererTaskLoad),
+        kThreadLoadTrackerReportingInterval,
+        kThreadLoadTrackerWaitingPeriodBeforeReporting);
+    foreground_main_thread_load_tracker = base::MakeUnique<ThreadLoadTracker>(
+        now, base::Bind(&ReportForegroundRendererTaskLoad),
+        kThreadLoadTrackerReportingInterval,
+        kThreadLoadTrackerWaitingPeriodBeforeReporting);
+    foreground_main_thread_load_tracker->Resume(now);
+  } else {
+    foreground_only_main_thread_load_tracker =
+        base::MakeUnique<ThreadLoadTracker>(
+            now, base::Bind(&ReportForegroundOnlyRendererTaskLoad),
+            kThreadLoadTrackerReportingInterval,
+            kThreadLoadTrackerWaitingPeriodBeforeReporting);
+    foreground_only_main_thread_load_tracker->Resume(now);
+  }
 }
 
 RendererSchedulerImpl::MainThreadOnly::~MainThreadOnly() {}
 
 RendererSchedulerImpl::AnyThread::AnyThread()
     : awaiting_touch_start_response(false),
       in_idle_period(false),
       begin_main_frame_on_critical_path(false),
       last_gesture_was_compositor_driven(false),
       default_gesture_prevented(true),
       have_seen_touchstart(false),
       waiting_for_meaningful_paint(false),
       have_seen_input_since_navigation(false) {}
 
 RendererSchedulerImpl::AnyThread::~AnyThread() {}
 
 RendererSchedulerImpl::CompositorThreadOnly::CompositorThreadOnly()
     : last_input_type(blink::WebInputEvent::kUndefined),
       main_thread_seems_unresponsive(false) {}
 
 RendererSchedulerImpl::CompositorThreadOnly::~CompositorThreadOnly() {}
 
 void RendererSchedulerImpl::Shutdown() {
   base::TimeTicks now = tick_clock()->NowTicks();
-  GetMainThreadOnly().background_main_thread_load_tracker.RecordIdle(now);
-  GetMainThreadOnly().foreground_main_thread_load_tracker.RecordIdle(now);
+  if (type_ == RendererType::kForegroundAndBackground) {
+    GetMainThreadOnly().background_main_thread_load_tracker->RecordIdle(now);
+    GetMainThreadOnly().foreground_main_thread_load_tracker->RecordIdle(now);
+  } else {
+    GetMainThreadOnly().foreground_only_main_thread_load_tracker->RecordIdle(
+        now);
+  }
 
   task_queue_throttler_.reset();
   helper_.Shutdown();
   idle_helper_.Shutdown();
   GetMainThreadOnly().was_shutdown = true;
   GetMainThreadOnly().rail_mode_observer = nullptr;
 }
 
 std::unique_ptr<blink::WebThread> RendererSchedulerImpl::CreateMainThread() {
   return base::MakeUnique<WebThreadImplForRendererScheduler>(this);
@@ skipping 278 matching lines @@
   GetMainThreadOnly().has_visible_render_widget_with_touch_handler =
       has_visible_render_widget_with_touch_handler;
 
   base::AutoLock lock(any_thread_lock_);
   UpdatePolicyLocked(UpdateType::FORCE_UPDATE);
 }
 
 void RendererSchedulerImpl::OnRendererBackgrounded() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::OnRendererBackgrounded");
+  DCHECK_EQ(RendererType::kForegroundAndBackground, type_);
+
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown() || GetMainThreadOnly().renderer_backgrounded)
     return;
 
   GetMainThreadOnly().renderer_backgrounded = true;
 
   UpdatePolicy();
 
   base::TimeTicks now = tick_clock()->NowTicks();
-  GetMainThreadOnly().foreground_main_thread_load_tracker.Pause(now);
-  GetMainThreadOnly().background_main_thread_load_tracker.Resume(now);
+  GetMainThreadOnly().foreground_main_thread_load_tracker->Pause(now);
+  GetMainThreadOnly().background_main_thread_load_tracker->Resume(now);
 
   if (!GetMainThreadOnly().timer_queue_suspension_when_backgrounded_enabled)
     return;
 
   suspend_timers_when_backgrounded_closure_.Cancel();
   base::TimeDelta suspend_timers_when_backgrounded_delay =
       base::TimeDelta::FromMilliseconds(
           kSuspendTimersWhenBackgroundedDelayMillis);
   control_task_queue_->PostDelayedTask(
       FROM_HERE, suspend_timers_when_backgrounded_closure_.GetCallback(),
       suspend_timers_when_backgrounded_delay);
 }
 
 void RendererSchedulerImpl::OnRendererForegrounded() {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("renderer.scheduler"),
                "RendererSchedulerImpl::OnRendererForegrounded");
   helper_.CheckOnValidThread();
   if (helper_.IsShutdown() || !GetMainThreadOnly().renderer_backgrounded)
     return;
 
+  // A foreground-only renderer would not have been backgrounded.
+  DCHECK_EQ(RendererType::kForegroundAndBackground, type_);
+
   GetMainThreadOnly().renderer_backgrounded = false;
   GetMainThreadOnly().renderer_suspended = false;
 
   UpdatePolicy();
 
   base::TimeTicks now = tick_clock()->NowTicks();
-  GetMainThreadOnly().foreground_main_thread_load_tracker.Resume(now);
-  GetMainThreadOnly().background_main_thread_load_tracker.Pause(now);
+  GetMainThreadOnly().foreground_main_thread_load_tracker->Resume(now);
+  GetMainThreadOnly().background_main_thread_load_tracker->Pause(now);
 
   suspend_timers_when_backgrounded_closure_.Cancel();
   ResumeTimerQueueWhenForegroundedOrResumed();
 }
 
 void RendererSchedulerImpl::OnAudioStateChanged() {
   bool is_audio_playing = false;
   for (WebViewSchedulerImpl* web_view_scheduler :
        GetMainThreadOnly().web_view_schedulers) {
     is_audio_playing = is_audio_playing || web_view_scheduler->IsAudioPlaying();
@@ skipping 1227 matching lines @@
 
   seqlock_queueing_time_estimator_.seqlock.WriteBegin();
   seqlock_queueing_time_estimator_.data.OnTopLevelTaskCompleted(end_time_ticks);
   seqlock_queueing_time_estimator_.seqlock.WriteEnd();
 
   task_queue_throttler()->OnTaskRunTimeReported(task_queue, start_time_ticks,
                                                 end_time_ticks);
 
   // We want to measure thread time here, but for efficiency reasons
   // we stick with wall time.
-  GetMainThreadOnly().foreground_main_thread_load_tracker.RecordTaskTime(
-      start_time_ticks, end_time_ticks);
-  GetMainThreadOnly().background_main_thread_load_tracker.RecordTaskTime(
-      start_time_ticks, end_time_ticks);
+  if (type_ == RendererType::kForegroundAndBackground) {
+    GetMainThreadOnly().foreground_main_thread_load_tracker->RecordTaskTime(
+        start_time_ticks, end_time_ticks);
+    GetMainThreadOnly().background_main_thread_load_tracker->RecordTaskTime(
+        start_time_ticks, end_time_ticks);
+  } else {
+    GetMainThreadOnly()
+        .foreground_only_main_thread_load_tracker->RecordTaskTime(
+            start_time_ticks, end_time_ticks);
+  }
 
   // TODO(altimin): Per-page metrics should also be considered.
   RecordTaskMetrics(task_queue->GetQueueType(),
                     end_time_ticks - start_time_ticks);
 }
 
 void RendererSchedulerImpl::RecordTaskMetrics(TaskQueue::QueueType queue_type,
                                               base::TimeDelta duration) {
   UMA_HISTOGRAM_CUSTOM_COUNTS("RendererScheduler.TaskTime",
                               duration.InMicroseconds(), 1, 1000 * 1000, 50);
@@ skipping 194 matching lines @@
     case TimeDomainType::VIRTUAL:
       return "virtual";
     default:
       NOTREACHED();
       return nullptr;
   }
 }
 
 }  // namespace scheduler
 }  // namespace blink