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

base/task_scheduler/scheduler_worker_pool_impl.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/scheduler_worker_pool_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
 
 #include "base/atomicops.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/sequence_token.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner.h"
 #include "base/task_scheduler/delayed_task_manager.h"
 #include "base/task_scheduler/task_tracker.h"
+#include "base/task_scheduler/task_traits.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_local.h"
 #include "base/threading/thread_restrictions.h"
 
 namespace base {
 namespace internal {
 
 namespace {
 
 constexpr char kPoolNameSuffix[] = "Pool";
 constexpr char kDetachDurationHistogramPrefix[] =
     "TaskScheduler.DetachDuration.";
 constexpr char kNumTasksBeforeDetachHistogramPrefix[] =
     "TaskScheduler.NumTasksBeforeDetach.";
 constexpr char kNumTasksBetweenWaitsHistogramPrefix[] =
     "TaskScheduler.NumTasksBetweenWaits.";
-constexpr char kTaskLatencyHistogramPrefix[] = "TaskScheduler.TaskLatency.";
 
 // SchedulerWorkerPool that owns the current thread, if any.
 LazyInstance<ThreadLocalPointer<const SchedulerWorkerPool>>::Leaky
     tls_current_worker_pool = LAZY_INSTANCE_INITIALIZER;
 
 // A task runner that runs tasks with the PARALLEL ExecutionMode.
 class SchedulerParallelTaskRunner : public TaskRunner {
  public:
   // Constructs a SchedulerParallelTaskRunner which can be used to post tasks so
   // long as |worker_pool| is alive.
@@ skipping 69 matching lines @@
 
   // Sequence for all Tasks posted through this TaskRunner.
   const scoped_refptr<Sequence> sequence_ = new Sequence;
 
   const TaskTraits traits_;
   SchedulerWorkerPool* const worker_pool_;
 
   DISALLOW_COPY_AND_ASSIGN(SchedulerSequencedTaskRunner);
 };
 
-HistogramBase* GetTaskLatencyHistogram(const std::string& pool_name,
-                                       TaskPriority task_priority) {
-  const char* task_priority_suffix = nullptr;
-  switch (task_priority) {
-    case TaskPriority::BACKGROUND:
-      task_priority_suffix = ".BackgroundTaskPriority";
-      break;
-    case TaskPriority::USER_VISIBLE:
-      task_priority_suffix = ".UserVisibleTaskPriority";
-      break;
-    case TaskPriority::USER_BLOCKING:
-      task_priority_suffix = ".UserBlockingTaskPriority";
-      break;
-  }
-
-  // Mimics the UMA_HISTOGRAM_TIMES macro.
-  return Histogram::FactoryTimeGet(kTaskLatencyHistogramPrefix + pool_name +
-                                       kPoolNameSuffix + task_priority_suffix,
-                                   TimeDelta::FromMilliseconds(1),
-                                   TimeDelta::FromSeconds(10), 50,
-                                   HistogramBase::kUmaTargetedHistogramFlag);
-}
-
 // Only used in DCHECKs.
 bool ContainsWorker(
     const std::vector<std::unique_ptr<SchedulerWorker>>& workers,
     const SchedulerWorker* worker) {
   auto it = std::find_if(workers.begin(), workers.end(),
       [worker](const std::unique_ptr<SchedulerWorker>& i) {
         return i.get() == worker;
       });
   return it != workers.end();
 }
@@ skipping 67 matching lines @@
       int index);
   ~SchedulerWorkerDelegateImpl() override;
 
   PriorityQueue* single_threaded_priority_queue() {
     return &single_threaded_priority_queue_;
   }
 
   // SchedulerWorker::Delegate:
   void OnMainEntry(SchedulerWorker* worker) override;
   scoped_refptr<Sequence> GetWork(SchedulerWorker* worker) override;
-  void DidRunTaskWithPriority(TaskPriority task_priority,
-                              TimeDelta task_latency) override;
+  void DidRunTask() override;
   void ReEnqueueSequence(scoped_refptr<Sequence> sequence) override;
   TimeDelta GetSleepTimeout() override;
   bool CanDetach(SchedulerWorker* worker) override;
   void OnDetach() override;
 
   void RegisterSingleThreadTaskRunner() {
     // No barrier as barriers only affect sequential consistency which is
     // irrelevant in a single variable use case (they don't force an immediate
     // flush anymore than atomics do by default).
     subtle::NoBarrier_AtomicIncrement(&num_single_threaded_runners_, 1);
@@ skipping 339 matching lines @@
   DCHECK(sequence);
 
   outer_->RemoveFromIdleWorkersStack(worker);
   idle_start_time_ = TimeTicks();
   did_detach_since_last_get_work_ = false;
   last_get_work_returned_nullptr_ = false;
 
   return sequence;
 }
 
-void SchedulerWorkerPoolImpl::SchedulerWorkerDelegateImpl::
-    DidRunTaskWithPriority(TaskPriority task_priority, TimeDelta task_latency) {
+void SchedulerWorkerPoolImpl::SchedulerWorkerDelegateImpl::DidRunTask() {
   ++num_tasks_since_last_wait_;
   ++num_tasks_since_last_detach_;
-
-  const int priority_index = static_cast<int>(task_priority);
-
-  // As explained in the header file, histograms are allocated on demand. It
-  // doesn't matter if an element of |task_latency_histograms_| is set multiple
-  // times since GetTaskLatencyHistogram() is idempotent. As explained in the
-  // comment at the top of histogram_macros.h, barriers are required.
-  HistogramBase* task_latency_histogram = reinterpret_cast<HistogramBase*>(
-      subtle::Acquire_Load(&outer_->task_latency_histograms_[priority_index]));
-  if (!task_latency_histogram) {
-    task_latency_histogram =
-        GetTaskLatencyHistogram(outer_->name_, task_priority);
-    subtle::Release_Store(
-        &outer_->task_latency_histograms_[priority_index],
-        reinterpret_cast<subtle::AtomicWord>(task_latency_histogram));
-  }
-
-  task_latency_histogram->AddTime(task_latency);
 }
 
 void SchedulerWorkerPoolImpl::SchedulerWorkerDelegateImpl::
     ReEnqueueSequence(scoped_refptr<Sequence> sequence) {
   if (last_sequence_is_single_threaded_) {
     // A single-threaded Sequence is always re-enqueued in the single-threaded
     // PriorityQueue from which it was extracted.
     const SequenceSortKey sequence_sort_key = sequence->GetSortKey();
     single_threaded_priority_queue_.BeginTransaction()->Push(
         std::move(sequence), sequence_sort_key);
@@ skipping 163 matching lines @@
   AutoSchedulerLock auto_lock(idle_workers_stack_lock_);
   idle_workers_stack_.Remove(worker);
 }
 
 bool SchedulerWorkerPoolImpl::CanWorkerDetachForTesting() {
   return !worker_detachment_disallowed_.IsSet();
 }
 
 }  // namespace internal
 }  // namespace base