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 <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
-#include "base/message_loop/message_loop.h"
 #include "base/native_library.h"
 #include "base/path_service.h"
 #include "base/profiler/native_stack_sampler.h"
 #include "base/profiler/stack_sampling_profiler.h"
 #include "base/run_loop.h"
 #include "base/scoped_native_library.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
+#include "base/threading/simple_thread.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_WIN)
 #include <intrin.h>
 #include <malloc.h>
 #include <windows.h>
 #else
 #include <alloca.h>
@@ skipping 306 matching lines @@
   target_thread.SignalThreadToFinish();
 
   PlatformThread::Join(target_thread_handle);
 }
 
 template <class Function>
 void WithTargetThread(Function function) {
   WithTargetThread(function, StackConfiguration(StackConfiguration::NORMAL));
 }
 
+struct TestProfilerInfo {
+  TestProfilerInfo(PlatformThreadId thread_id,
+                   const SamplingParams& params,
+                   NativeStackSamplerTestDelegate* delegate = nullptr)
+      : completed(WaitableEvent::ResetPolicy::MANUAL,
+                  WaitableEvent::InitialState::NOT_SIGNALED),
+        profiler(thread_id,
+                 params,
+                 Bind(&SaveProfilesAndSignalEvent,
+                      Unretained(&profiles),
+                      Unretained(&completed)),
+                 delegate) {}
+
+  void Reset() {
+    profiler.Stop();
+    completed.Wait();
+    completed.Reset();
+    profiles.clear();
+  }
+
+  // The order here is important to ensure objects being referenced don't get
+  // destructed until after the objects referencing them.
+  CallStackProfiles profiles;
+  WaitableEvent completed;
+  StackSamplingProfiler profiler;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TestProfilerInfo);
+};
+
+// Creates multiple profilers based on a vector of parameters.
+std::vector<std::unique_ptr<TestProfilerInfo>> CreateProfilers(
+    PlatformThreadId target_thread_id,
+    const std::vector<SamplingParams>& params) {
+  DCHECK(!params.empty());
+
+  std::vector<std::unique_ptr<TestProfilerInfo>> profilers;
+  for (size_t i = 0; i < params.size(); ++i) {
+    profilers.push_back(
+        MakeUnique<TestProfilerInfo>(target_thread_id, params[i]));
+  }
+
+  return profilers;
+}
+
 // Captures profiles as specified by |params| on the TargetThread, and returns
 // them in |profiles|. Waits up to |profiler_wait_time| for the profiler to
 // complete.
 void CaptureProfiles(const SamplingParams& params, TimeDelta profiler_wait_time,
                      CallStackProfiles* profiles) {
-  profiles->clear();
-
   WithTargetThread([&params, profiles,
                     profiler_wait_time](PlatformThreadId target_thread_id) {
-    WaitableEvent sampling_thread_completed(
-        WaitableEvent::ResetPolicy::MANUAL,
-        WaitableEvent::InitialState::NOT_SIGNALED);
-    const StackSamplingProfiler::CompletedCallback callback =
-        Bind(&SaveProfilesAndSignalEvent, Unretained(profiles),
-             Unretained(&sampling_thread_completed));
-    StackSamplingProfiler profiler(target_thread_id, params, callback);
-    profiler.Start();
-    sampling_thread_completed.TimedWait(profiler_wait_time);
-    profiler.Stop();
-    sampling_thread_completed.Wait();
+    TestProfilerInfo info(target_thread_id, params);
+    info.profiler.Start();
+    info.completed.TimedWait(profiler_wait_time);
+    info.profiler.Stop();
+    info.completed.Wait();
+
+    *profiles = std::move(info.profiles);
   });
 }
 
+// Waits for one of multiple samplings to complete.
+size_t WaitForSamplingComplete(
+    const std::vector<std::unique_ptr<TestProfilerInfo>>& infos) {
+  // Map unique_ptrs to something that WaitMany can accept.
+  std::vector<WaitableEvent*> sampling_completed_rawptrs(infos.size());
+  std::transform(infos.begin(), infos.end(), sampling_completed_rawptrs.begin(),
+                 [](const std::unique_ptr<TestProfilerInfo>& info) {
+                   return &info.get()->completed;
+                 });
+  // Wait for one profiler to finish.
+  return WaitableEvent::WaitMany(sampling_completed_rawptrs.data(),
+                                 sampling_completed_rawptrs.size());
+}
+
 // If this executable was linked with /INCREMENTAL (the default for non-official
 // debug and release builds on Windows), function addresses do not correspond to
 // function code itself, but instead to instructions in the Incremental Link
 // Table that jump to the functions. Checks for a jump instruction and if
 // present does a little decompilation to find the function's actual starting
 // address.
 const void* MaybeFixupFunctionAddressForILT(const void* function_address) {
 #if defined(_WIN64)
   const unsigned char* opcode =
       reinterpret_cast<const unsigned char*>(function_address);
@@ skipping 50 matching lines @@
 // asynchronous library loading has completed before walking the stack. If
 // false, the unloading may still be occurring during the stack walk.
 void TestLibraryUnload(bool wait_until_unloaded) {
   // Test delegate that supports intervening between the copying of the stack
   // and the walking of the stack.
   class StackCopiedSignaler : public NativeStackSamplerTestDelegate {
    public:
     StackCopiedSignaler(WaitableEvent* stack_copied,
                         WaitableEvent* start_stack_walk,
                         bool wait_to_walk_stack)
-        : stack_copied_(stack_copied), start_stack_walk_(start_stack_walk),
-          wait_to_walk_stack_(wait_to_walk_stack) {
-    }
+        : stack_copied_(stack_copied),
+          start_stack_walk_(start_stack_walk),
+          wait_to_walk_stack_(wait_to_walk_stack) {}
 
     void OnPreStackWalk() override {
       stack_copied_->Signal();
       if (wait_to_walk_stack_)
         start_stack_walk_->Wait();
     }
 
    private:
     WaitableEvent* const stack_copied_;
     WaitableEvent* const start_stack_walk_;
@@ skipping 110 matching lines @@
     // TargetThread::SignalAndWaitUntilSignaled
     // TargetThread::OtherLibraryCallback
     // InvokeCallbackFunction (in other library)
     // TargetThread::CallThroughOtherLibrary
     EXPECT_EQ(3, other_library_frame - end_frame)
         << "Stack:\n"
         << FormatSampleForDiagnosticOutput(sample, profile.modules);
   }
 }
 
+// Provide a suitable (and clean) environment for the tests below. All tests
+// must use this class to ensure that proper clean-up is done and thus be
+// usable in a later test.
+class StackSamplingProfilerTest : public testing::Test {
+ public:
+  void SetUp() override {
+    // The idle-shutdown time is too long for convenient (and accurate) testing.
+    // That behavior is checked instead by artificially triggering it through
+    // the TestAPI.
+    StackSamplingProfiler::TestAPI::DisableIdleShutdown();
+  }
+
+  void TearDown() override {
+    // Be a good citizen and clean up after ourselves. This also re-enables the
+    // idle-shutdown behavior.
+    StackSamplingProfiler::TestAPI::Reset();
+  }
+};
+
 }  // namespace
 
 // Checks that the basic expected information is present in a sampled call stack
 // profile.
 #if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
 #define MAYBE_Basic Basic
 #else
 #define MAYBE_Basic DISABLED_Basic
 #endif
-TEST(StackSamplingProfilerTest, MAYBE_Basic) {
-  StackSamplingProfiler::ResetAnnotationsForTesting();
-
+TEST_F(StackSamplingProfilerTest, MAYBE_Basic) {
   SamplingParams params;
   params.sampling_interval = TimeDelta::FromMilliseconds(0);
   params.samples_per_burst = 1;
 
   std::vector<CallStackProfile> profiles;
   CaptureProfiles(params, AVeryLongTimeDelta(), &profiles);
 
   // Check that the profile and samples sizes are correct, and the module
   // indices are in range.
   ASSERT_EQ(1u, profiles.size());
@@ skipping 22 matching lines @@
   EXPECT_TRUE(PathService::Get(FILE_EXE, &executable_path));
   EXPECT_EQ(executable_path, profile.modules[loc->module_index].filename);
 }
 
 // Checks that annotations are recorded in samples.
 #if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
 #define MAYBE_Annotations Annotations
 #else
 #define MAYBE_Annotations DISABLED_Annotations
 #endif
-TEST(StackSamplingProfilerTest, MAYBE_Annotations) {
-  StackSamplingProfiler::ResetAnnotationsForTesting();
-
+TEST_F(StackSamplingProfilerTest, MAYBE_Annotations) {
   SamplingParams params;
   params.sampling_interval = TimeDelta::FromMilliseconds(0);
   params.samples_per_burst = 1;
 
   // Check that a run picks up annotations.
   StackSamplingProfiler::SetProcessMilestone(1);
   std::vector<CallStackProfile> profiles1;
   CaptureProfiles(params, AVeryLongTimeDelta(), &profiles1);
   ASSERT_EQ(1u, profiles1.size());
   const CallStackProfile& profile1 = profiles1[0];
@@ skipping 13 matching lines @@
   EXPECT_EQ(sample1.process_milestones | (1u << 2), sample2.process_milestones);
 }
 
 // Checks that the profiler handles stacks containing dynamically-allocated
 // stack memory.
 #if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
 #define MAYBE_Alloca Alloca
 #else
 #define MAYBE_Alloca DISABLED_Alloca
 #endif
-TEST(StackSamplingProfilerTest, MAYBE_Alloca) {
+TEST_F(StackSamplingProfilerTest, MAYBE_Alloca) {
   SamplingParams params;
   params.sampling_interval = TimeDelta::FromMilliseconds(0);
   params.samples_per_burst = 1;
 
   std::vector<CallStackProfile> profiles;
   WithTargetThread(
       [&params, &profiles](PlatformThreadId target_thread_id) {
         WaitableEvent sampling_thread_completed(
             WaitableEvent::ResetPolicy::MANUAL,
             WaitableEvent::InitialState::NOT_SIGNALED);
@@ skipping 32 matching lines @@
              reinterpret_cast<const void*>(&TargetThread::CallWithAlloca))
       << " was not found in stack:\n"
       << FormatSampleForDiagnosticOutput(sample, profile.modules);
 
   // These frames should be adjacent on the stack.
   EXPECT_EQ(1, alloca_frame - end_frame)
       << "Stack:\n"
       << FormatSampleForDiagnosticOutput(sample, profile.modules);
 }
 
-// Checks that the fire-and-forget interface works.
-#if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
-#define MAYBE_StartAndRunAsync StartAndRunAsync
-#else
-#define MAYBE_StartAndRunAsync DISABLED_StartAndRunAsync
-#endif
-TEST(StackSamplingProfilerTest, MAYBE_StartAndRunAsync) {
-  // StartAndRunAsync requires the caller to have a message loop.
-  MessageLoop message_loop;
-
-  SamplingParams params;
-  params.samples_per_burst = 1;
-
-  CallStackProfiles profiles;
-  WithTargetThread([&params, &profiles](PlatformThreadId target_thread_id) {
-    WaitableEvent sampling_thread_completed(
-        WaitableEvent::ResetPolicy::AUTOMATIC,
-        WaitableEvent::InitialState::NOT_SIGNALED);
-    const StackSamplingProfiler::CompletedCallback callback =
-        Bind(&SaveProfilesAndSignalEvent, Unretained(&profiles),
-             Unretained(&sampling_thread_completed));
-    StackSamplingProfiler::StartAndRunAsync(target_thread_id, params, callback);
-    RunLoop().RunUntilIdle();
-    sampling_thread_completed.Wait();
-  });
-
-  ASSERT_EQ(1u, profiles.size());
-}
-
 // Checks that the expected number of profiles and samples are present in the
 // call stack profiles produced.
 #if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
 #define MAYBE_MultipleProfilesAndSamples MultipleProfilesAndSamples
 #else
 #define MAYBE_MultipleProfilesAndSamples DISABLED_MultipleProfilesAndSamples
 #endif
-TEST(StackSamplingProfilerTest, MAYBE_MultipleProfilesAndSamples) {
+TEST_F(StackSamplingProfilerTest, MAYBE_MultipleProfilesAndSamples) {
   SamplingParams params;
   params.burst_interval = params.sampling_interval =
       TimeDelta::FromMilliseconds(0);
   params.bursts = 2;
   params.samples_per_burst = 3;
 
   std::vector<CallStackProfile> profiles;
   CaptureProfiles(params, AVeryLongTimeDelta(), &profiles);
 
   ASSERT_EQ(2u, profiles.size());
   EXPECT_EQ(3u, profiles[0].samples.size());
   EXPECT_EQ(3u, profiles[1].samples.size());
 }
 
+// Checks that a profiler can stop/destruct without ever having started.
+#if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
+#define MAYBE_StopWithoutStarting StopWithoutStarting
+#else
+#define MAYBE_StopWithoutStarting DISABLED_StopWithoutStarting
+#endif
+TEST_F(StackSamplingProfilerTest, MAYBE_StopWithoutStarting) {
+  WithTargetThread([](PlatformThreadId target_thread_id) {
+    SamplingParams params;
+    params.sampling_interval = TimeDelta::FromMilliseconds(0);
+    params.samples_per_burst = 1;
+
+    CallStackProfiles profiles;
+    WaitableEvent sampling_completed(WaitableEvent::ResetPolicy::MANUAL,
+                                     WaitableEvent::InitialState::NOT_SIGNALED);
+    const StackSamplingProfiler::CompletedCallback callback =
+        Bind(&SaveProfilesAndSignalEvent, Unretained(&profiles),
+             Unretained(&sampling_completed));
+    StackSamplingProfiler profiler(target_thread_id, params, callback);
+
+    profiler.Stop();  // Constructed but never started.
+    EXPECT_FALSE(sampling_completed.IsSignaled());
+  });
+}
+
+// Checks that its okay to stop a profiler before it finishes even when the
+// sampling thread continues to run.
+#if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
+#define MAYBE_StopSafely StopSafely
+#else
+#define MAYBE_StopSafely DISABLED_StopSafely
+#endif
+TEST_F(StackSamplingProfilerTest, MAYBE_StopSafely) {
+  // Test delegate that counts samples.
+  class SampleRecordedCounter : public NativeStackSamplerTestDelegate {
+   public:
+    SampleRecordedCounter() {}
+
+    void OnPreStackWalk() override {
+      AutoLock lock(lock_);
+      ++count_;
+    }
+
+    size_t Get() {
+      AutoLock lock(lock_);
+      return count_;
+    }
+
+   private:
+    Lock lock_;
+    size_t count_ = 0;
+  };
+
+  WithTargetThread([](PlatformThreadId target_thread_id) {
+    SamplingParams params[2];
+
+    // Providing an initial delay makes it more likely that both will be
+    // scheduled before either starts to run. Once started, samples will
+    // run ordered by their scheduled, interleaved times regardless of
+    // whatever interval the thread wakes up.
+    params[0].initial_delay = TimeDelta::FromMilliseconds(10);
+    params[0].sampling_interval = TimeDelta::FromMilliseconds(1);
+    params[0].samples_per_burst = 100000;
+
+    params[1].initial_delay = TimeDelta::FromMilliseconds(10);
+    params[1].sampling_interval = TimeDelta::FromMilliseconds(1);
+    params[1].samples_per_burst = 100000;
+
+    SampleRecordedCounter samples_recorded[2];

[Mike Wittman, 2017/04/04 17:59:52]

nit: arraysize(params)

[bcwhite, 2017/04/06 16:18:50]

Done.

+
+    TestProfilerInfo profiler_info0(target_thread_id, params[0],
+                                    &samples_recorded[0]);
+    TestProfilerInfo profiler_info1(target_thread_id, params[1],
+                                    &samples_recorded[1]);
+
+    profiler_info0.profiler.Start();
+    profiler_info1.profiler.Start();
+
+    // Wait for both to start accumulating samples. Using a WaitableEvent is
+    // possible but gets complicated later on because there's no way of knowing
+    // if 0 or 1 additional sample will be taken after Stop() and thus no way
+    // of knowing how many Wait() calls to make on it.
+    while (samples_recorded[0].Get() == 0 || samples_recorded[1].Get() == 0)
+      PlatformThread::Sleep(TimeDelta::FromMilliseconds(1));
+
+    // Ensure that the first sampler can be safely stopped while the second
+    // continues to run. The stopped first profiler will still have a
+    // PerformCollectionTask pending that will do nothing when executed because
+    // the collection will have been removed by Stop().
+    profiler_info0.profiler.Stop();
+    profiler_info0.completed.Wait();
+    size_t count0 = samples_recorded[0].Get();
+    size_t count1 = samples_recorded[1].Get();
+
+    // Waiting for the second sampler to collect a couple samples ensures that
+    // the pending PerformCollectionTask for the first has executed because
+    // tasks are always ordered by their next scheduled time.
+    while (samples_recorded[1].Get() < count1 + 2)
+      PlatformThread::Sleep(TimeDelta::FromMilliseconds(1));
+
+    // Ensure that the first profiler didn't do anything since it was stopped.
+    EXPECT_EQ(count0, samples_recorded[0].Get());
+  });
+}
+
 // Checks that no call stack profiles are captured if the profiling is stopped
 // during the initial delay.
 #if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
 #define MAYBE_StopDuringInitialDelay StopDuringInitialDelay
 #else
 #define MAYBE_StopDuringInitialDelay DISABLED_StopDuringInitialDelay
 #endif
-TEST(StackSamplingProfilerTest, MAYBE_StopDuringInitialDelay) {
+TEST_F(StackSamplingProfilerTest, MAYBE_StopDuringInitialDelay) {
   SamplingParams params;
   params.initial_delay = TimeDelta::FromSeconds(60);
 
   std::vector<CallStackProfile> profiles;
   CaptureProfiles(params, TimeDelta::FromMilliseconds(0), &profiles);
 
   EXPECT_TRUE(profiles.empty());
 }
 
 // Checks that the single completed call stack profile is captured if the
 // profiling is stopped between bursts.
 #if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
 #define MAYBE_StopDuringInterBurstInterval StopDuringInterBurstInterval
 #else
 #define MAYBE_StopDuringInterBurstInterval DISABLED_StopDuringInterBurstInterval
 #endif
-TEST(StackSamplingProfilerTest, MAYBE_StopDuringInterBurstInterval) {
+TEST_F(StackSamplingProfilerTest, MAYBE_StopDuringInterBurstInterval) {
   SamplingParams params;
   params.sampling_interval = TimeDelta::FromMilliseconds(0);
   params.burst_interval = TimeDelta::FromSeconds(60);
   params.bursts = 2;
   params.samples_per_burst = 1;
 
   std::vector<CallStackProfile> profiles;
   CaptureProfiles(params, TimeDelta::FromMilliseconds(50), &profiles);
 
   ASSERT_EQ(1u, profiles.size());
   EXPECT_EQ(1u, profiles[0].samples.size());
 }
 
-// Checks that incomplete call stack profiles are captured.
+// Checks that tasks can be stopped before completion and incomplete call stack
+// profiles are captured.
 #if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
 #define MAYBE_StopDuringInterSampleInterval StopDuringInterSampleInterval
 #else
 #define MAYBE_StopDuringInterSampleInterval \
   DISABLED_StopDuringInterSampleInterval
 #endif
-TEST(StackSamplingProfilerTest, MAYBE_StopDuringInterSampleInterval) {
-  SamplingParams params;
-  params.sampling_interval = TimeDelta::FromSeconds(60);
-  params.samples_per_burst = 2;
+TEST_F(StackSamplingProfilerTest, MAYBE_StopDuringInterSampleInterval) {
+  // Test delegate that counts samples.
+  class SampleRecordedEvent : public NativeStackSamplerTestDelegate {
+   public:
+    SampleRecordedEvent()
+        : sample_recorded_(WaitableEvent::ResetPolicy::MANUAL,
+                           WaitableEvent::InitialState::NOT_SIGNALED) {}
 
-  std::vector<CallStackProfile> profiles;
-  CaptureProfiles(params, TimeDelta::FromMilliseconds(50), &profiles);
+    void OnPreStackWalk() override { sample_recorded_.Signal(); }
 
-  ASSERT_EQ(1u, profiles.size());
-  EXPECT_EQ(1u, profiles[0].samples.size());
+    void WaitForSample() { sample_recorded_.Wait(); }
+
+   private:
+    WaitableEvent sample_recorded_;
+  };
+
+  WithTargetThread([](PlatformThreadId target_thread_id) {
+    SamplingParams params;
+
+    params.sampling_interval = AVeryLongTimeDelta();
+    params.samples_per_burst = 2;
+
+    SampleRecordedEvent samples_recorded;
+    TestProfilerInfo profiler_info(target_thread_id, params, &samples_recorded);
+
+    profiler_info.profiler.Start();
+
+    // Wait for profiler to start accumulating samples.
+    samples_recorded.WaitForSample();
+
+    // Ensure that it can stop safely.
+    profiler_info.profiler.Stop();
+    profiler_info.completed.Wait();
+
+    ASSERT_EQ(1u, profiler_info.profiles.size());
+    EXPECT_EQ(1u, profiler_info.profiles[0].samples.size());
+  });
 }
 
 // Checks that we can destroy the profiler while profiling.
 #if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
 #define MAYBE_DestroyProfilerWhileProfiling DestroyProfilerWhileProfiling
 #else
 #define MAYBE_DestroyProfilerWhileProfiling \
   DISABLED_DestroyProfilerWhileProfiling
 #endif
-TEST(StackSamplingProfilerTest, MAYBE_DestroyProfilerWhileProfiling) {
+TEST_F(StackSamplingProfilerTest, MAYBE_DestroyProfilerWhileProfiling) {
   SamplingParams params;
   params.sampling_interval = TimeDelta::FromMilliseconds(10);
 
   CallStackProfiles profiles;
   WithTargetThread([&params, &profiles](PlatformThreadId target_thread_id) {
     std::unique_ptr<StackSamplingProfiler> profiler;
     profiler.reset(new StackSamplingProfiler(
         target_thread_id, params, Bind(&SaveProfiles, Unretained(&profiles))));
     profiler->Start();
     profiler.reset();
 
     // Wait longer than a sample interval to catch any use-after-free actions by
     // the profiler thread.
     PlatformThread::Sleep(TimeDelta::FromMilliseconds(50));
   });
 }
 
 // Checks that the same profiler may be run multiple times.
 #if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
 #define MAYBE_CanRunMultipleTimes CanRunMultipleTimes
 #else
 #define MAYBE_CanRunMultipleTimes DISABLED_CanRunMultipleTimes
 #endif
-TEST(StackSamplingProfilerTest, MAYBE_CanRunMultipleTimes) {
+TEST_F(StackSamplingProfilerTest, MAYBE_CanRunMultipleTimes) {
+  WithTargetThread([](PlatformThreadId target_thread_id) {
+    SamplingParams params;
+    params.sampling_interval = TimeDelta::FromMilliseconds(0);
+    params.samples_per_burst = 1;
+
+    CallStackProfiles profiles;
+    WaitableEvent sampling_completed(WaitableEvent::ResetPolicy::MANUAL,
+                                     WaitableEvent::InitialState::NOT_SIGNALED);
+    const StackSamplingProfiler::CompletedCallback callback =
+        Bind(&SaveProfilesAndSignalEvent, Unretained(&profiles),
+             Unretained(&sampling_completed));
+    StackSamplingProfiler profiler(target_thread_id, params, callback);
+
+    // Just start and stop to execute code paths.
+    profiler.Start();
+    profiler.Stop();
+    sampling_completed.Wait();
+
+    // 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());
+  });
+}
+
+// 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;
 
   std::vector<CallStackProfile> profiles;
   CaptureProfiles(params, AVeryLongTimeDelta(), &profiles);
   ASSERT_EQ(1u, profiles.size());
 
   profiles.clear();
   CaptureProfiles(params, AVeryLongTimeDelta(), &profiles);
   ASSERT_EQ(1u, profiles.size());
 }
 
-// Checks that requests to start profiling while another profile is taking place
-// 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];
+// Checks that a sampler can be started while another is running.
+#if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
+#define MAYBE_MultipleStart MultipleStart
+#else
+#define MAYBE_MultipleStart DISABLED_MultipleStart
+#endif
+TEST_F(StackSamplingProfilerTest, MAYBE_MultipleStart) {
+  WithTargetThread([](PlatformThreadId target_thread_id) {
+    std::vector<SamplingParams> params(2);
+
+    params[0].initial_delay = AVeryLongTimeDelta();
+    params[0].samples_per_burst = 1;
+
+    params[1].sampling_interval = TimeDelta::FromMilliseconds(1);
+    params[1].samples_per_burst = 1;
+
+    std::vector<std::unique_ptr<TestProfilerInfo>> profiler_infos =
+        CreateProfilers(target_thread_id, params);
+
+    profiler_infos[0]->profiler.Start();
+    profiler_infos[1]->profiler.Start();
+    profiler_infos[1]->completed.Wait();
+    EXPECT_EQ(1u, profiler_infos[1]->profiles.size());
+  });
+}
+
+// Checks that the sampling thread can shut down.
+#if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
+#define MAYBE_SamplerIdleShutdown SamplerIdleShutdown
+#else
+#define MAYBE_SamplerIdleShutdown DISABLED_SamplerIdleShutdown
+#endif
+TEST_F(StackSamplingProfilerTest, MAYBE_SamplerIdleShutdown) {
+  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());
+
+  // Capture thread should still be running at this point.
+  ASSERT_TRUE(StackSamplingProfiler::TestAPI::IsSamplingThreadRunning());
+
+  // Initiate an "idle" shutdown and ensure it happens. Idle-shutdown was
+  // disabled by the test fixture so the test will fail due to a timeout if
+  // it does not exit.
+  StackSamplingProfiler::TestAPI::PerformSamplingThreadIdleShutdown(false);
+
+  // While the shutdown has been initiated, the actual exit of the thread still
+  // happens asynchronously. Watch until the thread actually exits. This test
+  // will time-out in the case of failure.
+  while (StackSamplingProfiler::TestAPI::IsSamplingThreadRunning())
+    PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1));
+}
+
+// Checks that additional requests will restart a stopped profiler.
+#if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
+#define MAYBE_WillRestartSamplerAfterIdleShutdown \
+  WillRestartSamplerAfterIdleShutdown
+#else
+#define MAYBE_WillRestartSamplerAfterIdleShutdown \
+  DISABLED_WillRestartSamplerAfterIdleShutdown
+#endif
+TEST_F(StackSamplingProfilerTest, MAYBE_WillRestartSamplerAfterIdleShutdown) {
+  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());
+
+  // Capture thread should still be running at this point.
+  ASSERT_TRUE(StackSamplingProfiler::TestAPI::IsSamplingThreadRunning());
+
+  // Post a ShutdownTask on the sampling thread which, when executed, will
+  // mark the thread as EXITING and begin shut down of the thread.
+  StackSamplingProfiler::TestAPI::PerformSamplingThreadIdleShutdown(false);
+
+  // Ensure another capture will start the sampling thread and run.
+  profiles.clear();
+  CaptureProfiles(params, AVeryLongTimeDelta(), &profiles);
+  ASSERT_EQ(1u, profiles.size());
+  EXPECT_TRUE(StackSamplingProfiler::TestAPI::IsSamplingThreadRunning());
+}
+
+// Checks that it's safe to stop a task after it's completed and the sampling
+// thread has shut-down for being idle.
+#if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
+#define MAYBE_StopAfterIdleShutdown StopAfterIdleShutdown
+#else
+#define MAYBE_StopAfterIdleShutdown DISABLED_StopAfterIdleShutdown
+#endif
+TEST_F(StackSamplingProfilerTest, MAYBE_StopAfterIdleShutdown) {
+  WithTargetThread([](PlatformThreadId target_thread_id) {
+    SamplingParams params;
+
+    params.sampling_interval = TimeDelta::FromMilliseconds(1);
+    params.samples_per_burst = 1;
+
+    TestProfilerInfo profiler_info(target_thread_id, params);
+
+    profiler_info.profiler.Start();
+    profiler_info.completed.Wait();
+
+    // Capture thread should still be running at this point.
+    ASSERT_TRUE(StackSamplingProfiler::TestAPI::IsSamplingThreadRunning());
+
+    // Perform an idle shutdown.
+    StackSamplingProfiler::TestAPI::PerformSamplingThreadIdleShutdown(false);
+
+    // Stop should be safe though its impossible to know at this moment if the
+    // sampling thread has completely exited or will just "stop soon".
+    profiler_info.profiler.Stop();
+  });
+}
+
+// Checks that profilers can run both before and after the sampling thread has
+// started.
+#if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
+#define MAYBE_ProfileBeforeAndAfterSamplingThreadRunning \
+  ProfileBeforeAndAfterSamplingThreadRunning
+#else
+#define MAYBE_ProfileBeforeAndAfterSamplingThreadRunning \
+  DISABLED_ProfileBeforeAndAfterSamplingThreadRunning
+#endif
+TEST_F(StackSamplingProfilerTest,
+       MAYBE_ProfileBeforeAndAfterSamplingThreadRunning) {
+  WithTargetThread([](PlatformThreadId target_thread_id) {
+    std::vector<SamplingParams> params(2);
+
+    params[0].initial_delay = AVeryLongTimeDelta();
+    params[0].sampling_interval = TimeDelta::FromMilliseconds(1);
+    params[0].samples_per_burst = 1;
+
+    params[1].initial_delay = TimeDelta::FromMilliseconds(0);
+    params[1].sampling_interval = TimeDelta::FromMilliseconds(1);
+    params[1].samples_per_burst = 1;
+
+    std::vector<std::unique_ptr<TestProfilerInfo>> profiler_infos =
+        CreateProfilers(target_thread_id, params);
+
+    // First profiler is started when there has never been a sampling thread.
+    EXPECT_FALSE(StackSamplingProfiler::TestAPI::IsSamplingThreadRunning());
+    profiler_infos[0]->profiler.Start();
+    // Second profiler is started when sampling thread is already running.
+    EXPECT_TRUE(StackSamplingProfiler::TestAPI::IsSamplingThreadRunning());
+    profiler_infos[1]->profiler.Start();
+
+    // Only the second profiler should finish before test times out.
+    size_t completed_profiler = WaitForSamplingComplete(profiler_infos);
+    EXPECT_EQ(1U, completed_profiler);
+  });
+}
+
+// Checks that an idle-shutdown task will abort if a new profiler starts
+// between when it was posted and when it runs.
+#if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
+#define MAYBE_IdleShutdownAbort IdleShutdownAbort
+#else
+#define MAYBE_IdleShutdownAbort DISABLED_IdleShutdownAbort
+#endif
+TEST_F(StackSamplingProfilerTest, MAYBE_IdleShutdownAbort) {
+  WithTargetThread([](PlatformThreadId target_thread_id) {
+    SamplingParams params;
+
+    params.sampling_interval = TimeDelta::FromMilliseconds(1);
+    params.samples_per_burst = 1;
+
+    TestProfilerInfo profiler_info(target_thread_id, params);
+
+    profiler_info.profiler.Start();
+    profiler_info.completed.Wait();
+    EXPECT_EQ(1u, profiler_info.profiles.size());
+
+    // Perform an idle shutdown but simulate that a new capture is started
+    // before it can actually run.
+    StackSamplingProfiler::TestAPI::PerformSamplingThreadIdleShutdown(true);
+
+    // Though the shutdown-task has been executed, any actual exit of the
+    // thread is asynchronous so there is no way to detect that *didn't* exit
+    // except to wait a reasonable amount of time and then check. Since the
+    // thread was just running ("perform" blocked until it was), it should
+    // finish almost immediately and without any waiting for tasks or events.
+    PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(200));
+    EXPECT_TRUE(StackSamplingProfiler::TestAPI::IsSamplingThreadRunning());
+
+    // Ensure that it's still possible to run another sampler. Restarting the
+    // already defined sampler is fine.
+    profiler_info.Reset();

[Mike Wittman, 2017/04/04 17:59:52]

Now that we have the TestProfilerInfo struct it would be simpler just to create
a new TestProfilerInfo here and run that.

[bcwhite, 2017/04/06 16:18:49]

Done.

+    profiler_info.profiler.Start();
+    profiler_info.completed.Wait();
+    EXPECT_EQ(1u, profiler_info.profiles.size());
+  });
+}
+
+// Checks that synchronized multiple sampling requests execute in parallel.
+#if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
+#define MAYBE_ConcurrentProfiling_InSync ConcurrentProfiling_InSync
+#else
+#define MAYBE_ConcurrentProfiling_InSync DISABLED_ConcurrentProfiling_InSync
+#endif
+TEST_F(StackSamplingProfilerTest, MAYBE_ConcurrentProfiling_InSync) {
+  WithTargetThread([](PlatformThreadId target_thread_id) {
+    std::vector<SamplingParams> params(2);
+
+    // Providing an initial delay makes it more likely that both will be
+    // scheduled before either starts to run. Once started, samples will
+    // run ordered by their scheduled, interleaved times regardless of
+    // whatever interval the thread wakes up. Thus, total execution time
+    // will be 10ms (delay) + 10x1ms (sampling) + 1/2 timer minimum interval.
     params[0].initial_delay = TimeDelta::FromMilliseconds(10);
-    params[0].sampling_interval = TimeDelta::FromMilliseconds(0);
-    params[0].samples_per_burst = 1;
-
-    params[1].sampling_interval = TimeDelta::FromMilliseconds(0);
-    params[1].samples_per_burst = 1;
-
-    CallStackProfiles profiles[2];
-    std::vector<std::unique_ptr<WaitableEvent>> sampling_completed(2);
-    std::vector<std::unique_ptr<StackSamplingProfiler>> profiler(2);
-    for (int i = 0; i < 2; ++i) {
-      sampling_completed[i] =
-          MakeUnique<WaitableEvent>(WaitableEvent::ResetPolicy::AUTOMATIC,
-                                    WaitableEvent::InitialState::NOT_SIGNALED);
-      const StackSamplingProfiler::CompletedCallback callback =
-          Bind(&SaveProfilesAndSignalEvent, Unretained(&profiles[i]),
-               Unretained(sampling_completed[i].get()));
-      profiler[i] = MakeUnique<StackSamplingProfiler>(target_thread_id,
-                                                      params[i], callback);
-    }
-
-    profiler[0]->Start();
-    profiler[1]->Start();
-
-    std::vector<WaitableEvent*> sampling_completed_rawptrs(
-        sampling_completed.size());
-    std::transform(
-        sampling_completed.begin(), sampling_completed.end(),
-        sampling_completed_rawptrs.begin(),
-        [](const std::unique_ptr<WaitableEvent>& elem) { return elem.get(); });
+    params[0].sampling_interval = TimeDelta::FromMilliseconds(1);
+    params[0].samples_per_burst = 9;
+
+    params[1].initial_delay = TimeDelta::FromMilliseconds(11);
+    params[1].sampling_interval = TimeDelta::FromMilliseconds(1);
+    params[1].samples_per_burst = 8;
+
+    std::vector<std::unique_ptr<TestProfilerInfo>> profiler_infos =
+        CreateProfilers(target_thread_id, params);
+
+    profiler_infos[0]->profiler.Start();
+    profiler_infos[1]->profiler.Start();
+
     // Wait for one profiler to finish.
-    size_t completed_profiler =
-        WaitableEvent::WaitMany(sampling_completed_rawptrs.data(), 2);
-    EXPECT_EQ(1u, profiles[completed_profiler].size());
+    size_t completed_profiler = WaitForSamplingComplete(profiler_infos);
+    ASSERT_EQ(1u, profiler_infos[completed_profiler]->profiles.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());
-  });
-}
-
+    // Wait for the other profiler to finish.
+    profiler_infos[other_profiler]->completed.Wait();
+    ASSERT_EQ(1u, profiler_infos[other_profiler]->profiles.size());
+
+    // Ensure each got the correct number of samples.
+    EXPECT_EQ(9u, profiler_infos[0]->profiles[0].samples.size());
+    EXPECT_EQ(8u, profiler_infos[1]->profiles[0].samples.size());
+  });
+}
+
+// Checks that several mixed sampling requests execute in parallel.
+#if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
+#define MAYBE_ConcurrentProfiling_Mixed ConcurrentProfiling_Mixed
+#else
+#define MAYBE_ConcurrentProfiling_Mixed DISABLED_ConcurrentProfiling_Mixed
+#endif
+TEST_F(StackSamplingProfilerTest, MAYBE_ConcurrentProfiling_Mixed) {
+  WithTargetThread([](PlatformThreadId target_thread_id) {
+    std::vector<SamplingParams> params(3);
+
+    params[0].initial_delay = TimeDelta::FromMilliseconds(8);
+    params[0].sampling_interval = TimeDelta::FromMilliseconds(4);
+    params[0].samples_per_burst = 10;
+
+    params[1].initial_delay = TimeDelta::FromMilliseconds(9);
+    params[1].sampling_interval = TimeDelta::FromMilliseconds(3);
+    params[1].samples_per_burst = 10;
+
+    params[2].initial_delay = TimeDelta::FromMilliseconds(10);
+    params[2].sampling_interval = TimeDelta::FromMilliseconds(2);
+    params[2].samples_per_burst = 10;
+
+    std::vector<std::unique_ptr<TestProfilerInfo>> profiler_infos =
+        CreateProfilers(target_thread_id, params);
+
+    for (size_t i = 0; i < profiler_infos.size(); ++i)
+      profiler_infos[i]->profiler.Start();
+
+    // Wait for one profiler to finish.
+    size_t completed_profiler = WaitForSamplingComplete(profiler_infos);
+    EXPECT_EQ(1u, profiler_infos[completed_profiler]->profiles.size());
+    // Stop and destroy all profilers, always in the same order. Don't crash.
+    for (size_t i = 0; i < profiler_infos.size(); ++i)
+      profiler_infos[i]->profiler.Stop();
+    for (size_t i = 0; i < profiler_infos.size(); ++i)
+      profiler_infos[i].reset();
+  });
+}
+
 // 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
-TEST(StackSamplingProfilerTest, MAYBE_OtherLibrary) {
+TEST_F(StackSamplingProfilerTest, MAYBE_OtherLibrary) {
   SamplingParams params;
   params.sampling_interval = TimeDelta::FromMilliseconds(0);
   params.samples_per_burst = 1;
 
   std::vector<CallStackProfile> profiles;
   {
     ScopedNativeLibrary other_library(LoadOtherLibrary());
     WithTargetThread(
         [&params, &profiles](PlatformThreadId target_thread_id) {
           WaitableEvent sampling_thread_completed(
@@ skipping 50 matching lines @@
       << "Stack:\n" << FormatSampleForDiagnosticOutput(sample, profile.modules);
 }
 
 // Checks that a stack that runs through a library that is unloading produces a
 // stack, and doesn't crash.
 #if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
 #define MAYBE_UnloadingLibrary UnloadingLibrary
 #else
 #define MAYBE_UnloadingLibrary DISABLED_UnloadingLibrary
 #endif
-TEST(StackSamplingProfilerTest, MAYBE_UnloadingLibrary) {
+TEST_F(StackSamplingProfilerTest, MAYBE_UnloadingLibrary) {
   TestLibraryUnload(false);
 }
 
 // Checks that a stack that runs through a library that has been unloaded
 // produces a stack, and doesn't crash.
 #if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
 #define MAYBE_UnloadedLibrary UnloadedLibrary
 #else
 #define MAYBE_UnloadedLibrary DISABLED_UnloadedLibrary
 #endif
-TEST(StackSamplingProfilerTest, MAYBE_UnloadedLibrary) {
+TEST_F(StackSamplingProfilerTest, MAYBE_UnloadedLibrary) {
   TestLibraryUnload(true);
 }
 
+// Checks that different threads can be sampled in parallel.
+#if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
+#define MAYBE_MultipleSampledThreads MultipleSampledThreads
+#else
+#define MAYBE_MultipleSampledThreads DISABLED_MultipleSampledThreads
+#endif
+TEST_F(StackSamplingProfilerTest, MAYBE_MultipleSampledThreads) {
+  // Create target threads. The extra parethesis around the StackConfiguration
+  // call are to avoid the most-vexing-parse problem.
+  TargetThread target_thread1((StackConfiguration(StackConfiguration::NORMAL)));
+  TargetThread target_thread2((StackConfiguration(StackConfiguration::NORMAL)));
+  PlatformThreadHandle target_thread_handle1, target_thread_handle2;
+  EXPECT_TRUE(
+      PlatformThread::Create(0, &target_thread1, &target_thread_handle1));
+  EXPECT_TRUE(
+      PlatformThread::Create(0, &target_thread2, &target_thread_handle2));
+  target_thread1.WaitForThreadStart();
+  target_thread2.WaitForThreadStart();
+
+  // Providing an initial delay makes it more likely that both will be
+  // scheduled before either starts to run. Once started, samples will
+  // run ordered by their scheduled, interleaved times regardless of
+  // whatever interval the thread wakes up.
+  SamplingParams params1, params2;
+  params1.initial_delay = TimeDelta::FromMilliseconds(10);
+  params1.sampling_interval = TimeDelta::FromMilliseconds(1);
+  params1.samples_per_burst = 9;
+  params2.initial_delay = TimeDelta::FromMilliseconds(10);
+  params2.sampling_interval = TimeDelta::FromMilliseconds(1);
+  params2.samples_per_burst = 8;
+
+  std::vector<CallStackProfile> profiles1, profiles2;
+
+  WaitableEvent sampling_thread_completed1(
+      WaitableEvent::ResetPolicy::MANUAL,
+      WaitableEvent::InitialState::NOT_SIGNALED);
+  const StackSamplingProfiler::CompletedCallback callback1 =
+      Bind(&SaveProfilesAndSignalEvent, Unretained(&profiles1),
+           Unretained(&sampling_thread_completed1));
+  StackSamplingProfiler profiler1(target_thread1.id(), params1, callback1);
+
+  WaitableEvent sampling_thread_completed2(
+      WaitableEvent::ResetPolicy::MANUAL,
+      WaitableEvent::InitialState::NOT_SIGNALED);
+  const StackSamplingProfiler::CompletedCallback callback2 =
+      Bind(&SaveProfilesAndSignalEvent, Unretained(&profiles2),
+           Unretained(&sampling_thread_completed2));
+  StackSamplingProfiler profiler2(target_thread2.id(), params2, callback2);
+
+  // Finally the real work.
+  profiler1.Start();
+  profiler2.Start();
+  sampling_thread_completed1.Wait();
+  sampling_thread_completed2.Wait();
+  ASSERT_EQ(1u, profiles1.size());
+  EXPECT_EQ(9u, profiles1[0].samples.size());
+  ASSERT_EQ(1u, profiles2.size());
+  EXPECT_EQ(8u, profiles2[0].samples.size());
+
+  target_thread1.SignalThreadToFinish();
+  target_thread2.SignalThreadToFinish();
+  PlatformThread::Join(target_thread_handle1);
+  PlatformThread::Join(target_thread_handle2);
+}
+
+// A simple thread that runs a profiler on another thread.
+class ProfilerThread : public SimpleThread {
+ public:
+  ProfilerThread(const std::string& name,
+                 PlatformThreadId thread_id,
+                 const SamplingParams& params)
+      : SimpleThread(name, Options()),
+        run_(WaitableEvent::ResetPolicy::MANUAL,
+             WaitableEvent::InitialState::NOT_SIGNALED),
+        completed_(WaitableEvent::ResetPolicy::MANUAL,
+                   WaitableEvent::InitialState::NOT_SIGNALED),
+        profiler_(thread_id,
+                  params,
+                  Bind(&SaveProfilesAndSignalEvent,
+                       Unretained(&profiles_),
+                       Unretained(&completed_))) {}
+
+  void Run() override {
+    run_.Wait();
+    profiler_.Start();
+  }
+
+  void Go() { run_.Signal(); }
+
+  void Wait() { completed_.Wait(); }
+
+  CallStackProfiles& profiles() { return profiles_; }
+
+ private:
+  WaitableEvent run_;
+
+  CallStackProfiles profiles_;
+  WaitableEvent completed_;
+  StackSamplingProfiler profiler_;
+};
+
+// Checks that different threads can run samplers in parallel.
+#if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
+#define MAYBE_MultipleProfilerThreads MultipleProfilerThreads
+#else
+#define MAYBE_MultipleProfilerThreads DISABLED_MultipleProfilerThreads
+#endif
+TEST_F(StackSamplingProfilerTest, MAYBE_MultipleProfilerThreads) {
+  WithTargetThread([](PlatformThreadId target_thread_id) {
+    // Providing an initial delay makes it more likely that both will be
+    // scheduled before either starts to run. Once started, samples will
+    // run ordered by their scheduled, interleaved times regardless of
+    // whatever interval the thread wakes up.
+    SamplingParams params1, params2;
+    params1.initial_delay = TimeDelta::FromMilliseconds(10);
+    params1.sampling_interval = TimeDelta::FromMilliseconds(1);
+    params1.samples_per_burst = 9;
+    params2.initial_delay = TimeDelta::FromMilliseconds(10);
+    params2.sampling_interval = TimeDelta::FromMilliseconds(1);
+    params2.samples_per_burst = 8;
+
+    // Start the profiler threads and give them a moment to get going.
+    ProfilerThread profiler_thread1("profiler1", target_thread_id, params1);
+    ProfilerThread profiler_thread2("profiler2", target_thread_id, params2);
+    profiler_thread1.Start();
+    profiler_thread2.Start();
+    PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
+
+    // This will (approximately) synchronize the two threads.
+    profiler_thread1.Go();
+    profiler_thread2.Go();
+
+    // Wait for them both to finish and validate collection.
+    profiler_thread1.Wait();
+    profiler_thread2.Wait();
+    ASSERT_EQ(1u, profiler_thread1.profiles().size());
+    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