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) {
+  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