Wait for sampling to complete before destructing.

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>
 #include <string>
 #include <vector>
 
 #include "base/atomicops.h"
 #include "base/base_export.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/strings/string16.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 
 namespace base {
 
 class NativeStackSampler;
 class NativeStackSamplerTestDelegate;
+class WaitableEvent;
 
 // StackSamplingProfiler periodically stops a thread to sample its stack, for
 // the purpose of collecting information about which code paths are
 // executing. This information is used in aggregate by UMA to identify hot
 // and/or janky code paths.
 //
+// IMPORTANT: Only threads guaranteed to live beyond the lifetime of the
+// profiler object can be safely sampled. Sampling the activity of the current
+// thread within the scope of this object is safe, but sampling any other
+// thread could cause Bad Things(tm) to occur should that thread exit before
+// sampling is complete. USE WITH CAUTION!
+//
 // Sample StackSamplingProfiler usage:
 //
 //   // Create and customize params as desired.
 //   base::StackStackSamplingProfiler::SamplingParams params;
 //   // Any thread's ID may be passed as the target.
 //   base::StackSamplingProfiler profiler(base::PlatformThread::CurrentId()),
 //       params);
 //
 //   // Or, to process the profiles within Chrome rather than via UMA, use a
 //   // custom completed callback:
@@ skipping 154 matching lines @@
   StackSamplingProfiler(PlatformThreadId thread_id,
                         const SamplingParams& params,
                         const CompletedCallback& callback);
   StackSamplingProfiler(PlatformThreadId thread_id,
                         const SamplingParams& params,
                         const CompletedCallback& callback,
                         NativeStackSamplerTestDelegate* test_delegate);
   // Stops any profiling currently taking place before destroying the profiler.
   ~StackSamplingProfiler();
 
-  // The fire-and-forget interface: starts a profiler and allows it to complete
-  // without the caller needing to manage the profiler lifetime. May be invoked
-  // from any thread, but requires that the calling thread has a message loop.
-  static void StartAndRunAsync(PlatformThreadId thread_id,
-                               const SamplingParams& params,
-                               const CompletedCallback& callback);
-
   // Initializes the profiler and starts sampling.
   void Start();
 
   // 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();
+  // whichever occurs first. If |done| is not null, a signal will be sent to it
+  // once the sampling has stopped and the callback completed.
+  void Stop(WaitableEvent* done);
 
   // Stops all active profiles and cleans up any resources in anticipation of
   // a shutdown of the current process.
   static void Shutdown();
 
   // Resets the "shutdown" state so that the sampling thread can be restarted.
   static void UndoShutdownForTesting();
 
   // Returns whether the sampling thread is currently running or not.
   static bool IsSamplingThreadRunningForTesting();
@@ skipping 64 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_