Stack sampling profiler: handle unloaded and unloading modules

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 <string>
 #include <vector>
 
 #include "base/base_export.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.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;
 
 // 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.
 //
 // Sample StackSamplingProfiler usage:
 //
 //   // Create and customize params as desired.
 //   base::StackStackSamplingProfiler::SamplingParams params;
@@ skipping 116 matching lines @@
   // The callback type used to collect completed profiles.
   //
   // IMPORTANT NOTE: the callback is invoked on a thread the profiler
   // constructs, rather than on the thread used to construct the profiler and
   // set the callback, and thus the callback must be callable on any thread. For
   // threads with message loops that create StackSamplingProfilers, posting a
   // task to the message loop with a copy of the profiles is the recommended
   // thread-safe callback implementation.
   using CompletedCallback = Callback<void(const CallStackProfiles&)>;
 
-  // Creates a profiler that sends completed profiles to |callback|.
+  // Creates a profiler that sends completed profiles to |callback|. The second
+  // constructor is for test purposes.
   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);
 
@@ skipping 51 matching lines @@
   // The thread whose stack will be sampled.
   PlatformThreadId thread_id_;
 
   const SamplingParams params_;
 
   scoped_ptr<SamplingThread> sampling_thread_;
   PlatformThreadHandle sampling_thread_handle_;
 
   const CompletedCallback completed_callback_;
 
+  // Stored until it can be passed to the NativeStackSampler created in Start().
+  NativeStackSamplerTestDelegate* const test_delegate_;
+
   DISALLOW_COPY_AND_ASSIGN(StackSamplingProfiler);
 };
 
 // The metrics provider code wants to put Samples in a map and compare them,
 // which requires us to define a few operators.
 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_