Set process phases in the StackSamplingProfiler.

base/profiler/stack_sampling_profiler.h

 // Copyright 2015 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_PROFILER_STACK_SAMPLING_PROFILER_H_
 #define BASE_PROFILER_STACK_SAMPLING_PROFILER_H_
 
 #include <stddef.h>
 
 #include <memory>
@@ skipping 103 matching lines @@
     Sample(const Sample& sample);
     ~Sample();
 
     // These constructors are used only during testing.
     Sample(const Frame& frame);
     Sample(const std::vector<Frame>& frames);
 
     // The entire stack frame when the sample is taken.
     std::vector<Frame> frames;
 
-    // A bit-field indicating which process phases have passed. This can be
+    // A bit-field indicating which process milestones have passed. This can be
     // used to tell where in the process lifetime the samples are taken. Just
-    // as a "lifetime" can only move forward, these bits mark the phases of
+    // as a "lifetime" can only move forward, these bits mark the milestones of
     // the processes life as they occur. Bits can be set but never reset. The
     // actual definition of the individual bits is left to the user of this
     // module.
-    uint32_t process_phases = 0;
+    uint32_t process_milestones = 0;
   };
 
   // CallStackProfile represents a set of samples.
   struct BASE_EXPORT CallStackProfile {
     CallStackProfile();
     CallStackProfile(CallStackProfile&& other);
     ~CallStackProfile();
 
     CallStackProfile& operator=(CallStackProfile&& other);
 
@@ skipping 77 matching lines @@
   // Stops the profiler and any ongoing sampling. Calling this function is
   // optional; if not invoked profiling terminates when all the profiling bursts
   // specified in the SamplingParams are completed or the profiler is destroyed,
   // whichever occurs first.
   void Stop();
 
   // Set the current system state that is recorded with each captured stack
   // frame. This is thread-safe so can be called from anywhere. The parameter
   // value should be from an enumeration of the appropriate type with values
   // ranging from 0 to 31, inclusive. This sets bits within Sample field of
-  // |process_phases|. The actual meanings of these bits are defined (globally)
-  // by the caller(s).
-  static void SetProcessPhase(int phase);
+  // |process_milestones|. The actual meanings of these bits are defined
+  // (globally) by the caller(s).
+  static void SetProcessMilestone(int milestone);
   static void ResetAnnotationsForTesting();
 
  private:
   // SamplingThread is a separate thread used to suspend and sample stacks from
   // the target thread.
   class SamplingThread : public PlatformThread::Delegate {
    public:
     // Samples stacks using |native_sampler|. When complete, invokes
     // |completed_callback| with the collected call stack profiles.
     // |completed_callback| must be callable on any thread.
@@ skipping 32 matching lines @@
   };
 
   // Adds annotations to a Sample.
   static void RecordAnnotations(Sample* sample);
 
   // This global variables holds the current system state and is recorded with
   // every captured sample, done on a separate thread which is why updates to
   // this must be atomic. A PostTask to move the the updates to that thread
   // would skew the timing and a lock could result in deadlock if the thread
   // making a change was also being profiled and got stopped.
-  static subtle::Atomic32 process_phases_;
+  static subtle::Atomic32 process_milestones_;
 
   // The thread whose stack will be sampled.
   PlatformThreadId thread_id_;
 
   const SamplingParams params_;
 
   std::unique_ptr<SamplingThread> sampling_thread_;
   PlatformThreadHandle sampling_thread_handle_;
 
   const CompletedCallback completed_callback_;
@@ skipping 15 matching lines @@
 BASE_EXPORT bool operator<(const StackSamplingProfiler::Sample& a,
                            const StackSamplingProfiler::Sample& b);
 BASE_EXPORT bool operator==(const StackSamplingProfiler::Frame& a,
                             const StackSamplingProfiler::Frame& b);
 BASE_EXPORT bool operator<(const StackSamplingProfiler::Frame& a,
                            const StackSamplingProfiler::Frame& b);
 
 }  // namespace base
 
 #endif  // BASE_PROFILER_STACK_SAMPLING_PROFILER_H_