Enable startup profiling by Win x64 stack sampling profiler

base/profiler/stack_sampling_profiler_unittest.cc

Index: base/profiler/stack_sampling_profiler_unittest.cc
diff --git a/base/profiler/stack_sampling_profiler_unittest.cc b/base/profiler/stack_sampling_profiler_unittest.cc
index dfccab4e1a893ae7da9c768f0e5c17aef4f9b692..dcefe0e6c2f4cd20fc9b6d1332893f635b4fea18 100644
--- a/base/profiler/stack_sampling_profiler_unittest.cc
+++ b/base/profiler/stack_sampling_profiler_unittest.cc
@@ -91,15 +91,16 @@ void SaveProfilesAndSignalEvent(std::vector<Profile>* profiles,
                                 WaitableEvent* event,
                                 const std::vector<Profile>& pending_profiles) {
   *profiles = pending_profiles;
-  event->Signal();
+  if (event)
+    event->Signal();
 }
 
 // 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.
+// complete. Uses a per-object callback unless |use_default_callback| is true.
 void CaptureProfiles(const StackSamplingProfiler::SamplingParams& params,
                      std::vector<Profile>* profiles,
-                     TimeDelta profiler_wait_time) {
+                     TimeDelta profiler_wait_time, bool use_default_callback) {
   TargetThread target_thread;
   PlatformThreadHandle target_thread_handle;
   EXPECT_TRUE(PlatformThread::Create(0, &target_thread, &target_thread_handle));
@@ -108,18 +109,73 @@ void CaptureProfiles(const StackSamplingProfiler::SamplingParams& params,
 
   WaitableEvent sampling_thread_completed(true, false);
   profiles->clear();
-  StackSamplingProfiler profiler(target_thread.id(), params);
-  profiler.SetCustomCompletedCallback(
+  const StackSamplingProfiler::CompletedCallback callback =
       Bind(&SaveProfilesAndSignalEvent, Unretained(profiles),
-           Unretained(&sampling_thread_completed)));
-  profiler.Start();
+           Unretained(&sampling_thread_completed));
+  scoped_ptr<StackSamplingProfiler> profiler;
+  if (use_default_callback) {
+    StackSamplingProfiler::SetDefaultCompletedCallback(callback);
+    profiler.reset(new StackSamplingProfiler(target_thread.id(), params));
+  } else {
+    profiler.reset(new StackSamplingProfiler(target_thread.id(), params,
+                                             callback));
+  }
+  profiler->Start();
   sampling_thread_completed.TimedWait(profiler_wait_time);
-  profiler.Stop();
+  profiler->Stop();
   sampling_thread_completed.Wait();
 
   target_thread.SignalThreadToFinish();
 
   PlatformThread::Join(target_thread_handle);
+
+  if (use_default_callback) {
+    StackSamplingProfiler::SetDefaultCompletedCallback(
+        StackSamplingProfiler::CompletedCallback());
+  }
+}
+
+// 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 CaptureProfilesWithObjectCallback(
+    const StackSamplingProfiler::SamplingParams& params,
+    std::vector<Profile>* profiles,
+    TimeDelta profiler_wait_time) {
+  CaptureProfiles(params, profiles, profiler_wait_time, false);
+}
+
+// Captures profiles as specified by |params| on the TargetThread, and returns
+// them in |profiles|. Uses the default callback rather than a per-object
+// callback. Waits up to |profiler_wait_time| for the profiler to complete.
+void CaptureProfilesWithDefaultCallback(
+    const StackSamplingProfiler::SamplingParams& params,
+    std::vector<Profile>* profiles,
+    TimeDelta profiler_wait_time) {
+  CaptureProfiles(params, profiles, profiler_wait_time, true);
+}
+
+// Runs the profiler with |params| on the TargetThread, with no default or
+// per-object callback.
+void RunProfilerWithNoCallback(
+    const StackSamplingProfiler::SamplingParams& params,
+    TimeDelta profiler_wait_time) {
+  TargetThread target_thread;
+  PlatformThreadHandle target_thread_handle;
+  EXPECT_TRUE(PlatformThread::Create(0, &target_thread, &target_thread_handle));
+
+  target_thread.WaitForThreadStart();
+
+  StackSamplingProfiler profiler(target_thread.id(), params);
+  profiler.Start();
+  // Since we don't specify a callback, we don't have a synchronization
+  // mechanism with the sampling thread. Just sleep instead.
+  PlatformThread::Sleep(profiler_wait_time);
+  profiler.Stop();
+
+  target_thread.SignalThreadToFinish();
+
+  PlatformThread::Join(target_thread_handle);
 }
 
 // If this executable was linked with /INCREMENTAL (the default for non-official
@@ -198,7 +254,7 @@ TEST(StackSamplingProfilerTest, MAYBE_Basic) {
   params.samples_per_burst = 1;
 
   std::vector<Profile> profiles;
-  CaptureProfiles(params, &profiles, AVeryLongTimeDelta());
+  CaptureProfilesWithObjectCallback(params, &profiles, AVeryLongTimeDelta());
 
   // Check that the profile and samples sizes are correct, and the module
   // indices are in range.
@@ -252,7 +308,7 @@ TEST(StackSamplingProfilerTest, MAYBE_MultipleProfilesAndSamples) {
   params.samples_per_burst = 3;
 
   std::vector<Profile> profiles;
-  CaptureProfiles(params, &profiles, AVeryLongTimeDelta());
+  CaptureProfilesWithObjectCallback(params, &profiles, AVeryLongTimeDelta());
 
   ASSERT_EQ(2u, profiles.size());
   EXPECT_EQ(3u, profiles[0].samples.size());
@@ -274,7 +330,8 @@ TEST(StackSamplingProfilerTest, MAYBE_StopDuringInitialDelay) {
   params.bursts = params.samples_per_burst = 1;
 
   std::vector<Profile> profiles;
-  CaptureProfiles(params, &profiles, TimeDelta::FromMilliseconds(0));
+  CaptureProfilesWithObjectCallback(params, &profiles,
+                                    TimeDelta::FromMilliseconds(0));
 
   EXPECT_TRUE(profiles.empty());
 }
@@ -295,7 +352,8 @@ TEST(StackSamplingProfilerTest, MAYBE_StopDuringInterBurstInterval) {
   params.samples_per_burst = 1;
 
   std::vector<Profile> profiles;
-  CaptureProfiles(params, &profiles, TimeDelta::FromMilliseconds(50));
+  CaptureProfilesWithObjectCallback(params, &profiles,
+                                    TimeDelta::FromMilliseconds(50));
 
   ASSERT_EQ(1u, profiles.size());
   EXPECT_EQ(1u, profiles[0].samples.size());
@@ -316,9 +374,56 @@ TEST(StackSamplingProfilerTest, MAYBE_StopDuringInterSampleInterval) {
   params.samples_per_burst = 2;
 
   std::vector<Profile> profiles;
-  CaptureProfiles(params, &profiles, TimeDelta::FromMilliseconds(50));
+  CaptureProfilesWithObjectCallback(params, &profiles,
+                                    TimeDelta::FromMilliseconds(50));
 
   EXPECT_TRUE(profiles.empty());
 }
 
-}  // namespace tracked_objects
+// Checks that profiles are captured via the default completed callback.
+#if defined(_WIN64)
+#define MAYBE_DefaultCallback DefaultCallback
+#else
+#define MAYBE_DefaultCallback DISABLED_DefaultCallback
+#endif
+TEST(StackSamplingProfilerTest, MAYBE_DefaultCallback) {

[Mike Wittman, 2015/03/24 18:37:39]

This test and the following one need to be run independent of each other and the
tests above due to setting global state. I'm planning to use the test
serialization support in https://crrev.com/1027993002 if and when it lands.

+  StackSamplingProfiler::SamplingParams params;
+  params.initial_delay = params.burst_interval = params.sampling_interval =
+      TimeDelta::FromMilliseconds(0);
+  params.bursts = 1;
+  params.samples_per_burst = 1;
+
+  std::vector<Profile> profiles;
+  CaptureProfilesWithDefaultCallback(params, &profiles, AVeryLongTimeDelta());
+
+  EXPECT_EQ(1u, profiles.size());
+  EXPECT_EQ(1u, profiles[0].samples.size());
+}
+
+// Checks that profiles are queued until a default callback is set, then
+// delivered.
+#if defined(_WIN64)
+#define MAYBE_ProfilesQueuedWithNoCallback ProfilesQueuedWithNoCallback
+#else
+#define MAYBE_ProfilesQueuedWithNoCallback DISABLED_ProfilesQueuedWithNoCallback
+#endif
+TEST(StackSamplingProfilerTest, MAYBE_ProfilesQueuedWithNoCallback) {
+  StackSamplingProfiler::SamplingParams params;
+  params.initial_delay = params.burst_interval = params.sampling_interval =
+      TimeDelta::FromMilliseconds(0);
+  params.bursts = 1;
+  params.samples_per_burst = 1;
+
+  RunProfilerWithNoCallback(params, TimeDelta::FromMilliseconds(50));
+
+  std::vector<Profile> profiles;
+  // This should immediately call SaveProfilesAndSignalEvent on this thread.
+  StackSamplingProfiler::SetDefaultCompletedCallback(
+      Bind(&SaveProfilesAndSignalEvent, Unretained(&profiles), nullptr));
+  EXPECT_EQ(1u, profiles.size());
+  EXPECT_EQ(1u, profiles[0].samples.size());
+  StackSamplingProfiler::SetDefaultCompletedCallback(
+      StackSamplingProfiler::CompletedCallback());
+}
+
+}  // namespace base