Make stack sampling profiler sample beyond startup.

base/profiler/stack_sampling_profiler_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <cstdlib>
 #include <memory>
 #include <utility>
@@ skipping 298 matching lines @@
     PlatformThread::Sleep(TimeDelta::FromMilliseconds(1));
   }
 #elif defined(OS_MACOSX)
 // Unloading a library on the Mac is synchronous.
 #else
   NOTIMPLEMENTED();
 #endif
 }
 
 // Called on the profiler thread when complete, to collect profiles.
-void SaveProfiles(CallStackProfiles* profiles,
-                  CallStackProfiles pending_profiles) {
+bool SaveProfiles(CallStackProfiles* profiles,
+                  CallStackProfiles pending_profiles,
+                  StackSamplingProfiler::SamplingParams* sampling_params) {
   *profiles = std::move(pending_profiles);
+  return false;
 }
 
 // Called on the profiler thread when complete. Collects profiles produced by
 // the profiler, and signals an event to allow the main thread to know that that
 // the profiler is done.
-void SaveProfilesAndSignalEvent(CallStackProfiles* profiles,
-                                WaitableEvent* event,
-                                CallStackProfiles pending_profiles) {
+bool SaveProfilesAndSignalEvent(
+    CallStackProfiles* profiles,
+    WaitableEvent* event,
+    CallStackProfiles pending_profiles,
+    StackSamplingProfiler::SamplingParams* sampling_params) {
   *profiles = std::move(pending_profiles);
   event->Signal();
+  return false;
+}
+
+// Similar to SaveProfilesAndSignalEvent(), but will schedule a second
+// collection after the first call back.
+bool SaveProfilesAndReschedule(
+    std::vector<CallStackProfiles>* profiles,
+    WaitableEvent* event,
+    CallStackProfiles pending_profiles,
+    StackSamplingProfiler::SamplingParams* sampling_params) {
+  profiles->push_back(std::move(pending_profiles));
+
+  event->Signal();
+  event->Reset();
+
+  if (profiles->size() == 2)
+    return false;
+
+  sampling_params->initial_delay = base::TimeDelta::FromSeconds(1);
+  sampling_params->bursts = 1;
+  sampling_params->samples_per_burst = 1;
+  // Below are unused:
+  sampling_params->burst_interval = base::TimeDelta::FromMilliseconds(0);
+  sampling_params->sampling_interval = base::TimeDelta::FromMilliseconds(0);
+  return true;
 }
 
 // Executes the function with the target thread running and executing within
 // SignalAndWaitUntilSignaled(). Performs all necessary target thread startup
 // and shutdown work before and afterward.
 template <class Function>
 void WithTargetThread(Function function,
                       const StackConfiguration& stack_config) {
   TargetThread target_thread(stack_config);
   PlatformThreadHandle target_thread_handle;
@@ skipping 713 matching lines @@
     // Ensure a second request will run and not block.
     sampling_completed.Reset();
     profiles.clear();
     profiler.Start();
     sampling_completed.Wait();
     profiler.Stop();
     ASSERT_EQ(1u, profiles.size());
   });
 }
 
+TEST_F(StackSamplingProfilerTest, RescheduledByCallback) {

[Alexei Svitkine (slow), 2017/06/20 20:57:39]

Note: I'll need to rebase this on my other CL.

+  WithTargetThread([](PlatformThreadId target_thread_id) {
+    SamplingParams params;
+    params.sampling_interval = TimeDelta::FromMilliseconds(0);
+    params.samples_per_burst = 1;
+
+    std::vector<CallStackProfiles> profiles;
+    WaitableEvent sampling_completed(WaitableEvent::ResetPolicy::MANUAL,
+                                     WaitableEvent::InitialState::NOT_SIGNALED);
+    const StackSamplingProfiler::CompletedCallback callback =
+        Bind(&SaveProfilesAndReschedule, Unretained(&profiles),
+             Unretained(&sampling_completed));
+    StackSamplingProfiler profiler(target_thread_id, params, callback);
+
+    // Start once and wait for it to be completed.
+    profiler.Start();
+    sampling_completed.Wait();
+    ASSERT_EQ(1u, profiles.size());
+    ASSERT_EQ(1u, profiles[0].size());
+
+    // Now, wait for the second callback call.
+    sampling_completed.Wait();
+    profiler.Stop();
+    ASSERT_EQ(2u, profiles.size());
+    ASSERT_EQ(1u, profiles[1].size());
+  });
+}
+
 // Checks that the different profilers may be run.
 #if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
 #define MAYBE_CanRunMultipleProfilers CanRunMultipleProfilers
 #else
 #define MAYBE_CanRunMultipleProfilers DISABLED_CanRunMultipleProfilers
 #endif
 TEST_F(StackSamplingProfilerTest, MAYBE_CanRunMultipleProfilers) {
   SamplingParams params;
   params.sampling_interval = TimeDelta::FromMilliseconds(0);
   params.samples_per_burst = 1;
@@ skipping 523 matching lines @@
     EXPECT_EQ(9u, profiler_thread1.profiles()[0].samples.size());
     ASSERT_EQ(1u, profiler_thread2.profiles().size());
     EXPECT_EQ(8u, profiler_thread2.profiles()[0].samples.size());
 
     profiler_thread1.Join();
     profiler_thread2.Join();
   });
 }
 
 }  // namespace base