Support parallel captures from the StackSamplingProfiler.

base/profiler/native_stack_sampler.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_NATIVE_STACK_SAMPLER_H_
 #define BASE_PROFILER_NATIVE_STACK_SAMPLER_H_
 
 #include <memory>
 
 #include "base/base_export.h"
 #include "base/macros.h"
 #include "base/profiler/stack_sampling_profiler.h"
 #include "base/threading/platform_thread.h"
 
 namespace base {
 
 class NativeStackSamplerTestDelegate;
 
 // NativeStackSampler is an implementation detail of StackSamplingProfiler. It
 // abstracts the native implementation required to record a stack sample for a
 // given thread.
 class NativeStackSampler {
  public:
+  // The thread state as determined by the sampler during it's last attempt.

[Mike Wittman, 2017/02/13 22:35:57]

All changes in this file and native_stack_sampler_win.cc can be removed since
they're not adding any functionality to the existing implementation.

[bcwhite, 2017/02/14 14:33:01]

Done.

+  enum ThreadState {
+    THREAD_UNCHECKED,
+    THREAD_RUNNING,
+    THREAD_EXITED,
+    THREAD_UNSUSPENDABLE,
+    THREAD_NO_INFO,
+    THREAD_STACK_TOO_BIG,
+    THREAD_INACCESSIBLE,
+  };
+
   // The callback type used to add annotations to a sample during collection.
   // This is passed to the native sampler to be applied at the most appropriate
   // time. It is a simple function-pointer because the generated code must be
   // completely predictable and do nothing that could acquire a mutex; a
   // Callback object is code outside the control of this object and could,
   // for example, acquire a mutex as part of allocating memory for a LOG
   // message.
   using AnnotateCallback = void (*)(StackSamplingProfiler::Sample*);
 
   virtual ~NativeStackSampler();
@@ skipping 13 matching lines @@
   virtual void ProfileRecordingStarting(
       std::vector<StackSamplingProfiler::Module>* modules) = 0;
 
   // Records a stack sample to |sample|.
   virtual void RecordStackSample(StackSamplingProfiler::Sample* sample) = 0;
 
   // Notifies the sampler that we've stopped recording the current
   // profile.
   virtual void ProfileRecordingStopped() = 0;
 
+  // Gets the last-known thread state.
+  ThreadState thread_state() { return thread_state_; }
+
  protected:
   NativeStackSampler();
 
+  void set_thread_state(ThreadState state) { thread_state_ = state; }
+
  private:
+  ThreadState thread_state_ = THREAD_UNCHECKED;
+
   DISALLOW_COPY_AND_ASSIGN(NativeStackSampler);
 };
 
 // NativeStackSamplerTestDelegate provides seams for test code to execute during
 // stack collection.
 class BASE_EXPORT NativeStackSamplerTestDelegate {
  public:
   virtual ~NativeStackSamplerTestDelegate();
 
   // Called after copying the stack and resuming the target thread, but prior to
   // walking the stack. Invoked on the SamplingThread.
-  virtual void OnPreStackWalk() = 0;
+  virtual void OnPreStackWalk(){};
+
+  // Called after the sampling is complete.
+  virtual void OnPostRecordSample(NativeStackSampler::ThreadState state){};
 
  protected:
   NativeStackSamplerTestDelegate();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NativeStackSamplerTestDelegate);
 };
 
 }  // namespace base
 
 #endif  // BASE_PROFILER_NATIVE_STACK_SAMPLER_H_