Enable startup profiling by Win x64 stack sampling profiler

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 <sstream>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/path_service.h"
 #include "base/profiler/stack_sampling_profiler.h"
@@ skipping 73 matching lines @@
 #pragma optimize("", on)
 #endif
 
 // 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(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));
 
   target_thread.WaitForThreadStart();
 
   WaitableEvent sampling_thread_completed(true, false);
   profiles->clear();
+  const StackSamplingProfiler::CompletedCallback callback =
+      Bind(&SaveProfilesAndSignalEvent, Unretained(profiles),
+           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();
+  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.SetCustomCompletedCallback(
-      Bind(&SaveProfilesAndSignalEvent, Unretained(profiles),
-           Unretained(&sampling_thread_completed)));
   profiler.Start();
-  sampling_thread_completed.TimedWait(profiler_wait_time);
+  // 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();
-  sampling_thread_completed.Wait();
 
   target_thread.SignalThreadToFinish();
 
   PlatformThread::Join(target_thread_handle);
 }
 
 // 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. Check for a jump instruction and if present
@@ skipping 62 matching lines @@
 #define MAYBE_Basic DISABLED_Basic
 #endif
 TEST(StackSamplingProfilerTest, MAYBE_Basic) {
   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;
-  CaptureProfiles(params, &profiles, AVeryLongTimeDelta());
+  CaptureProfilesWithObjectCallback(params, &profiles, AVeryLongTimeDelta());
 
   // Check that the profile and samples sizes are correct, and the module
   // indices are in range.
 
   ASSERT_EQ(1u, profiles.size());
   const Profile& profile = profiles[0];
   ASSERT_EQ(1u, profile.samples.size());
   EXPECT_EQ(params.sampling_interval, profile.sampling_period);
   const Sample& sample = profile.samples[0];
   for (const auto& frame : sample) {
@@ skipping 33 matching lines @@
 #define MAYBE_MultipleProfilesAndSamples DISABLED_MultipleProfilesAndSamples
 #endif
 TEST(StackSamplingProfilerTest, MAYBE_MultipleProfilesAndSamples) {
   StackSamplingProfiler::SamplingParams params;
   params.initial_delay = params.burst_interval = params.sampling_interval =
       TimeDelta::FromMilliseconds(0);
   params.bursts = 2;
   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());
   EXPECT_EQ(3u, profiles[1].samples.size());
 }
 
 // Checks that no profiles are captured if the profiling is stopped during the
 // initial delay.
 #if defined(_WIN64)
 #define MAYBE_StopDuringInitialDelay StopDuringInitialDelay
 #else
 #define MAYBE_StopDuringInitialDelay DISABLED_StopDuringInitialDelay
 #endif
 TEST(StackSamplingProfilerTest, MAYBE_StopDuringInitialDelay) {
   StackSamplingProfiler::SamplingParams params;
   params.burst_interval = params.sampling_interval =
       TimeDelta::FromMilliseconds(0);
   params.initial_delay = TimeDelta::FromSeconds(60);
   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());
 }
 
 // Checks that the single completed profile is captured if the profiling is
 // stopped between bursts.
 #if defined(_WIN64)
 #define MAYBE_StopDuringInterBurstInterval StopDuringInterBurstInterval
 #else
 #define MAYBE_StopDuringInterBurstInterval DISABLED_StopDuringInterBurstInterval
 #endif
 TEST(StackSamplingProfilerTest, MAYBE_StopDuringInterBurstInterval) {
   StackSamplingProfiler::SamplingParams params;
   params.initial_delay = params.sampling_interval =
       TimeDelta::FromMilliseconds(0);
   params.burst_interval = TimeDelta::FromSeconds(60);
   params.bursts = 2;
   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());
 }
 
 // Checks that only completed profiles are captured.
 #if defined(_WIN64)
 #define MAYBE_StopDuringInterSampleInterval StopDuringInterSampleInterval
 #else
 #define MAYBE_StopDuringInterSampleInterval \
   DISABLED_StopDuringInterSampleInterval
 #endif
 TEST(StackSamplingProfilerTest, MAYBE_StopDuringInterSampleInterval) {
   StackSamplingProfiler::SamplingParams params;
   params.initial_delay = params.burst_interval = TimeDelta::FromMilliseconds(0);
   params.sampling_interval = TimeDelta::FromSeconds(60);
   params.bursts = 1;
   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