Clean up ifdefs in base stack sampling profiler unit test.

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>
@@ skipping 33 matching lines @@
 #if defined(_WIN64) || (defined(OS_MACOSX) && !defined(OS_IOS))
 #define STACK_SAMPLING_PROFILER_SUPPORTED 1
 #endif
 
 #if defined(OS_WIN)
 #pragma intrinsic(_ReturnAddress)
 #endif
 
 namespace base {
 
+#if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
+#define PROFILER_TEST_F(TestClass, TestName) TEST_F(TestClass, TestName)
+#else
+#define PROFILER_TEST_F(TestClass, TestName) \
+  TEST_F(TestClass, DISABLED_##TestName)
+#endif
+
 using SamplingParams = StackSamplingProfiler::SamplingParams;
 using Frame = StackSamplingProfiler::Frame;
 using Frames = std::vector<StackSamplingProfiler::Frame>;
 using Module = StackSamplingProfiler::Module;
 using Sample = StackSamplingProfiler::Sample;
 using CallStackProfile = StackSamplingProfiler::CallStackProfile;
 using CallStackProfiles = StackSamplingProfiler::CallStackProfiles;
 
 namespace {
 
@@ skipping 580 matching lines @@
     // idle-shutdown behavior.
     StackSamplingProfiler::TestAPI::Reset();
   }
 };
 
 }  // namespace
 
 // Checks that the basic expected information is present in a sampled call stack
 // profile.
 // macOS ASAN is not yet supported - crbug.com/718628.
-#if defined(STACK_SAMPLING_PROFILER_SUPPORTED) && \
-    !(defined(ADDRESS_SANITIZER) && defined(OS_MACOSX))
+#if !(defined(ADDRESS_SANITIZER) && defined(OS_MACOSX))
 #define MAYBE_Basic Basic
 #else
 #define MAYBE_Basic DISABLED_Basic
 #endif
-TEST_F(StackSamplingProfilerTest, MAYBE_Basic) {
+PROFILER_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 18 matching lines @@
              &TargetThread::SignalAndWaitUntilSignaled))
       << " was not found in stack:\n"
       << FormatSampleForDiagnosticOutput(sample, profile.modules);
   FilePath executable_path;
   EXPECT_TRUE(PathService::Get(FILE_EXE, &executable_path));
   EXPECT_EQ(executable_path,
             MakeAbsoluteFilePath(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_F(StackSamplingProfilerTest, MAYBE_Annotations) {
+PROFILER_TEST_F(StackSamplingProfilerTest, 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];
   ASSERT_EQ(1u, profile1.samples.size());
   const Sample& sample1 = profile1.samples[0];
   EXPECT_EQ(1u << 1, sample1.process_milestones);
 
   // Run it a second time but with changed annotations. These annotations
   // should appear in the first acquired sample.
   StackSamplingProfiler::SetProcessMilestone(2);
   std::vector<CallStackProfile> profiles2;
   CaptureProfiles(params, AVeryLongTimeDelta(), &profiles2);
   ASSERT_EQ(1u, profiles2.size());
   const CallStackProfile& profile2 = profiles2[0];
   ASSERT_EQ(1u, profile2.samples.size());
   const Sample& sample2 = profile2.samples[0];
   EXPECT_EQ(sample1.process_milestones | (1u << 2), sample2.process_milestones);
 }
 
 // Checks that the profiler handles stacks containing dynamically-allocated
 // stack memory.
 // macOS ASAN is not yet supported - crbug.com/718628.
-#if defined(STACK_SAMPLING_PROFILER_SUPPORTED) && \
-    !(defined(ADDRESS_SANITIZER) && defined(OS_MACOSX))
+#if !(defined(ADDRESS_SANITIZER) && defined(OS_MACOSX))
 #define MAYBE_Alloca Alloca
 #else
 #define MAYBE_Alloca DISABLED_Alloca
 #endif
-TEST_F(StackSamplingProfilerTest, MAYBE_Alloca) {
+PROFILER_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 34 matching lines @@
       << 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 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_F(StackSamplingProfilerTest, MAYBE_MultipleProfilesAndSamples) {
+PROFILER_TEST_F(StackSamplingProfilerTest, 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) {
+PROFILER_TEST_F(StackSamplingProfilerTest, 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) {
+PROFILER_TEST_F(StackSamplingProfilerTest, StopSafely) {
   // Test delegate that counts samples.
   class SampleRecordedCounter : public NativeStackSamplerTestDelegate {
    public:
     SampleRecordedCounter() {}
 
     void OnPreStackWalk() override {
       AutoLock lock(lock_);
       ++count_;
     }
 
@@ skipping 54 matching lines @@
     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_F(StackSamplingProfilerTest, MAYBE_StopDuringInitialDelay) {
+PROFILER_TEST_F(StackSamplingProfilerTest, 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_F(StackSamplingProfilerTest, MAYBE_StopDuringInterBurstInterval) {
+PROFILER_TEST_F(StackSamplingProfilerTest, 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 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_F(StackSamplingProfilerTest, MAYBE_StopDuringInterSampleInterval) {
+PROFILER_TEST_F(StackSamplingProfilerTest, StopDuringInterSampleInterval) {
   // Test delegate that counts samples.
   class SampleRecordedEvent : public NativeStackSamplerTestDelegate {
    public:
     SampleRecordedEvent()
         : sample_recorded_(WaitableEvent::ResetPolicy::MANUAL,
                            WaitableEvent::InitialState::NOT_SIGNALED) {}
 
     void OnPreStackWalk() override { sample_recorded_.Signal(); }
 
     void WaitForSample() { sample_recorded_.Wait(); }
@@ skipping 19 matching lines @@
     // 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_F(StackSamplingProfilerTest, MAYBE_DestroyProfilerWhileProfiling) {
+PROFILER_TEST_F(StackSamplingProfilerTest, 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_F(StackSamplingProfilerTest, MAYBE_CanRunMultipleTimes) {
+PROFILER_TEST_F(StackSamplingProfilerTest, 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) {
+PROFILER_TEST_F(StackSamplingProfilerTest, 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 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) {
+PROFILER_TEST_F(StackSamplingProfilerTest, 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) {
+PROFILER_TEST_F(StackSamplingProfilerTest, 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) {
+PROFILER_TEST_F(StackSamplingProfilerTest,
+                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) {
+PROFILER_TEST_F(StackSamplingProfilerTest, 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) {
+PROFILER_TEST_F(StackSamplingProfilerTest,
+                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) {
+PROFILER_TEST_F(StackSamplingProfilerTest, 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();
@@ skipping 13 matching lines @@
 
     // Ensure that it's still possible to run another sampler.
     TestProfilerInfo another_info(target_thread_id, params);
     another_info.profiler.Start();
     another_info.completed.Wait();
     EXPECT_EQ(1u, another_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) {
+PROFILER_TEST_F(StackSamplingProfilerTest, 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(1);
@@ skipping 18 matching lines @@
     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) {
+PROFILER_TEST_F(StackSamplingProfilerTest, 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;
@@ skipping 15 matching lines @@
     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.
 // macOS ASAN is not yet supported - crbug.com/718628.
-#if defined(STACK_SAMPLING_PROFILER_SUPPORTED) && \
-    !(defined(ADDRESS_SANITIZER) && defined(OS_MACOSX))
+#if !(defined(ADDRESS_SANITIZER) && defined(OS_MACOSX))
 #define MAYBE_OtherLibrary OtherLibrary
 #else
 #define MAYBE_OtherLibrary DISABLED_OtherLibrary
 #endif
-TEST_F(StackSamplingProfilerTest, MAYBE_OtherLibrary) {
+PROFILER_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 46 matching lines @@
   // TargetThread::OtherLibraryCallback
   // InvokeCallbackFunction (in other library)
   // TargetThread::CallThroughOtherLibrary
   EXPECT_EQ(3, other_library_frame - end_frame)
       << "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.
 // Unloading is synchronous on the Mac, so this test is inapplicable.
-#if defined(STACK_SAMPLING_PROFILER_SUPPORTED) && !defined(OS_MACOSX)
+#if !defined(OS_MACOSX)
 #define MAYBE_UnloadingLibrary UnloadingLibrary
 #else
 #define MAYBE_UnloadingLibrary DISABLED_UnloadingLibrary
 #endif
-TEST_F(StackSamplingProfilerTest, MAYBE_UnloadingLibrary) {
+PROFILER_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.
 // macOS ASAN is not yet supported - crbug.com/718628.
-#if defined(STACK_SAMPLING_PROFILER_SUPPORTED) && \
-    !(defined(ADDRESS_SANITIZER) && defined(OS_MACOSX))
+#if !(defined(ADDRESS_SANITIZER) && defined(OS_MACOSX))
 #define MAYBE_UnloadedLibrary UnloadedLibrary
 #else
 #define MAYBE_UnloadedLibrary DISABLED_UnloadedLibrary
 #endif
-TEST_F(StackSamplingProfilerTest, MAYBE_UnloadedLibrary) {
+PROFILER_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) {
+PROFILER_TEST_F(StackSamplingProfilerTest, 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();
@@ skipping 75 matching lines @@
 
  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) {
+PROFILER_TEST_F(StackSamplingProfilerTest, 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);
@@ skipping 18 matching lines @@
     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