Migrate WaitableEvent to enum-based constructor in thread_watcher_unittest.cc

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 227 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 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 kIOThreadName[];
+  static const char kDBThreadName[];
+  static const char kCrashOnHangThreadNames[];
+  static const char kThreadNamesAndLiveThreshold[];
+  static const char kCrashOnHangThreadData[];
+
   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());
     db_thread_->StartAndWaitForTesting();
     io_thread_->StartAndWaitForTesting();
     watchdog_thread_->StartAndWaitForTesting();
 
     WatchDogThread::PostTask(
         FROM_HERE,
         base::Bind(&ThreadWatcherTest::SetUpObjects, base::Unretained(this)));
 
     WaitForSetUp(TimeDelta::FromMinutes(1));
   }
 
   void SetUpObjects() {
     DCHECK(WatchDogThread::CurrentlyOnWatchDogThread());
 
     // Setup the registry for thread watchers.
     thread_watcher_list_ = new ThreadWatcherList();
 
     // Create thread watcher object for the IO thread.
-    io_watcher_ = new CustomThreadWatcher(io_thread_id, io_thread_name,
+    io_watcher_ = new CustomThreadWatcher(BrowserThread::IO, kIOThreadName,
                                           kSleepTime, kUnresponsiveTime);
-    EXPECT_EQ(io_watcher_, thread_watcher_list_->Find(io_thread_id));
+    EXPECT_EQ(io_watcher_, thread_watcher_list_->Find(BrowserThread::IO));
 
     // Create thread watcher object for the DB thread.
-    db_watcher_ = new CustomThreadWatcher(
-        db_thread_id, db_thread_name, kSleepTime, kUnresponsiveTime);
-    EXPECT_EQ(db_watcher_, thread_watcher_list_->Find(db_thread_id));
+    db_watcher_ = new CustomThreadWatcher(BrowserThread::DB, kDBThreadName,
+                                          kSleepTime, kUnresponsiveTime);
+    EXPECT_EQ(db_watcher_, thread_watcher_list_->Find(BrowserThread::DB));
 
     {
       base::AutoLock lock(lock_);
       initialized_ = true;
     }
     setup_complete_.Signal();
   }
 
   void WaitForSetUp(TimeDelta wait_time) {
     DCHECK(!WatchDogThread::CurrentlyOnWatchDogThread());
@@ skipping 16 matching lines @@
   }
 
  private:
   base::MessageLoop message_loop_;
   base::Lock lock_;
   base::ConditionVariable setup_complete_;
   bool initialized_;
   std::unique_ptr<content::TestBrowserThread> db_thread_;
   std::unique_ptr<content::TestBrowserThread> io_thread_;
   std::unique_ptr<WatchDogThread> watchdog_thread_;
+
+  DISALLOW_COPY_AND_ASSIGN(ThreadWatcherTest);
 };
 
 // Define static constants.
-const TimeDelta ThreadWatcherTest::kSleepTime =
-    TimeDelta::FromMilliseconds(50);
+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 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 =
-    "UI:4,IO:4";
-const std::string ThreadWatcherTest::crash_on_hang_thread_data =
+const char ThreadWatcherTest::kIOThreadName[] = "IO";
+const char ThreadWatcherTest::kDBThreadName[] = "DB";
+const char ThreadWatcherTest::kCrashOnHangThreadNames[] = "UI,IO";
+const char ThreadWatcherTest::kThreadNamesAndLiveThreshold[] = "UI:4,IO:4";
+const char ThreadWatcherTest::kCrashOnHangThreadData[] =
     "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);
+                                 kCrashOnHangThreadNames);
 
   // Parse command_line arguments.
   ThreadWatcherList::CrashOnHangThreadMap crash_on_hang_threads;
   uint32_t unresponsive_threshold;
   ThreadWatcherList::ParseCommandLine(command_line,
                                       &unresponsive_threshold,
                                       &crash_on_hang_threads);
 
   // Verify the data.
-  base::StringTokenizer tokens(crash_on_hang_thread_names, ",");
+  base::CStringTokenizer tokens(
+      kCrashOnHangThreadNames,
+      kCrashOnHangThreadNames + (arraysize(kCrashOnHangThreadNames) - 1), ",");
   while (tokens.GetNext()) {
     std::vector<base::StringPiece> values = base::SplitStringPiece(
         tokens.token_piece(), ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     std::string thread_name = values[0].as_string();
 
     ThreadWatcherList::CrashOnHangThreadMap::iterator it =
         crash_on_hang_threads.find(thread_name);
     bool crash_on_hang = (it != crash_on_hang_threads.end());
     EXPECT_TRUE(crash_on_hang);
     EXPECT_LT(0u, it->second.live_threads_threshold);
     EXPECT_LT(0u, it->second.unresponsive_threshold);
   }
 }
 
 TEST_F(ThreadWatcherTest, ThreadNamesAndLiveThresholdArgs) {
   // Setup command_line arguments.
   base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
   command_line.AppendSwitchASCII(switches::kCrashOnHangThreads,
-                                 thread_names_and_live_threshold);
+                                 kThreadNamesAndLiveThreshold);
 
   // Parse command_line arguments.
   ThreadWatcherList::CrashOnHangThreadMap crash_on_hang_threads;
   uint32_t unresponsive_threshold;
   ThreadWatcherList::ParseCommandLine(command_line,
                                       &unresponsive_threshold,
                                       &crash_on_hang_threads);
 
   // Verify the data.
-  base::StringTokenizer tokens(thread_names_and_live_threshold, ",");
+  base::CStringTokenizer tokens(
+      kThreadNamesAndLiveThreshold,
+      kThreadNamesAndLiveThreshold +
+          (arraysize(kThreadNamesAndLiveThreshold) - 1),
+      ",");
   while (tokens.GetNext()) {
     std::vector<base::StringPiece> values = base::SplitStringPiece(
         tokens.token_piece(), ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     std::string thread_name = values[0].as_string();
 
     ThreadWatcherList::CrashOnHangThreadMap::iterator it =
         crash_on_hang_threads.find(thread_name);
     bool crash_on_hang = (it != crash_on_hang_threads.end());
     EXPECT_TRUE(crash_on_hang);
     EXPECT_EQ(4u, it->second.live_threads_threshold);
     EXPECT_LT(0u, it->second.unresponsive_threshold);
   }
 }
 
 TEST_F(ThreadWatcherTest, CrashOnHangThreadsAllArgs) {
   // Setup command_line arguments.
   base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
   command_line.AppendSwitchASCII(switches::kCrashOnHangThreads,
-                                 crash_on_hang_thread_data);
+                                 kCrashOnHangThreadData);
 
   // Parse command_line arguments.
   ThreadWatcherList::CrashOnHangThreadMap crash_on_hang_threads;
   uint32_t unresponsive_threshold;
   ThreadWatcherList::ParseCommandLine(command_line,
                                       &unresponsive_threshold,
                                       &crash_on_hang_threads);
 
   // Verify the data.
-  base::StringTokenizer tokens(crash_on_hang_thread_data, ",");
+  base::CStringTokenizer tokens(
+      kCrashOnHangThreadData,
+      kCrashOnHangThreadData + (arraysize(kCrashOnHangThreadData) - 1), ",");
   while (tokens.GetNext()) {
     std::vector<base::StringPiece> values = base::SplitStringPiece(
         tokens.token_piece(), ":", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     std::string thread_name = values[0].as_string();
 
     ThreadWatcherList::CrashOnHangThreadMap::iterator it =
         crash_on_hang_threads.find(thread_name);
 
     bool crash_on_hang = (it != crash_on_hang_threads.end());
     EXPECT_TRUE(crash_on_hang);
 
     uint32_t crash_live_threads_threshold = it->second.live_threads_threshold;
     EXPECT_EQ(5u, crash_live_threads_threshold);
 
     uint32_t crash_unresponsive_threshold = it->second.unresponsive_threshold;
     uint32_t crash_on_unresponsive_seconds =
         ThreadWatcherList::kUnresponsiveSeconds * crash_unresponsive_threshold;
     EXPECT_EQ(12u, crash_on_unresponsive_seconds);
   }
 }
 
 // Test registration. When thread_watcher_list_ goes out of scope after
 // TearDown, all thread watcher objects will be deleted.
 TEST_F(ThreadWatcherTest, Registration) {
   // Check ThreadWatcher object has all correct parameters.
-  EXPECT_EQ(io_thread_id, io_watcher_->thread_id());
-  EXPECT_EQ(io_thread_name, io_watcher_->thread_name());
+  EXPECT_EQ(BrowserThread::IO, io_watcher_->thread_id());
+  EXPECT_EQ(kIOThreadName, io_watcher_->thread_name());
   EXPECT_EQ(kSleepTime, io_watcher_->sleep_time());
   EXPECT_EQ(kUnresponsiveTime, io_watcher_->unresponsive_time());
   EXPECT_FALSE(io_watcher_->active());
 
   // Check ThreadWatcher object of watched DB thread has correct data.
-  EXPECT_EQ(db_thread_id, db_watcher_->thread_id());
-  EXPECT_EQ(db_thread_name, db_watcher_->thread_name());
+  EXPECT_EQ(BrowserThread::DB, db_watcher_->thread_id());
+  EXPECT_EQ(kDBThreadName, db_watcher_->thread_name());
   EXPECT_EQ(kSleepTime, db_watcher_->sleep_time());
   EXPECT_EQ(kUnresponsiveTime, db_watcher_->unresponsive_time());
   EXPECT_FALSE(db_watcher_->active());
 }
 
 // Test ActivateThreadWatching and DeActivateThreadWatching of IO thread. This
 // method also checks that pong message was sent by the watched thread and pong
 // message was received by the WatchDogThread. It also checks that
 // OnCheckResponsiveness has verified the ping-pong mechanism and the watched
 // thread is not hung.
@@ skipping 33 matching lines @@
 // This test posts a task on watched thread that takes very long time (this is
 // to simulate hanging of watched thread). It then checks for
 // OnCheckResponsiveness raising an alert (OnCheckResponsiveness returns false
 // if the watched thread is not responding).
 TEST_F(ThreadWatcherTest, ThreadNotResponding) {
   // Simulate hanging of watched thread by making the watched thread wait for a
   // very long time by posting a task on watched thread that keeps it busy.
   // It is safe to use base::Unretained because test is waiting for the method
   // to finish.
   BrowserThread::PostTask(
-      io_thread_id,
-      FROM_HERE,
+      BrowserThread::IO, FROM_HERE,
       base::Bind(&CustomThreadWatcher::VeryLongMethod,
-                 base::Unretained(io_watcher_),
-                 kUnresponsiveTime * 10));
+                 base::Unretained(io_watcher_), kUnresponsiveTime * 10));
 
   // Activate thread watching.
   WatchDogThread::PostTask(
       FROM_HERE,
       base::Bind(&ThreadWatcher::ActivateThreadWatching,
                  base::Unretained(io_watcher_)));
 
   // Verify watched thread is not responding for ping messages.
   io_watcher_->WaitForCheckResponse(
       kUnresponsiveTime + TimeDelta::FromMinutes(1), FAILED);
@@ skipping 60 matching lines @@
                  base::Unretained(db_watcher_)));
 }
 
 // Test watching of multiple threads with one of the threads not responding.
 TEST_F(ThreadWatcherTest, MultipleThreadsNotResponding) {
   // Simulate hanging of watched thread by making the watched thread wait for a
   // very long time by posting a task on watched thread that keeps it busy.
   // It is safe ot use base::Unretained because test is waiting for the method
   // to finish.
   BrowserThread::PostTask(
-      io_thread_id,
-      FROM_HERE,
+      BrowserThread::IO, FROM_HERE,
       base::Bind(&CustomThreadWatcher::VeryLongMethod,
-                 base::Unretained(io_watcher_),
-                 kUnresponsiveTime * 10));
+                 base::Unretained(io_watcher_), kUnresponsiveTime * 10));
 
   // Activate watching of DB thread.
   WatchDogThread::PostTask(
       FROM_HERE,
       base::Bind(&ThreadWatcher::ActivateThreadWatching,
                  base::Unretained(db_watcher_)));
 
   // Activate watching of IO thread.
   WatchDogThread::PostTask(
       FROM_HERE,
@@ skipping 166 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());
 }