Support parallel captures from the StackSamplingProfiler.

base/profiler/native_stack_sampler_win.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/native_stack_sampler.h"
 
 #include <objbase.h>
 #include <windows.h>
 #include <stddef.h>
 #include <winternl.h>
@@ skipping 308 matching lines @@
   return result != 0 && (memory_info.Protect & PAGE_GUARD);
 }
 
 // Suspends the thread with |thread_handle|, copies its stack and resumes the
 // thread, then records the stack frames and associated modules into |stack|.
 //
 // IMPORTANT NOTE: No allocations from the default heap may occur in the
 // ScopedSuspendThread scope, including indirectly via use of DCHECK/CHECK or
 // other logging statements. Otherwise this code can deadlock on heap locks in
 // the default heap acquired by the target thread before it was suspended.
-void SuspendThreadAndRecordStack(
+NativeStackSampler::ThreadState SuspendThreadAndRecordStack(
     HANDLE thread_handle,
     const void* base_address,
     void* stack_copy_buffer,
     size_t stack_copy_buffer_size,
     std::vector<RecordedFrame>* stack,
     NativeStackSampler::AnnotateCallback annotator,
     StackSamplingProfiler::Sample* sample,
     NativeStackSamplerTestDelegate* test_delegate) {
   DCHECK(stack->empty());
 
   CONTEXT thread_context = {0};
   thread_context.ContextFlags = CONTEXT_FULL;
   // The stack bounds are saved to uintptr_ts for use outside
   // ScopedSuspendThread, as the thread's memory is not safe to dereference
   // beyond that point.
   const uintptr_t top = reinterpret_cast<uintptr_t>(base_address);
   uintptr_t bottom = 0u;
 
   {
     ScopedSuspendThread suspend_thread(thread_handle);
 
     if (!suspend_thread.was_successful())
-      return;
+      return NativeStackSampler::THREAD_UNSUSPENDABLE;
 
     if (!::GetThreadContext(thread_handle, &thread_context))
-      return;
+      return NativeStackSampler::THREAD_NO_INFO;
+
 #if defined(_WIN64)
     bottom = thread_context.Rsp;
 #else
     bottom = thread_context.Esp;
 #endif
 
     if ((top - bottom) > stack_copy_buffer_size)
-      return;
+      return NativeStackSampler::THREAD_STACK_TOO_BIG;
 
     // Dereferencing a pointer in the guard page in a thread that doesn't own
     // the stack results in a STATUS_GUARD_PAGE_VIOLATION exception and a crash.
     // This occurs very rarely, but reliably over the population.
     if (PointsToGuardPage(bottom))
-      return;
+      return NativeStackSampler::THREAD_INACCESSIBLE;
 
     (*annotator)(sample);
 
     CopyMemoryFromStack(stack_copy_buffer,
                         reinterpret_cast<const void*>(bottom), top - bottom);
   }
 
   if (test_delegate)
     test_delegate->OnPreStackWalk();
 
   RewritePointersToStackMemory(top, bottom, &thread_context, stack_copy_buffer);
 
   RecordStack(&thread_context, stack);
+  return NativeStackSampler::THREAD_RUNNING;
 }
 
 // NativeStackSamplerWin ------------------------------------------------------
 
 class NativeStackSamplerWin : public NativeStackSampler {
  public:
   NativeStackSamplerWin(win::ScopedHandle thread_handle,
                         AnnotateCallback annotator,
                         NativeStackSamplerTestDelegate* test_delegate);
   ~NativeStackSamplerWin() override;
@@ skipping 77 matching lines @@
   profile_module_index_.clear();
 }
 
 void NativeStackSamplerWin::RecordStackSample(
     StackSamplingProfiler::Sample* sample) {
   DCHECK(current_modules_);
 
   if (!stack_copy_buffer_)
     return;
 
+  if (thread_state() == THREAD_EXITED)
+    return;
+
   std::vector<RecordedFrame> stack;
-  SuspendThreadAndRecordStack(thread_handle_.Get(), thread_stack_base_address_,
-                              stack_copy_buffer_.get(), kStackCopyBufferSize,
-                              &stack, annotator_, sample, test_delegate_);
+  set_thread_state(SuspendThreadAndRecordStack(
+      thread_handle_.Get(), thread_stack_base_address_,
+      stack_copy_buffer_.get(), kStackCopyBufferSize, &stack, annotator_,
+      sample, test_delegate_));
   CopyToSample(stack, sample, current_modules_);
+
+  if (test_delegate_)
+    test_delegate_->OnPostRecordSample(thread_state());
 }
 
 void NativeStackSamplerWin::ProfileRecordingStopped() {
   current_modules_ = nullptr;
 }
 
 // static
 bool NativeStackSamplerWin::GetModuleForHandle(
     HMODULE module_handle,
     StackSamplingProfiler::Module* module) {
@@ skipping 62 matching lines @@
 
   if (thread_handle) {
     return std::unique_ptr<NativeStackSampler>(new NativeStackSamplerWin(
         win::ScopedHandle(thread_handle), annotator, test_delegate));
   }
 #endif
   return std::unique_ptr<NativeStackSampler>();
 }
 
 }  // namespace base