Enable startup profiling by Win x64 stack sampling profiler

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>
 
@@ skipping 16 matching lines @@
 // and/or janky code paths.
 //
 // 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);
 //
-//   // To process the call stack profiles within Chrome rather than via UMA,
-//   // set a custom completed callback:
+//   // Or, to process the profiles within Chrome rather than via UMA, use a
+//   // custom completed callback:
 //   base::StackStackSamplingProfiler::CompletedCallback
 //       thread_safe_callback = ...;
-//   profiler.SetCustomCompletedCallback(thread_safe_callback);
+//   base::StackSamplingProfiler profiler(base::PlatformThread::CurrentId()),
+//       params, thread_safe_callback);
 //
 //   profiler.Start();
 //   // ... work being done on the target thread here ...
 //   profiler.Stop();  // optional, stops collection before complete per params
 //
 // The default SamplingParams causes stacks to be recorded in a single burst at
 // a 10Hz interval for a total of 30 seconds. All of these parameters may be
 // altered as desired.
 //
 // When all call stack profiles are complete or the profiler is stopped, if the
-// custom completed callback was set it is called from the profiler thread with
-// the completed profiles. A profile is considered complete if all requested
-// samples were recorded for the profile (i.e. it was not stopped
-// prematurely). If no callback was set, the completed profiles are stored
-// internally and retrieved for UMA through GetPendingProfiles().
-// GetPendingProfiles() should never be called by other code; to retrieve
-// profiles for in-process processing, set a completed callback.
+// custom completed callback was set it is called from a thread created by the
+// profiler with the completed profiles. A profile is considered complete if all
+// requested samples were recorded for the profile (i.e. it was not stopped
+// prematurely).  If no callback was set, the default completed callback will be
+// called with the profiles. It is expected that the the default completed
+// callback is set by the metrics system to allow profiles to be provided via
+// UMA.
 //
 // The results of the profiling are passed to the completed callback and consist
 // of a vector of CallStackProfiles. Each CallStackProfile corresponds to a
 // burst as specified in SamplingParams and contains a set of Samples and
 // Modules. One Sample corresponds to a single recorded stack, and the Modules
 // record those modules associated with the recorded stack frames.
 class BASE_EXPORT StackSamplingProfiler {
  public:
   // Module represents the module (DLL or exe) corresponding to a stack frame.
   struct BASE_EXPORT Module {
@@ skipping 88 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 the default completed
+  // callback.
   StackSamplingProfiler(PlatformThreadId thread_id,
                         const SamplingParams& params);
+  // Creates a profiler that sends completed profiles to |completed_callback|.
+  StackSamplingProfiler(PlatformThreadId thread_id,
+                        const SamplingParams& params,
+                        CompletedCallback callback);
   ~StackSamplingProfiler();
 
   // 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.
   void Stop();
 
-  // Moves all pending call stack profiles from internal storage to
-  // |profiles|. This function is thread safe.
+  // Sets a callback to process profiles collected by profiler instances without
+  // a completed callback. Profiles are queued internally until a non-null
+  // callback is provided to this function,
   //
-  // ***This is intended for use only by UMA.*** Callers who want to process the
-  // collected profiles should use SetCustomCompletedCallback.
-  static void GetPendingProfiles(CallStackProfiles* call_stack_profiles);
-
-  // By default, collected call stack profiles are stored internally and can be
-  // retrieved by GetPendingProfiles. If a callback is provided via this
-  // function, however, it is called with the collected profiles instead.
-  void set_custom_completed_callback(CompletedCallback callback) {
-    custom_completed_callback_ = callback;
-  }
+  // The callback is typically called on a thread created by the profiler.  If
+  // completed profiles are queued when set, however, it will also be called
+  // immediately on the calling thread.
+  static void SetDefaultCompletedCallback(CompletedCallback callback);
 
  private:
   // SamplingThread is a separate thread used to suspend and sample stacks from
   // the target thread.
   class SamplingThread : public PlatformThread::Delegate {
    public:
     // Samples stacks using |native_sampler|. When complete, invokes
     // |completed_callback| with the collected call stack profiles.
     // |completed_callback| must be callable on any thread.
     SamplingThread(scoped_ptr<NativeStackSampler> native_sampler,
@@ skipping 17 matching lines @@
     // only full bursts.
     void CollectProfiles(CallStackProfiles* profiles);
 
     scoped_ptr<NativeStackSampler> native_sampler_;
     const SamplingParams params_;
 
     // If Stop() is called, it signals this event to force the sampling to
     // terminate before all the samples specified in |params_| are collected.
     WaitableEvent stop_event_;
 
-    CompletedCallback completed_callback_;
+    const CompletedCallback completed_callback_;
 
     DISALLOW_COPY_AND_ASSIGN(SamplingThread);
   };
 
   // The thread whose stack will be sampled.
   PlatformThreadId thread_id_;
 
   const SamplingParams params_;
 
   scoped_ptr<SamplingThread> sampling_thread_;
+  PlatformThreadHandle sampling_thread_handle_;
 
-  CompletedCallback custom_completed_callback_;
+  const CompletedCallback completed_callback_;
 
   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_