[scheduler] Add per-thread task duration UMA.

Previously, we have extensive metric coverage and understanding of types of
work being run on the renderer main thread. Our understanding of work being
done on other renderer threads, however, is very limited. This patch:

1. Moved TaskDurationMetricReporter to util/ so that it can be shared by
child/;
2. Added OnTaskCompleted API in WorkerScheduler and implemented it in
WorkerSchedulerImpl and CompositorScheduler;
3. Report per-thread task duration for main thread, worker thread and
compositor thread.

BUG=788744

Change-Id: Ida597ccb90ff42129fd786f95f0d9810a5d5b745
Reviewed-on: https://chromium-review.googlesource.com/795014Reviewed-by: Steven Holte <holte@chromium.org>
Reviewed-by: Alexander Timin <altimin@chromium.org>
Commit-Queue: lpy <lpy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#520368}

third_party/WebKit/Source/platform/scheduler/BUILD.gn

@@ -97,7 +97,6 @@ jumbo_source_set("scheduler") {
     "renderer/scoped_virtual_time_pauser.cc",
     "renderer/task_cost_estimator.cc",
     "renderer/task_cost_estimator.h",
-    "renderer/task_duration_metric_reporter.h",
     "renderer/task_queue_throttler.cc",
     "renderer/task_queue_throttler.h",
     "renderer/throttled_time_domain.cc",
@@ -113,8 +112,10 @@ jumbo_source_set("scheduler") {
     "renderer/web_view_scheduler_impl.h",
     "renderer/webthread_impl_for_renderer_scheduler.cc",
     "renderer/webthread_impl_for_renderer_scheduler.h",
+    "util/task_duration_metric_reporter.h",
     "util/thread_load_tracker.cc",
     "util/thread_load_tracker.h",
+    "util/thread_type.h",
     "util/tracing_helper.cc",
     "util/tracing_helper.h",
     "utility/webthread_impl_for_utility_thread.cc",
@@ -192,12 +193,12 @@ jumbo_source_set("unit_tests") {
     "renderer/renderer_metrics_helper_unittest.cc",
     "renderer/renderer_scheduler_impl_unittest.cc",
     "renderer/task_cost_estimator_unittest.cc",
-    "renderer/task_duration_metric_reporter_unittest.cc",
     "renderer/task_queue_throttler_unittest.cc",
     "renderer/user_model_unittest.cc",
     "renderer/web_frame_scheduler_impl_unittest.cc",
     "renderer/web_view_scheduler_impl_unittest.cc",
     "renderer/webthread_impl_for_renderer_scheduler_unittest.cc",
+    "util/task_duration_metric_reporter_unittest.cc",
     "util/thread_load_tracker_unittest.cc",
     "util/tracing_helper_unittest.cc",
   ]

third_party/WebKit/Source/platform/scheduler/child/compositor_worker_scheduler.cc

@@ -19,17 +19,31 @@ namespace scheduler {
 
 CompositorWorkerScheduler::CompositorWorkerScheduler(
     base::Thread* thread,
-    std::unique_ptr<WorkerSchedulerHelper> scheduler_helper)
-    : WorkerScheduler(std::move(scheduler_helper)), thread_(thread) {}
+    std::unique_ptr<TaskQueueManager> task_queue_manager)
+    : WorkerScheduler(
+          std::make_unique<WorkerSchedulerHelper>(std::move(task_queue_manager),
+                                                  this)),
+      thread_(thread),
+      compositor_thread_task_duration_reporter_(
+          "RendererScheduler.TaskDurationPerThreadType") {}
 
 CompositorWorkerScheduler::~CompositorWorkerScheduler() {}
 
-void CompositorWorkerScheduler::Init() {}
-
 scoped_refptr<WorkerTaskQueue> CompositorWorkerScheduler::DefaultTaskQueue() {
   return helper_->DefaultWorkerTaskQueue();
 }
 
+void CompositorWorkerScheduler::Init() {}
+
+void CompositorWorkerScheduler::OnTaskCompleted(
+    WorkerTaskQueue* worker_task_queue,
+    const TaskQueue::Task& task,
+    base::TimeTicks start,
+    base::TimeTicks end) {
+  compositor_thread_task_duration_reporter_.RecordTask(
+      ThreadType::kCompositorThread, end - start);
+}
+
 scoped_refptr<base::SingleThreadTaskRunner>
 CompositorWorkerScheduler::DefaultTaskRunner() {
   return DefaultTaskQueue();

third_party/WebKit/Source/platform/scheduler/child/compositor_worker_scheduler.h

@@ -10,6 +10,8 @@
 #include "base/single_thread_task_runner.h"
 #include "platform/PlatformExport.h"
 #include "platform/scheduler/child/worker_scheduler.h"
+#include "platform/scheduler/util/task_duration_metric_reporter.h"
+#include "platform/scheduler/util/thread_type.h"
 #include "public/platform/scheduler/child/single_thread_idle_task_runner.h"
 
 namespace base {
@@ -19,20 +21,23 @@ class Thread;
 namespace blink {
 namespace scheduler {
 
-class WorkerSchedulerHelper;
-
 class PLATFORM_EXPORT CompositorWorkerScheduler
     : public WorkerScheduler,
       public SingleThreadIdleTaskRunner::Delegate {
  public:
   CompositorWorkerScheduler(
       base::Thread* thread,
-      std::unique_ptr<WorkerSchedulerHelper> scheduler_helper);
+      std::unique_ptr<TaskQueueManager> task_queue_manager);
+
   ~CompositorWorkerScheduler() override;
 
   // WorkerScheduler:
-  void Init() override;
   scoped_refptr<WorkerTaskQueue> DefaultTaskQueue() override;
+  void Init() override;
+  void OnTaskCompleted(WorkerTaskQueue* worker_task_queue,
+                       const TaskQueue::Task& task,
+                       base::TimeTicks start,
+                       base::TimeTicks end) override;
 
   // ChildScheduler:
   scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner() override;
@@ -54,6 +59,8 @@ class PLATFORM_EXPORT CompositorWorkerScheduler
 
  private:
   base::Thread* thread_;
+  TaskDurationMetricReporter<ThreadType>
+      compositor_thread_task_duration_reporter_;
 
   DISALLOW_COPY_AND_ASSIGN(CompositorWorkerScheduler);
 };

third_party/WebKit/Source/platform/scheduler/child/idle_helper_unittest.cc

@@ -203,7 +203,8 @@ class BaseIdleHelperTest : public ::testing::Test {
             CreateTaskQueueManagerWithUnownedClockForTest(
                 message_loop,
                 message_loop ? message_loop->task_runner() : mock_task_runner_,
-                clock_.get()))),
+                clock_.get()),
+            nullptr)),
         idle_helper_(new IdleHelperForTest(
             scheduler_helper_.get(),
             required_quiescence_duration_before_long_idle_period,

third_party/WebKit/Source/platform/scheduler/child/scheduler_helper_unittest.cc

@@ -57,7 +57,8 @@ class SchedulerHelperTest : public ::testing::Test {
         scheduler_helper_(new WorkerSchedulerHelper(
             CreateTaskQueueManagerWithUnownedClockForTest(nullptr,
                                                           mock_task_runner_,
-                                                          clock_.get()))),
+                                                          clock_.get()),
+            nullptr)),
         default_task_runner_(scheduler_helper_->DefaultWorkerTaskQueue()) {
     clock_->Advance(base::TimeDelta::FromMicroseconds(5000));
   }

third_party/WebKit/Source/platform/scheduler/child/webthread_base.cc

@@ -119,8 +119,7 @@ class WebThreadForCompositor : public WebThreadImplForWorkerScheduler {
   std::unique_ptr<blink::scheduler::WorkerScheduler> CreateWorkerScheduler()
       override {
     return std::make_unique<CompositorWorkerScheduler>(
-        GetThread(), std::make_unique<WorkerSchedulerHelper>(
-                         TaskQueueManager::TakeOverCurrentThread()));
+        GetThread(), TaskQueueManager::TakeOverCurrentThread());
   }
 
   DISALLOW_COPY_AND_ASSIGN(WebThreadForCompositor);

third_party/WebKit/Source/platform/scheduler/child/worker_scheduler.h

@@ -33,6 +33,11 @@ class PLATFORM_EXPORT WorkerScheduler : public ChildScheduler {
   // initialization needed such as initializing idle period detection.
   virtual void Init() = 0;
 
+  virtual void OnTaskCompleted(WorkerTaskQueue* worker_task_queue,
+                               const TaskQueue::Task& task,
+                               base::TimeTicks start,
+                               base::TimeTicks end) = 0;
+
   scoped_refptr<WorkerTaskQueue> CreateTaskRunner();
 
  protected:

third_party/WebKit/Source/platform/scheduler/child/worker_scheduler_helper.cc

@@ -10,8 +10,10 @@ namespace blink {
 namespace scheduler {
 
 WorkerSchedulerHelper::WorkerSchedulerHelper(
-    std::unique_ptr<TaskQueueManager> manager)
-    : SchedulerHelper(std::move(manager)),
+    std::unique_ptr<TaskQueueManager> task_queue_manager,
+    WorkerScheduler* worker_scheduler)
+    : SchedulerHelper(std::move(task_queue_manager)),
+      worker_scheduler_(worker_scheduler),
       default_task_queue_(NewTaskQueue(TaskQueue::Spec("worker_default_tq")
                                            .SetShouldMonitorQuiescence(true))),
       control_task_queue_(NewTaskQueue(TaskQueue::Spec("worker_control_tq")
@@ -42,7 +44,8 @@ scoped_refptr<TaskQueue> WorkerSchedulerHelper::ControlTaskQueue() {
 
 scoped_refptr<WorkerTaskQueue> WorkerSchedulerHelper::NewTaskQueue(
     const TaskQueue::Spec& spec) {
-  return task_queue_manager_->CreateTaskQueue<WorkerTaskQueue>(spec);
+  return task_queue_manager_->CreateTaskQueue<WorkerTaskQueue>(
+      spec, worker_scheduler_);
 }
 
 }  // namespace scheduler

third_party/WebKit/Source/platform/scheduler/child/worker_scheduler_helper.h

@@ -12,9 +12,12 @@
 namespace blink {
 namespace scheduler {
 
+class WorkerScheduler;
+
 class PLATFORM_EXPORT WorkerSchedulerHelper : public SchedulerHelper {
  public:
-  explicit WorkerSchedulerHelper(std::unique_ptr<TaskQueueManager> manager);
+  WorkerSchedulerHelper(std::unique_ptr<TaskQueueManager> manager,
+                        WorkerScheduler* worker_scheduler);
   ~WorkerSchedulerHelper() override;
 
   scoped_refptr<WorkerTaskQueue> NewTaskQueue(const TaskQueue::Spec& spec);
@@ -26,7 +29,8 @@ class PLATFORM_EXPORT WorkerSchedulerHelper : public SchedulerHelper {
   scoped_refptr<TaskQueue> DefaultTaskQueue() override;
   scoped_refptr<TaskQueue> ControlTaskQueue() override;
 
- protected:
+ private:
+  WorkerScheduler* worker_scheduler_;  // NOT OWNED
   const scoped_refptr<WorkerTaskQueue> default_task_queue_;
   const scoped_refptr<WorkerTaskQueue> control_task_queue_;
 

third_party/WebKit/Source/platform/scheduler/child/worker_scheduler_impl.cc

@@ -45,8 +45,9 @@ base::TimeTicks MonotonicTimeInSecondsToTimeTicks(
 
 WorkerSchedulerImpl::WorkerSchedulerImpl(
     std::unique_ptr<TaskQueueManager> task_queue_manager)
-    : WorkerScheduler(std::make_unique<WorkerSchedulerHelper>(
-          std::move(task_queue_manager))),
+    : WorkerScheduler(
+          std::make_unique<WorkerSchedulerHelper>(std::move(task_queue_manager),
+                                                  this)),
       idle_helper_(helper_.get(),
                    this,
                    "WorkerSchedulerIdlePeriod",
@@ -56,7 +57,9 @@ WorkerSchedulerImpl::WorkerSchedulerImpl(
                                           idle_helper_.IdleTaskRunner()),
       load_tracker_(helper_->NowTicks(),
                     base::Bind(&ReportWorkerTaskLoad),
-                    kWorkerThreadLoadTrackerReportingInterval) {
+                    kWorkerThreadLoadTrackerReportingInterval),
+      worker_thread_task_duration_reporter_(
+          "RendererScheduler.TaskDurationPerThreadType") {
   initialized_ = false;
   thread_start_time_ = helper_->NowTicks();
   load_tracker_.Resume(thread_start_time_);
@@ -71,22 +74,12 @@ WorkerSchedulerImpl::~WorkerSchedulerImpl() {
   helper_->RemoveTaskTimeObserver(this);
 }
 
-void WorkerSchedulerImpl::Init() {
-  initialized_ = true;
-  idle_helper_.EnableLongIdlePeriod();
-}
-
 scoped_refptr<base::SingleThreadTaskRunner>
 WorkerSchedulerImpl::DefaultTaskRunner() {
   DCHECK(initialized_);
   return helper_->DefaultWorkerTaskQueue();
 }
 
-scoped_refptr<WorkerTaskQueue> WorkerSchedulerImpl::DefaultTaskQueue() {
-  DCHECK(initialized_);
-  return helper_->DefaultWorkerTaskQueue();
-}
-
 scoped_refptr<SingleThreadIdleTaskRunner>
 WorkerSchedulerImpl::IdleTaskRunner() {
   DCHECK(initialized_);
@@ -135,6 +128,24 @@ void WorkerSchedulerImpl::Shutdown() {
   helper_->Shutdown();
 }
 
+scoped_refptr<WorkerTaskQueue> WorkerSchedulerImpl::DefaultTaskQueue() {
+  DCHECK(initialized_);
+  return helper_->DefaultWorkerTaskQueue();
+}
+
+void WorkerSchedulerImpl::Init() {
+  initialized_ = true;
+  idle_helper_.EnableLongIdlePeriod();
+}
+
+void WorkerSchedulerImpl::OnTaskCompleted(WorkerTaskQueue* worker_task_queue,
+                                          const TaskQueue::Task& task,
+                                          base::TimeTicks start,
+                                          base::TimeTicks end) {
+  worker_thread_task_duration_reporter_.RecordTask(ThreadType::kWorkerThread,
+                                                   end - start);
+}
+
 SchedulerHelper* WorkerSchedulerImpl::GetSchedulerHelperForTesting() {
   return helper_.get();
 }

third_party/WebKit/Source/platform/scheduler/child/worker_scheduler_impl.h

@@ -12,7 +12,9 @@
 #include "platform/scheduler/child/idle_canceled_delayed_task_sweeper.h"
 #include "platform/scheduler/child/idle_helper.h"
 #include "platform/scheduler/child/worker_scheduler.h"
+#include "platform/scheduler/util/task_duration_metric_reporter.h"
 #include "platform/scheduler/util/thread_load_tracker.h"
+#include "platform/scheduler/util/thread_type.h"
 
 namespace blink {
 namespace scheduler {
@@ -27,19 +29,25 @@ class PLATFORM_EXPORT WorkerSchedulerImpl : public WorkerScheduler,
       std::unique_ptr<TaskQueueManager> task_queue_manager);
   ~WorkerSchedulerImpl() override;
 
-  // WorkerScheduler implementation:
+  // ChildScheduler implementation:
   scoped_refptr<base::SingleThreadTaskRunner> DefaultTaskRunner() override;
-  scoped_refptr<WorkerTaskQueue> DefaultTaskQueue() override;
   scoped_refptr<SingleThreadIdleTaskRunner> IdleTaskRunner() override;
   scoped_refptr<base::SingleThreadTaskRunner> IPCTaskRunner() override;
-  bool CanExceedIdleDeadlineIfRequired() const override;
   bool ShouldYieldForHighPriorityWork() override;
+  bool CanExceedIdleDeadlineIfRequired() const override;
   void AddTaskObserver(base::MessageLoop::TaskObserver* task_observer) override;
   void RemoveTaskObserver(
       base::MessageLoop::TaskObserver* task_observer) override;
-  void Init() override;
   void Shutdown() override;
 
+  // WorkerScheduler implementation:
+  scoped_refptr<WorkerTaskQueue> DefaultTaskQueue() override;
+  void Init() override;
+  void OnTaskCompleted(WorkerTaskQueue* worker_task_queue,
+                       const TaskQueue::Task& task,
+                       base::TimeTicks start,
+                       base::TimeTicks end) override;
+
   // TaskTimeObserver implementation:
   void WillProcessTask(double start_time) override;
   void DidProcessTask(double start_time, double end_time) override;
@@ -65,6 +73,7 @@ class PLATFORM_EXPORT WorkerSchedulerImpl : public WorkerScheduler,
   ThreadLoadTracker load_tracker_;
   bool initialized_;
   base::TimeTicks thread_start_time_;
+  TaskDurationMetricReporter<ThreadType> worker_thread_task_duration_reporter_;
 
   DISALLOW_COPY_AND_ASSIGN(WorkerSchedulerImpl);
 };

third_party/WebKit/Source/platform/scheduler/child/worker_task_queue.cc

@@ -5,15 +5,31 @@
 #include "platform/scheduler/child/worker_task_queue.h"
 
 #include "platform/scheduler/base/task_queue_impl.h"
+#include "platform/scheduler/child/worker_scheduler.h"
 
 namespace blink {
 namespace scheduler {
 
 WorkerTaskQueue::WorkerTaskQueue(std::unique_ptr<internal::TaskQueueImpl> impl,
-                                 const TaskQueue::Spec& spec)
-    : TaskQueue(std::move(impl), spec) {}
+                                 const TaskQueue::Spec& spec,
+                                 WorkerScheduler* worker_scheduler)
+    : TaskQueue(std::move(impl), spec), worker_scheduler_(worker_scheduler) {
+  if (GetTaskQueueImpl()) {
+    // TaskQueueImpl may be null for tests.
+    GetTaskQueueImpl()->SetOnTaskCompletedHandler(
+        base::Bind(&WorkerTaskQueue::OnTaskCompleted, base::Unretained(this)));
+  }
+}
 
 WorkerTaskQueue::~WorkerTaskQueue() {}
 
+void WorkerTaskQueue::OnTaskCompleted(const TaskQueue::Task& task,
+                                      base::TimeTicks start,
+                                      base::TimeTicks end) {
+  // |worker_scheduler_| can be nullptr in tests.
+  if (worker_scheduler_)
+    worker_scheduler_->OnTaskCompleted(this, task, start, end);
+}
+
 }  // namespace scheduler
 }  // namespace blink

third_party/WebKit/Source/platform/scheduler/child/worker_task_queue.h

@@ -10,11 +10,22 @@
 namespace blink {
 namespace scheduler {
 
+class WorkerScheduler;
+
 class PLATFORM_EXPORT WorkerTaskQueue : public TaskQueue {
  public:
   WorkerTaskQueue(std::unique_ptr<internal::TaskQueueImpl> impl,
-                  const Spec& spec);
+                  const Spec& spec,
+                  WorkerScheduler* worker_scheduler);
   ~WorkerTaskQueue() override;
+
+  void OnTaskCompleted(const TaskQueue::Task& task,
+                       base::TimeTicks start,
+                       base::TimeTicks end);
+
+ private:
+  // Not owned.
+  WorkerScheduler* worker_scheduler_;
 };
 
 }  // namespace scheduler

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

@@ -36,7 +36,8 @@ class AutoAdvancingVirtualTimeDomainTest : public ::testing::Test {
 
     scheduler_helper_.reset(
         new WorkerSchedulerHelper(CreateTaskQueueManagerWithUnownedClockForTest(
-            nullptr, mock_task_runner_, clock_.get())));
+                                      nullptr, mock_task_runner_, clock_.get()),
+                                  nullptr));
 
     scheduler_helper_->AddTaskTimeObserver(&test_task_time_observer_);
     task_queue_ = scheduler_helper_->DefaultWorkerTaskQueue();

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

@@ -166,6 +166,8 @@ RendererMetricsHelper::RendererMetricsHelper(
           DURATION_PER_QUEUE_TYPE_METRIC_NAME ".HiddenMusic"),
       per_frame_type_duration_reporter(DURATION_PER_FRAME_TYPE_METRIC_NAME),
       per_task_type_duration_reporter(DURATION_PER_TASK_TYPE_METRIC_NAME),
+      main_thread_task_duration_reporter(
+          "RendererScheduler.TaskDurationPerThreadType"),
       main_thread_task_load_state(MainThreadTaskLoadState::kUnknown) {
   main_thread_load_tracker.Resume(now);
   if (renderer_backgrounded) {
@@ -270,6 +272,8 @@ void RendererMetricsHelper::RecordTaskMetrics(MainThreadTaskQueue* queue,
                               MainThreadTaskQueue::QueueType::kCount);
   }
 
+  main_thread_task_duration_reporter.RecordTask(ThreadType::kMainThread,
+                                                duration);
   per_queue_type_task_duration_reporter.RecordTask(queue_type, duration);
 
   if (renderer_scheduler_->main_thread_only().renderer_backgrounded) {

third_party/WebKit/Source/platform/scheduler/renderer/renderer_metrics_helper.h

@@ -10,8 +10,9 @@
 #include "base/time/time.h"
 #include "platform/PlatformExport.h"
 #include "platform/scheduler/renderer/main_thread_task_queue.h"
-#include "platform/scheduler/renderer/task_duration_metric_reporter.h"
+#include "platform/scheduler/util/task_duration_metric_reporter.h"
 #include "platform/scheduler/util/thread_load_tracker.h"
+#include "platform/scheduler/util/thread_type.h"
 
 namespace blink {
 
@@ -182,6 +183,8 @@ class PLATFORM_EXPORT RendererMetricsHelper {
       TaskDurationMetricReporter<TaskType>;
   TaskDurationPerTaskTypeMetricReporter per_task_type_duration_reporter;
 
+  TaskDurationMetricReporter<ThreadType> main_thread_task_duration_reporter;
+
   MainThreadTaskLoadState main_thread_task_load_state;
 
   DISALLOW_COPY_AND_ASSIGN(RendererMetricsHelper);

third_party/WebKit/Source/platform/scheduler/renderer/task_duration_metric_reporter.h → third_party/WebKit/Source/platform/scheduler/util/task_duration_metric_reporter.h

@@ -2,8 +2,8 @@
 // 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_TASK_DURATION_METRIC_REPORTER_H_
-#define THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_RENDERER_TASK_DURATION_METRIC_REPORTER_H_
+#ifndef THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_UTIL_TASK_DURATION_METRIC_REPORTER_H_
+#define THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_UTIL_TASK_DURATION_METRIC_REPORTER_H_
 
 #include <array>
 
@@ -12,7 +12,6 @@
 #include "base/metrics/histogram.h"
 #include "base/time/time.h"
 #include "platform/PlatformExport.h"
-#include "platform/scheduler/renderer/main_thread_task_queue.h"
 
 namespace base {
 class HistogramBase;
@@ -21,7 +20,7 @@ class HistogramBase;
 namespace blink {
 namespace scheduler {
 
-// A helper class to report task duration split by queue type.
+// A helper class to report task duration split by a specific type.
 // Aggregates small tasks internally and reports only whole milliseconds.
 //
 // |TaskClass| is an enum which should have COUNT field.
@@ -49,7 +48,7 @@ class PLATFORM_EXPORT TaskDurationMetricReporter {
     int64_t milliseconds = unreported_duration.InMilliseconds();
     if (milliseconds > 0) {
       unreported_duration -= base::TimeDelta::FromMilliseconds(milliseconds);
-      task_duration_per_queue_type_histogram_->AddCount(
+      task_duration_per_type_histogram_->AddCount(
           static_cast<int>(task_class), static_cast<int>(milliseconds));
     }
   }
@@ -58,11 +57,11 @@ class PLATFORM_EXPORT TaskDurationMetricReporter {
   FRIEND_TEST_ALL_PREFIXES(TaskDurationMetricReporterTest, Test);
 
   TaskDurationMetricReporter(base::HistogramBase* histogram)
-      : task_duration_per_queue_type_histogram_(histogram) {}
+      : task_duration_per_type_histogram_(histogram) {}
 
   std::array<base::TimeDelta, static_cast<size_t>(TaskClass::kCount)>
       unreported_task_duration_;
-  base::HistogramBase* task_duration_per_queue_type_histogram_;
+  base::HistogramBase* task_duration_per_type_histogram_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskDurationMetricReporter);
 };
@@ -70,4 +69,4 @@ class PLATFORM_EXPORT TaskDurationMetricReporter {
 }  // namespace scheduler
 }  // namespace blink
 
-#endif  // THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_RENDERER_TASK_DURATION_METRIC_REPORTER_H_
+#endif  // THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_UTIL_TASK_DURATION_METRIC_REPORTER_H_

third_party/WebKit/Source/platform/scheduler/renderer/task_duration_metric_reporter_unittest.cc → third_party/WebKit/Source/platform/scheduler/util/task_duration_metric_reporter_unittest.cc

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "platform/scheduler/renderer/task_duration_metric_reporter.h"
+#include "platform/scheduler/util/task_duration_metric_reporter.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_base.h"
@@ -49,31 +49,37 @@ class FakeHistogram : public base::HistogramBase {
                           base::ListValue*));
 };
 
+enum class FakeTaskQueueType {
+  kFakeType0 = 0,
+  kFakeType1 = 1,
+  kFakeType2 = 2,
+  kCount = 3
+};
+
 }  // namespace
 
 TEST(TaskDurationMetricReporterTest, Test) {
   FakeHistogram histogram;
 
-  TaskDurationMetricReporter<MainThreadTaskQueue::QueueType> metric_reporter(
-      &histogram);
+  TaskDurationMetricReporter<FakeTaskQueueType> metric_reporter(&histogram);
 
   EXPECT_CALL(histogram, AddCount(2, 3));
-  metric_reporter.RecordTask(static_cast<MainThreadTaskQueue::QueueType>(2),
+  metric_reporter.RecordTask(static_cast<FakeTaskQueueType>(2),
                              base::TimeDelta::FromMicroseconds(3400));
   Mock::VerifyAndClearExpectations(&histogram);
 
   EXPECT_CALL(histogram, AddCount(_, _)).Times(0);
-  metric_reporter.RecordTask(static_cast<MainThreadTaskQueue::QueueType>(2),
+  metric_reporter.RecordTask(static_cast<FakeTaskQueueType>(2),
                              base::TimeDelta::FromMicroseconds(300));
   Mock::VerifyAndClearExpectations(&histogram);
 
   EXPECT_CALL(histogram, AddCount(2, 1));
-  metric_reporter.RecordTask(static_cast<MainThreadTaskQueue::QueueType>(2),
+  metric_reporter.RecordTask(static_cast<FakeTaskQueueType>(2),
                              base::TimeDelta::FromMicroseconds(800));
   Mock::VerifyAndClearExpectations(&histogram);
 
   EXPECT_CALL(histogram, AddCount(2, 16));
-  metric_reporter.RecordTask(static_cast<MainThreadTaskQueue::QueueType>(2),
+  metric_reporter.RecordTask(static_cast<FakeTaskQueueType>(2),
                              base::TimeDelta::FromMicroseconds(15600));
   Mock::VerifyAndClearExpectations(&histogram);
 }

third_party/WebKit/Source/platform/scheduler/util/thread_type.h

+// Copyright 2017 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_UTIL_THREAD_TYPE_H_
+#define THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_UTIL_THREAD_TYPE_H_
+
+namespace blink {
+namespace scheduler {
+
+enum class ThreadType {
+  kMainThread = 0,
+  kWorkerThread = 1,
+  kCompositorThread = 2,
+  kCount = 3
+};
+
+}  // namespace scheduler
+}  // namespace blink
+
+#endif  // THIRD_PARTY_WEBKIT_SOURCE_PLATFORM_SCHEDULER_UTIL_THREAD_TYPE_H_

tools/metrics/histograms/enums.xml

@@ -35853,6 +35853,12 @@ Called by update_net_trust_anchors.py.-->
   <int value="25" label="Unthrottled"/>
 </enum>
 
+<enum name="RendererSchedulerThreadType">
+  <int value="0" label="MainThread"/>
+  <int value="1" label="WorkerThread"/>
+  <int value="2" label="CompositorThread"/>
+</enum>
+
 <enum name="RendererType">
   <int value="1" label="Normal renderer"/>
   <int value="2" label="Extension renderer"/>

tools/metrics/histograms/histograms.xml

@@ -69448,6 +69448,20 @@ http://cs/file:chrome/histograms.xml - but prefer this file for new entries.
   </summary>
 </histogram>
 
+<histogram name="RendererScheduler.TaskDurationPerThreadType"
+    enum="RendererSchedulerThreadType" units="ms">
+  <owner>altimin@chromium.org</owner>
+  <owner>lpy@chromium.org</owner>
+  <summary>
+    Total duration of renderer tasks split by per thread type. Used to compare
+    CPU usage of tasks from different threads. Reported each time when task is
+    completed and current accumulated duration is longer than 1ms.
+
+    Note that this metric discards tasks longer than 30 seconds because they are
+    considered to be a result of measurement glitch.
+  </summary>
+</histogram>
+
 <histogram name="RendererScheduler.TaskQueueManager.DelayedTaskLateness"
     units="ms">
   <obsolete>