Migrate WaitableEvent to enum-based constructor in base/

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 "base/bind.h"
@@ skipping 131 matching lines @@
 
   WaitableEvent thread_started_event_;
   WaitableEvent finish_event_;
   PlatformThreadId id_;
   const StackConfiguration stack_config_;
 
   DISALLOW_COPY_AND_ASSIGN(TargetThread);
 };
 
 TargetThread::TargetThread(const StackConfiguration& stack_config)
-    : thread_started_event_(false, false), finish_event_(false, false),
-      id_(0), stack_config_(stack_config) {}
+    : thread_started_event_(WaitableEvent::ResetPolicy::AUTOMATIC,
+                            WaitableEvent::InitialState::NOT_SIGNALED),
+      finish_event_(WaitableEvent::ResetPolicy::AUTOMATIC,
+                    WaitableEvent::InitialState::NOT_SIGNALED),
+      id_(0),
+      stack_config_(stack_config) {}
 
 void TargetThread::ThreadMain() {
   id_ = PlatformThread::CurrentId();
   switch (stack_config_.config) {
     case StackConfiguration::NORMAL:
       SignalAndWaitUntilSignaled(&thread_started_event_, &finish_event_,
                                  &stack_config_);
       break;
 
     case StackConfiguration::WITH_ALLOCA:
@@ skipping 180 matching lines @@
   WithTargetThread(function, StackConfiguration(StackConfiguration::NORMAL));
 }
 
 // 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(true, false);
+  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();
   });
 }
@@ skipping 91 matching lines @@
   NativeLibrary other_library = LoadOtherLibrary();
   TargetThread target_thread(StackConfiguration(
       StackConfiguration::WITH_OTHER_LIBRARY,
       other_library));
 
   PlatformThreadHandle target_thread_handle;
   EXPECT_TRUE(PlatformThread::Create(0, &target_thread, &target_thread_handle));
 
   target_thread.WaitForThreadStart();
 
-  WaitableEvent sampling_thread_completed(true, false);
+  WaitableEvent sampling_thread_completed(
+      WaitableEvent::ResetPolicy::MANUAL,
+      WaitableEvent::InitialState::NOT_SIGNALED);
   std::vector<CallStackProfile> profiles;
   const StackSamplingProfiler::CompletedCallback callback =
       Bind(&SaveProfilesAndSignalEvent, Unretained(&profiles),
            Unretained(&sampling_thread_completed));
-  WaitableEvent stack_copied(true, false);
-  WaitableEvent start_stack_walk(true, false);
+  WaitableEvent stack_copied(WaitableEvent::ResetPolicy::MANUAL,
+                             WaitableEvent::InitialState::NOT_SIGNALED);
+  WaitableEvent start_stack_walk(WaitableEvent::ResetPolicy::MANUAL,
+                                 WaitableEvent::InitialState::NOT_SIGNALED);
   StackCopiedSignaler test_delegate(&stack_copied, &start_stack_walk,
                                     wait_until_unloaded);
   StackSamplingProfiler profiler(target_thread.id(), params, callback,
                                  &test_delegate);
 
   profiler.Start();
 
   // Wait for the stack to be copied and the target thread to be resumed.
   stack_copied.Wait();
 
@@ skipping 133 matching lines @@
 #define MAYBE_Alloca Alloca
 #else
 #define MAYBE_Alloca DISABLED_Alloca
 #endif
 TEST(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(true, false);
-    const StackSamplingProfiler::CompletedCallback callback =
-        Bind(&SaveProfilesAndSignalEvent, Unretained(&profiles),
-             Unretained(&sampling_thread_completed));
-    StackSamplingProfiler profiler(target_thread_id, params, callback);
-    profiler.Start();
-    sampling_thread_completed.Wait();
-  }, StackConfiguration(StackConfiguration::WITH_ALLOCA));
+  WithTargetThread(
+      [&params, &profiles](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.Wait();
+      },
+      StackConfiguration(StackConfiguration::WITH_ALLOCA));
 
   // Look up the sample.
   ASSERT_EQ(1u, profiles.size());
   const CallStackProfile& profile = profiles[0];
   ASSERT_EQ(1u, profile.samples.size());
   const Sample& sample = profile.samples[0];
 
   // Check that the stack contains a frame for
   // TargetThread::SignalAndWaitUntilSignaled().
   Sample::const_iterator end_frame = FindFirstFrameWithinFunction(
@@ skipping 31 matching lines @@
 #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(false, false);
+    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());
 }
@@ skipping 136 matching lines @@
     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];
     ScopedVector<WaitableEvent> sampling_completed;
     ScopedVector<StackSamplingProfiler> profiler;
     for (int i = 0; i < 2; ++i) {
-      sampling_completed.push_back(new WaitableEvent(false, false));
+      sampling_completed.push_back(
+          new WaitableEvent(WaitableEvent::ResetPolicy::AUTOMATIC,
+                            WaitableEvent::InitialState::NOT_SIGNALED));
       const StackSamplingProfiler::CompletedCallback callback =
           Bind(&SaveProfilesAndSignalEvent, Unretained(&profiles[i]),
                Unretained(sampling_completed[i]));
       profiler.push_back(
           new StackSamplingProfiler(target_thread_id, params[i], callback));
     }
 
     profiler[0]->Start();
     profiler[1]->Start();
 
@@ skipping 22 matching lines @@
 #define MAYBE_OtherLibrary DISABLED_OtherLibrary
 #endif
 TEST(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(true, false);
-      const StackSamplingProfiler::CompletedCallback callback =
-          Bind(&SaveProfilesAndSignalEvent, Unretained(&profiles),
-               Unretained(&sampling_thread_completed));
-      StackSamplingProfiler profiler(target_thread_id, params, callback);
-      profiler.Start();
-      sampling_thread_completed.Wait();
-    }, StackConfiguration(StackConfiguration::WITH_OTHER_LIBRARY,
-                          other_library.get()));
+    WithTargetThread(
+        [&params, &profiles](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.Wait();
+        },
+        StackConfiguration(StackConfiguration::WITH_OTHER_LIBRARY,
+                           other_library.get()));
   }
 
   // Look up the sample.
   ASSERT_EQ(1u, profiles.size());
   const CallStackProfile& profile = profiles[0];
   ASSERT_EQ(1u, profile.samples.size());
   const Sample& sample = profile.samples[0];
 
   // Check that the stack contains a frame for
   // TargetThread::CallThroughOtherLibrary().
@@ skipping 47 matching lines @@
 #if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
 #define MAYBE_UnloadedLibrary UnloadedLibrary
 #else
 #define MAYBE_UnloadedLibrary DISABLED_UnloadedLibrary
 #endif
 TEST(StackSamplingProfilerTest, MAYBE_UnloadedLibrary) {
   TestLibraryUnload(true);
 }
 
 }  // namespace base