Support parallel captures from the StackSamplingProfiler.

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 <utility>
 
@@ skipping 864 matching lines @@
 // are ignored.
 #if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
 #define MAYBE_ConcurrentProfiling ConcurrentProfiling
 #else
 #define MAYBE_ConcurrentProfiling DISABLED_ConcurrentProfiling
 #endif
 TEST(StackSamplingProfilerTest, MAYBE_ConcurrentProfiling) {
   WithTargetThread([](PlatformThreadId target_thread_id) {
     SamplingParams params[2];
     params[0].initial_delay = TimeDelta::FromMilliseconds(10);
-    params[0].sampling_interval = TimeDelta::FromMilliseconds(0);
-    params[0].samples_per_burst = 1;
+    params[0].sampling_interval = TimeDelta::FromMilliseconds(1);
+    params[0].samples_per_burst = 10;
 
-    params[1].sampling_interval = TimeDelta::FromMilliseconds(0);
-    params[1].samples_per_burst = 1;
+    params[0].initial_delay = TimeDelta::FromMilliseconds(10);
+    params[1].sampling_interval = TimeDelta::FromMilliseconds(1);
+    params[1].samples_per_burst = 10;
 
     CallStackProfiles profiles[2];
     ScopedVector<WaitableEvent> sampling_completed;
     ScopedVector<StackSamplingProfiler> profiler;
     for (int i = 0; i < 2; ++i) {
       sampling_completed.push_back(
           new WaitableEvent(WaitableEvent::ResetPolicy::AUTOMATIC,
                             WaitableEvent::InitialState::NOT_SIGNALED));
       const StackSamplingProfiler::CompletedCallback callback =
           Bind(&SaveProfilesAndSignalEvent, Unretained(&profiles[i]),
                Unretained(sampling_completed[i]));
       profiler.push_back(
           new StackSamplingProfiler(target_thread_id, params[i], callback));
     }
 
     profiler[0]->Start();
     profiler[1]->Start();
 
     // Wait for one profiler to finish.
     size_t completed_profiler =
         WaitableEvent::WaitMany(&sampling_completed[0], 2);
     EXPECT_EQ(1u, profiles[completed_profiler].size());
 
     size_t other_profiler = 1 - completed_profiler;
-    // Give the other profiler a chance to run and observe that it hasn't.
-    EXPECT_FALSE(sampling_completed[other_profiler]->TimedWait(
-        TimeDelta::FromMilliseconds(25)));
-
-    // Start the other profiler again and it should run.
-    profiler[other_profiler]->Start();
-    sampling_completed[other_profiler]->Wait();
-    EXPECT_EQ(1u, profiles[other_profiler].size());
+    // Give the other profiler a chance to finish and verify it does no.
+    EXPECT_TRUE(sampling_completed[other_profiler]->TimedWait(
+        TimeDelta::FromMilliseconds(250)));
   });
 }
 
 // Checks that a stack that runs through another library produces a stack with
 // the expected functions.
 #if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
 #define MAYBE_OtherLibrary OtherLibrary
 #else
 #define MAYBE_OtherLibrary DISABLED_OtherLibrary
 #endif
@@ skipping 77 matching lines @@
 #if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
 #define MAYBE_UnloadedLibrary UnloadedLibrary
 #else
 #define MAYBE_UnloadedLibrary DISABLED_UnloadedLibrary
 #endif
 TEST(StackSamplingProfilerTest, MAYBE_UnloadedLibrary) {
   TestLibraryUnload(true);
 }
 
 }  // namespace base