Record task durations on Renderer Main & Compositor threads.

base/tracked_objects.cc

 // Copyright (c) 2012 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/tracked_objects.h"
 
 #include <ctype.h>
 #include <limits.h>
 #include <stdlib.h>
 
@@ skipping 505 matching lines @@
     ThreadData::list_lock_ = LAZY_INSTANCE_INITIALIZER;
 
 // static
 base::subtle::Atomic32 ThreadData::status_ = ThreadData::UNINITIALIZED;
 
 ThreadData::ThreadData(const std::string& sanitized_thread_name)
     : next_(NULL),
       next_retired_thread_data_(NULL),
       sanitized_thread_name_(sanitized_thread_name),
       incarnation_count_for_pool_(-1),
-      current_stopwatch_(NULL) {
+      current_stopwatch_(NULL),
+      task_length_recording_enabled_for_uma_(false) {
   DCHECK(sanitized_thread_name_.empty() ||
          !isdigit(sanitized_thread_name_.back()));
   PushToHeadOfList();  // Which sets real incarnation_count_for_pool_.
 }
 
 ThreadData::~ThreadData() {
 }
 
 void ThreadData::PushToHeadOfList() {
   // Toss in a hint of randomness (atop the uniniitalized value).
@@ skipping 325 matching lines @@
 }
 
 void ThreadData::OnProfilingPhaseCompletedOnThread(int profiling_phase) {
   base::AutoLock lock(map_lock_);
 
   for (auto& death : death_map_) {
     death.second.OnProfilingPhaseCompleted(profiling_phase);
   }
 }
 
+void ThreadData::EnableTaskDurationRecordingForUMA() {
+  task_length_recording_enabled_for_uma_ = true;
+}
+
 void ThreadData::EnsureTlsInitialization() {
   if (base::subtle::Acquire_Load(&status_) >= DEACTIVATED)
     return;  // Someone else did the initialization.
   // Due to racy lazy initialization in tests, we'll need to recheck status_
   // after we acquire the lock.
 
   // Ensure that we don't double initialize tls.  We are called when single
   // threaded in the product, but some tests may be racy and lazy about our
   // initialization.
   base::AutoLock lock(*list_lock_.Pointer());
@@ skipping 48 matching lines @@
 // static
 void ThreadData::EnableProfilerTiming() {
   base::subtle::NoBarrier_Store(&g_profiler_timing_enabled, ENABLED_TIMING);
 }
 
 // static
 base::TimeTicks ThreadData::Now() {
   if (now_function_for_testing_)
     return base::TimeTicks() +
            base::TimeDelta::FromMilliseconds((*now_function_for_testing_)());
+
   if (IsProfilerTimingEnabled() && TrackingStatus())
     return base::TimeTicks::Now();
   return base::TimeTicks();  // Super fast when disabled, or not compiled.
 }
 
 // static
+base::TimeTicks ThreadData::Now(const ThreadData* thread_data) {
+  base::TimeTicks now = ThreadData::Now();
+  if (!now.is_null())
+    return now;
+  if (!thread_data)
+    return base::TimeTicks();
+  if (thread_data->task_length_recording_enabled_for_uma())
+    return base::TimeTicks::Now();
+  return base::TimeTicks();
+}
+
+// static
 void ThreadData::EnsureCleanupWasCalled(int major_threads_shutdown_count) {
   base::AutoLock lock(*list_lock_.Pointer());
 
   // TODO(jar): until this is working on XP, don't run the real test.
 #if 0
   // Verify that we've at least shutdown/cleanup the major namesd threads.  The
   // caller should tell us how many thread shutdowns should have taken place by
   // now.
   CHECK_GT(cleanup_count_, major_threads_shutdown_count);
 #endif
@@ skipping 106 matching lines @@
   DCHECK(state_ != RUNNING);
   DCHECK(child_ == NULL);
 #endif
 }
 
 void TaskStopwatch::Start() {
 #if DCHECK_IS_ON()
   DCHECK(state_ == CREATED);
   state_ = RUNNING;
 #endif
-
-  start_time_ = ThreadData::Now();
+  current_thread_data_ = ThreadData::Get();
+  start_time_ = ThreadData::Now(current_thread_data_);
 #if BUILDFLAG(USE_ALLOCATOR_SHIM)
   if (heap_tracking_enabled_)
     heap_usage_.Start();
 #endif
 
-  current_thread_data_ = ThreadData::Get();
   if (!current_thread_data_)
     return;
 
   parent_ = current_thread_data_->current_stopwatch_;
 #if DCHECK_IS_ON()
   if (parent_) {
     DCHECK(parent_->state_ == RUNNING);
     DCHECK(parent_->child_ == NULL);
     parent_->child_ = this;
   }
 #endif
   current_thread_data_->current_stopwatch_ = this;
 }
 
 void TaskStopwatch::Stop() {
-  const base::TimeTicks end_time = ThreadData::Now();
+  const base::TimeTicks end_time = ThreadData::Now(current_thread_data_);
 #if DCHECK_IS_ON()
   DCHECK(state_ == RUNNING);
   state_ = STOPPED;
   DCHECK(child_ == NULL);
 #endif
 #if BUILDFLAG(USE_ALLOCATOR_SHIM)
   if (heap_tracking_enabled_)
     heap_usage_.Stop(true);
 #endif
 
@@ skipping 90 matching lines @@
 #endif
 }
 
 ProcessDataSnapshot::ProcessDataSnapshot(const ProcessDataSnapshot& other) =
     default;
 
 ProcessDataSnapshot::~ProcessDataSnapshot() {
 }
 
 }  // namespace tracked_objects