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 <algorithm>
 #include <cstdlib>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ 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) {
+Optional<StackSamplingProfiler::SamplingParams> SaveProfiles(
+    CallStackProfiles* profiles,
+    CallStackProfiles pending_profiles) {
   *profiles = std::move(pending_profiles);
+  return Optional<StackSamplingProfiler::SamplingParams>();
 }
 
 // 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) {
+Optional<StackSamplingProfiler::SamplingParams> SaveProfilesAndSignalEvent(
+    CallStackProfiles* profiles,
+    WaitableEvent* event,
+    CallStackProfiles pending_profiles) {
   *profiles = std::move(pending_profiles);
   event->Signal();
+  return Optional<StackSamplingProfiler::SamplingParams>();
+}
+
+// Similar to SaveProfilesAndSignalEvent(), but will schedule a second
+// collection after the first call back.
+Optional<StackSamplingProfiler::SamplingParams> SaveProfilesAndReschedule(
+    std::vector<CallStackProfiles>* profiles,
+    WaitableEvent* event,
+    CallStackProfiles pending_profiles) {
+  profiles->push_back(std::move(pending_profiles));
+
+  event->Signal();
+
+  if (profiles->size() == 2)
+    return Optional<StackSamplingProfiler::SamplingParams>();
+
+  StackSamplingProfiler::SamplingParams sampling_params;
+  sampling_params.initial_delay = base::TimeDelta::FromMilliseconds(100);
+  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 sampling_params;
 }
 
 // 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 664 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());
   });
 }
 
+PROFILER_TEST_F(StackSamplingProfilerTest, RescheduledByCallback) {
+  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::AUTOMATIC,
+                                     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.
 PROFILER_TEST_F(StackSamplingProfilerTest, CanRunMultipleProfilers) {
   SamplingParams params;
   params.sampling_interval = TimeDelta::FromMilliseconds(0);
   params.samples_per_burst = 1;
 
   std::vector<CallStackProfile> profiles;
   CaptureProfiles(params, AVeryLongTimeDelta(), &profiles);
   ASSERT_EQ(1u, profiles.size());
 
@@ skipping 463 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