DO NOT COMMIT (will be split in sub-components) - clang-tidy WaitableEvent refactor

chrome/browser/metrics/thread_watcher_unittest.cc

 // Copyright (c) 2012 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 "chrome/browser/metrics/thread_watcher.h"
 
 #include <math.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 228 matching lines @@
     UpdateWaitState(STOPPED_WAITING);
     return exit_state;
   }
 };
 
 class ThreadWatcherTest : public ::testing::Test {
  public:
   static const TimeDelta kSleepTime;
   static const TimeDelta kUnresponsiveTime;
   static const BrowserThread::ID io_thread_id;
-  static const std::string io_thread_name;
+  static const char io_thread_name[];
   static const BrowserThread::ID db_thread_id;
-  static const std::string db_thread_name;
-  static const std::string crash_on_hang_seconds;
-  static const std::string crash_on_hang_thread_names;
-  static const std::string thread_names_and_live_threshold;
-  static const std::string crash_on_hang_thread_data;
+  static const char db_thread_name[];
+  static const char crash_on_hang_thread_names[];
+  static const char thread_names_and_live_threshold[];
+  static const char crash_on_hang_thread_data[];
   CustomThreadWatcher* io_watcher_;
   CustomThreadWatcher* db_watcher_;
   ThreadWatcherList* thread_watcher_list_;
 
   ThreadWatcherTest()
       : setup_complete_(&lock_),
         initialized_(false) {
     db_thread_.reset(new content::TestBrowserThread(BrowserThread::DB));
     io_thread_.reset(new content::TestBrowserThread(BrowserThread::IO));
     watchdog_thread_.reset(new WatchDogThread());
@@ skipping 60 matching lines @@
   std::unique_ptr<content::TestBrowserThread> io_thread_;
   std::unique_ptr<WatchDogThread> watchdog_thread_;
 };
 
 // Define static constants.
 const TimeDelta ThreadWatcherTest::kSleepTime =
     TimeDelta::FromMilliseconds(50);
 const TimeDelta ThreadWatcherTest::kUnresponsiveTime =
     TimeDelta::FromMilliseconds(500);
 const BrowserThread::ID ThreadWatcherTest::io_thread_id = BrowserThread::IO;
-const std::string ThreadWatcherTest::io_thread_name = "IO";
+const char ThreadWatcherTest::io_thread_name[] = "IO";
 const BrowserThread::ID ThreadWatcherTest::db_thread_id = BrowserThread::DB;
-const std::string ThreadWatcherTest::db_thread_name = "DB";
-const std::string ThreadWatcherTest::crash_on_hang_thread_names = "UI,IO";
-const std::string ThreadWatcherTest::thread_names_and_live_threshold =
+const char ThreadWatcherTest::db_thread_name[] = "DB";
+const char ThreadWatcherTest::crash_on_hang_thread_names[] = "UI,IO";
+const char ThreadWatcherTest::thread_names_and_live_threshold[] =
     "UI:4,IO:4";
-const std::string ThreadWatcherTest::crash_on_hang_thread_data =
+const char ThreadWatcherTest::crash_on_hang_thread_data[] =
     "UI:5:12,IO:5:12,FILE:5:12";
 
 TEST_F(ThreadWatcherTest, ThreadNamesOnlyArgs) {
   // Setup command_line arguments.
   base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
   command_line.AppendSwitchASCII(switches::kCrashOnHangThreads,
                                  crash_on_hang_thread_names);
 
   // Parse command_line arguments.
   ThreadWatcherList::CrashOnHangThreadMap crash_on_hang_threads;
@@ skipping 418 matching lines @@
     SPIN_FOR_TIMEDELTA_OR_UNTIL_TRUE(TimeDelta::FromMinutes(1),
                                      watchdog_thread_->Started());
     WaitForWatchDogThreadPostTask();
   }
 
   ~JankTimeBombTest() override {
     watchdog_thread_.reset();
   }
 
   static void WaitForWatchDogThreadPostTask() {
-    base::WaitableEvent watchdog_thread_event(false, false);
+    base::WaitableEvent watchdog_thread_event(
+        base::WaitableEvent::ResetPolicy::AUTOMATIC,
+        base::WaitableEvent::InitialState::NOT_SIGNALED);
     PostAndWaitForWatchdogThread(&watchdog_thread_event);
   }
 
  private:
   static void OnJankTimeBombTask(base::WaitableEvent* event) {
     event->Signal();
   }
 
   static void PostAndWaitForWatchdogThread(base::WaitableEvent* event) {
     WatchDogThread::PostDelayedTask(
@@ skipping 20 matching lines @@
 }
 
 TEST_F(JankTimeBombTest, ArmTest) {
   // Test firing of Alarm by passing empty delay.
   TestingJankTimeBomb timebomb((base::TimeDelta()));
   if (!timebomb.IsEnabled())
     return;
   WaitForWatchDogThreadPostTask();
   EXPECT_TRUE(timebomb.alarm_invoked());
 }