Make stack sampling profiler sample beyond startup.

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/optional.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;
 
@@ skipping 179 matching lines @@
     // was started between when the idle-shutdown was initiated and when it
     // runs.
     static void PerformSamplingThreadIdleShutdown(
         bool simulate_intervening_start);
   };
 
   // The callback type used to collect completed profiles. The passed |profiles|
   // are move-only. Other threads, including the UI thread, may block on
   // callback completion so this should run as quickly as possible.
   //
+  // After collection completion, the callback may instruct the profiler to do
+  // additional collection(s) by returning a SamplingParams object to indicate
+  // collection should be started again.
+  //
   // 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 the moved (i.e. std::move) profiles is the
   // thread-safe callback implementation.
-  using CompletedCallback = Callback<void(CallStackProfiles)>;
+  using CompletedCallback =
+      Callback<Optional<SamplingParams>(CallStackProfiles)>;
 
   // Creates a profiler for the CURRENT thread that sends completed profiles
   // to |callback|. An optional |test_delegate| can be supplied by tests.
   // The caller must ensure that this object gets destroyed before the current
   // thread exits.
   StackSamplingProfiler(
       const SamplingParams& params,
       const CompletedCallback& callback,
       NativeStackSamplerTestDelegate* test_delegate = nullptr);
 
@@ skipping 57 matching lines @@
   const CompletedCallback completed_callback_;
 
   // This starts "signaled", is reset when sampling begins, and is signaled
   // when that sampling is complete and the callback done.
   WaitableEvent profiling_inactive_;
 
   // Object that does the native sampling. This is created during construction
   // and later passed to the sampling thread when profiling is started.
   std::unique_ptr<NativeStackSampler> native_sampler_;
 
-  // An ID uniquely identifying this collection to the sampling thread. This
+  // An ID uniquely identifying this profiler to the sampling thread. This
   // will be an internal "null" value when no collection has been started.
-  int collection_id_;
+  int profiler_id_;
 
   // Stored until it can be passed to the NativeStackSampler created in Start().
   NativeStackSamplerTestDelegate* const test_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(StackSamplingProfiler);
 };
 
 // These operators permit types to be compared and used in a map of Samples, as
 // done in tests and by the metrics provider code.
 BASE_EXPORT bool operator==(const StackSamplingProfiler::Module& a,
                             const StackSamplingProfiler::Module& b);
 BASE_EXPORT bool operator==(const StackSamplingProfiler::Sample& a,
                             const StackSamplingProfiler::Sample& b);
 BASE_EXPORT bool operator!=(const StackSamplingProfiler::Sample& a,
                             const StackSamplingProfiler::Sample& b);
 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_