Record task durations on Renderer Main & Compositor threads.

base/tracked_objects.h

 // 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.
 
 #ifndef BASE_TRACKED_OBJECTS_H_
 #define BASE_TRACKED_OBJECTS_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 604 matching lines @@
 
   // Record the end of execution in region, generally corresponding to a scope
   // being exited.
   static void TallyRunInAScopedRegionIfTracking(const Births* births,
                                                 const TaskStopwatch& stopwatch);
 
   const std::string& sanitized_thread_name() const {
     return sanitized_thread_name_;
   }
 
+  void EnableTaskDurationRecordingForUMA();
+  // Whether this thread records task lengths for UMA.
+  bool task_length_recording_enabled_for_uma() const {
+    return task_length_recording_enabled_for_uma_;
+  };
+
   // Initializes all statics if needed (this initialization call should be made
   // while we are single threaded).
   static void EnsureTlsInitialization();
 
   // Sets internal status_.
   // If |status| is false, then status_ is set to DEACTIVATED.
   // If |status| is true, then status_ is set to PROFILING_ACTIVE.
   static void InitializeAndSetTrackingStatus(Status status);
 
   static Status status();
 
   // Indicate if any sort of profiling is being done (i.e., we are more than
   // DEACTIVATED).
   static bool TrackingStatus();
 
   // Enables profiler timing.
   static void EnableProfilerTiming();
 
   // Provide a time function that does nothing (runs fast) when we don't have
   // the profiler enabled.  It will generally be optimized away when it is
   // ifdef'ed to be small enough (allowing the profiler to be "compiled out" of
   // the code).
   static base::TimeTicks Now();
 
+  // If the provided thread is enabled for task duration tracking, returns the

[Sami, 2017/07/26 20:36:38]

nit: "UMA task duration tracking" (I had to re-read this a couple of times to
figure out the difference to Now())

+  // current time. Otherwise, this is equivalent to Now().
+  static base::TimeTicks Now(const ThreadData* thread_data);
+
   // This function can be called at process termination to validate that thread
   // cleanup routines have been called for at least some number of named
   // threads.
   static void EnsureCleanupWasCalled(int major_threads_shutdown_count);
 
  private:
   friend class TaskStopwatch;
   // Allow only tests to call ShutdownSingleThreadedCleanup.  We NEVER call it
   // in production code.
   // TODO(jar): Make this a friend in DEBUG only, so that the optimizer has a
@@ skipping 157 matching lines @@
   // Record of what the incarnation_counter_ was when this instance was created.
   // If the incarnation_counter_ has changed, then we avoid pushing into the
   // pool (this is only critical in tests which go through multiple
   // incarnations).
   int incarnation_count_for_pool_;
 
   // Most recently started (i.e. most nested) stopwatch on the current thread,
   // if it exists; NULL otherwise.
   TaskStopwatch* current_stopwatch_;
 
+  bool task_length_recording_enabled_for_uma_;
+
   DISALLOW_COPY_AND_ASSIGN(ThreadData);
 };
 
 //------------------------------------------------------------------------------
 // Stopwatch to measure task run time or simply create a time interval that will
 // be subtracted from the current most nested task's run time.  Stopwatches
 // coordinate with the stopwatches in which they are nested to avoid
 // double-counting nested tasks run times.
 
 class BASE_EXPORT TaskStopwatch {
@@ skipping 85 matching lines @@
   ProcessDataSnapshot(const ProcessDataSnapshot& other);
   ~ProcessDataSnapshot();
 
   PhasedProcessDataSnapshotMap phased_snapshots;
   base::ProcessId process_id;
 };
 
 }  // namespace tracked_objects
 
 #endif  // BASE_TRACKED_OBJECTS_H_