Remove worker pool names from TaskScheduler.TaskLatency.* histograms.

base/task_scheduler/task_tracker.cc

 // 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.
 
 #include "base/task_scheduler/task_tracker.h"
 
 #include <limits>
+#include <string>
 
 #include "base/callback.h"
 #include "base/debug/task_annotator.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/sequence_token.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/task_scheduler/scoped_set_task_priority_for_current_thread.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "base/values.h"
 
 namespace base {
 namespace internal {
 
 namespace {
 
 constexpr char kParallelExecutionMode[] = "parallel";
 constexpr char kSequencedExecutionMode[] = "sequenced";
@@ skipping 33 matching lines @@
   JSONWriter::Write(dict, &tmp);
   out->append(tmp);
 }
 
 const char kQueueFunctionName[] = "base::PostTask";
 
 // This name conveys that a Task is run by the task scheduler without revealing
 // its implementation details.
 const char kRunFunctionName[] = "TaskSchedulerRunTask";
 
+HistogramBase* GetTaskLatencyHistogram(const char* suffix) {
+  // Mimics the UMA_HISTOGRAM_TIMES macro.
+  return Histogram::FactoryTimeGet(
+      std::string("TaskScheduler.TaskLatency.") + suffix,
+      TimeDelta::FromMilliseconds(1), TimeDelta::FromSeconds(10), 50,
+      HistogramBase::kUmaTargetedHistogramFlag);
+}
+
 // Upper bound for the
 // TaskScheduler.BlockShutdownTasksPostedDuringShutdown histogram.
 const HistogramBase::Sample kMaxBlockShutdownTasksPostedDuringShutdown = 1000;
 
 void RecordNumBlockShutdownTasksPostedDuringShutdown(
     HistogramBase::Sample value) {
   UMA_HISTOGRAM_CUSTOM_COUNTS(
       "TaskScheduler.BlockShutdownTasksPostedDuringShutdown", value, 1,
       kMaxBlockShutdownTasksPostedDuringShutdown, 50);
 }
@@ skipping 83 matching lines @@
   // blocking task or the second thread will win and
   // IncrementNumTasksBlockingShutdown() will know that shutdown has started.
   subtle::Atomic32 bits_ = 0;
 
   DISALLOW_COPY_AND_ASSIGN(State);
 };
 
 TaskTracker::TaskTracker()
     : state_(new State),
       flush_cv_(flush_lock_.CreateConditionVariable()),
-      shutdown_lock_(&flush_lock_) {}
+      shutdown_lock_(&flush_lock_),
+      task_latency_histograms_{
+          {GetTaskLatencyHistogram("BackgroundTaskPriority"),
+           GetTaskLatencyHistogram("BackgroundTaskPriority.MayBlock")},
+          {GetTaskLatencyHistogram("UserVisibleTaskPriority"),
+           GetTaskLatencyHistogram("UserVisibleTaskPriority.MayBlock")},
+          {GetTaskLatencyHistogram("UserBlockingTaskPriority"),
+           GetTaskLatencyHistogram("UserBlockingTaskPriority.MayBlock")}} {
+  // Confirm that all |task_latency_histograms_| have been initialized above.
+  DCHECK(*(&task_latency_histograms_[static_cast<int>(TaskPriority::HIGHEST) +
+                                     1][0] -
+           1));

[gab, 2017/01/05 22:16:36]

This is git cl format? Looks terrible..!

[fdoray, 2017/01/05 22:31:58]

Yes. And there is a presubmit check to verify that base/ is git cl formatted, so
we can't change this.

+}
+
 TaskTracker::~TaskTracker() = default;
 
 void TaskTracker::Shutdown() {
   PerformShutdown();
   DCHECK(IsShutdownComplete());
 
   // Unblock Flush() when shutdown completes.
   AutoSchedulerLock auto_lock(flush_lock_);
   flush_cv_->Signal();
 }
@@ skipping 25 matching lines @@
                           const SequenceToken& sequence_token) {
   DCHECK(task);
   DCHECK(sequence_token.IsValid());
 
   const TaskShutdownBehavior shutdown_behavior =
       task->traits.shutdown_behavior();
   const bool can_run_task = BeforeRunTask(shutdown_behavior);
   const bool is_delayed = !task->delayed_run_time.is_null();
 
   if (can_run_task) {
+    RecordTaskLatencyHistogram(task.get());
+
     const bool previous_singleton_allowed =
         ThreadRestrictions::SetSingletonAllowed(
             task->traits.shutdown_behavior() !=
             TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN);
     const bool previous_io_allowed =
         ThreadRestrictions::SetIOAllowed(task->traits.may_block());
     const bool previous_wait_allowed = ThreadRestrictions::SetWaitAllowed(
         task->traits.with_base_sync_primitives());
 
     {
@@ skipping 223 matching lines @@
 void TaskTracker::DecrementNumPendingUndelayedTasks() {
   const auto new_num_pending_undelayed_tasks =
       subtle::NoBarrier_AtomicIncrement(&num_pending_undelayed_tasks_, -1);
   DCHECK_GE(new_num_pending_undelayed_tasks, 0);
   if (new_num_pending_undelayed_tasks == 0) {
     AutoSchedulerLock auto_lock(flush_lock_);
     flush_cv_->Signal();
   }
 }
 
+void TaskTracker::RecordTaskLatencyHistogram(Task* task) {
+  const TimeDelta task_latency = TimeTicks::Now() - task->sequenced_time;
+  task_latency_histograms_[static_cast<int>(task->traits.priority())]
+                          [task->traits.may_block() ||
+                                   task->traits.with_base_sync_primitives()
+                               ? 1
+                               : 0]
+                              ->AddTime(task_latency);
+}
+
 }  // namespace internal
 }  // namespace base