Set process phases in the StackSamplingProfiler.

base/profiler/stack_sampling_profiler.cc

 // 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.
 
 #include "base/profiler/stack_sampling_profiler.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 242 matching lines @@
       return;
   }
 }
 
 void StackSamplingProfiler::SamplingThread::Stop() {
   stop_event_.Signal();
 }
 
 // StackSamplingProfiler ------------------------------------------------------
 
-subtle::Atomic32 StackSamplingProfiler::process_phases_ = 0;
+subtle::Atomic32 StackSamplingProfiler::process_milestones_ = 0;
 
 StackSamplingProfiler::SamplingParams::SamplingParams()
     : initial_delay(TimeDelta::FromMilliseconds(0)),
       bursts(1),
       burst_interval(TimeDelta::FromMilliseconds(10000)),
       samples_per_burst(300),
       sampling_interval(TimeDelta::FromMilliseconds(100)) {
 }
 
 StackSamplingProfiler::StackSamplingProfiler(
@@ skipping 42 matching lines @@
                               &sampling_thread_handle_))
     sampling_thread_.reset();
 }
 
 void StackSamplingProfiler::Stop() {
   if (sampling_thread_)
     sampling_thread_->Stop();
 }
 
 // static
-void StackSamplingProfiler::SetProcessPhase(int phase) {
-  DCHECK_LE(0, phase);
-  DCHECK_GT(static_cast<int>(sizeof(process_phases_) * 8), phase);
-  DCHECK_EQ(0, subtle::NoBarrier_Load(&process_phases_) & (1 << phase));
-  ChangeAtomicFlags(&process_phases_, 1 << phase, 0);
+void StackSamplingProfiler::SetProcessMilestone(int milestone) {
+  DCHECK_LE(0, milestone);
+  DCHECK_GT(static_cast<int>(sizeof(process_milestones_) * 8), milestone);
+  DCHECK_EQ(0, subtle::NoBarrier_Load(&process_milestones_) & (1 << milestone));
+  ChangeAtomicFlags(&process_milestones_, 1 << milestone, 0);
 }
 
 // static
 void StackSamplingProfiler::ResetAnnotationsForTesting() {
-  subtle::NoBarrier_Store(&process_phases_, 0u);
+  subtle::NoBarrier_Store(&process_milestones_, 0u);
 }
 
 // static
 void StackSamplingProfiler::RecordAnnotations(Sample* sample) {
   // The code inside this method must not do anything that could acquire a
   // mutex, including allocating memory (which includes LOG messages) because
   // that mutex could be held by a stopped thread, thus resulting in deadlock.
-  sample->process_phases = subtle::NoBarrier_Load(&process_phases_);
+  sample->process_milestones = subtle::NoBarrier_Load(&process_milestones_);
 }
 
 // StackSamplingProfiler::Frame global functions ------------------------------
 
 bool operator==(const StackSamplingProfiler::Module& a,
                 const StackSamplingProfiler::Module& b) {
   return a.base_address == b.base_address && a.id == b.id &&
       a.filename == b.filename;
 }
 
 bool operator==(const StackSamplingProfiler::Sample& a,
                 const StackSamplingProfiler::Sample& b) {
-  return a.process_phases == b.process_phases && a.frames == b.frames;
+  return a.process_milestones == b.process_milestones && a.frames == b.frames;
 }
 
 bool operator!=(const StackSamplingProfiler::Sample& a,
                 const StackSamplingProfiler::Sample& b) {
   return !(a == b);
 }
 
 bool operator<(const StackSamplingProfiler::Sample& a,
                const StackSamplingProfiler::Sample& b) {
-  if (a.process_phases < b.process_phases)
+  if (a.process_milestones < b.process_milestones)
     return true;
-  if (a.process_phases > b.process_phases)
+  if (a.process_milestones > b.process_milestones)
     return false;
 
   return a.frames < b.frames;
 }
 
 bool operator==(const StackSamplingProfiler::Frame &a,
                 const StackSamplingProfiler::Frame &b) {
   return a.instruction_pointer == b.instruction_pointer &&
       a.module_index == b.module_index;
 }
 
 bool operator<(const StackSamplingProfiler::Frame &a,
                const StackSamplingProfiler::Frame &b) {
   return (a.module_index < b.module_index) ||
       (a.module_index == b.module_index &&
        a.instruction_pointer < b.instruction_pointer);
 }
 
 }  // namespace base