Switch to standard integer types in chrome/browser/, part 2 of 4.

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 <math.h>
+#include <stdint.h>
 
-#include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/spin_wait.h"
@@ skipping 38 matching lines @@
 // thread that keeps it busy. It also has an utility method to block running of
 // tests until ThreadWatcher object's post-condition state changes to an
 // expected state.
 class CustomThreadWatcher : public ThreadWatcher {
  public:
   base::Lock custom_lock_;
   base::ConditionVariable state_changed_;
   State thread_watcher_state_;
   WaitState wait_state_;
   CheckResponseState check_response_state_;
-  uint64 ping_sent_;
-  uint64 pong_received_;
+  uint64_t ping_sent_;
+  uint64_t pong_received_;
   base::subtle::Atomic32 success_response_;
   base::subtle::Atomic32 failed_response_;
   base::TimeTicks saved_ping_time_;
-  uint64 saved_ping_sequence_number_;
+  uint64_t saved_ping_sequence_number_;
 
   CustomThreadWatcher(const BrowserThread::ID thread_id,
                       const std::string thread_name,
                       const TimeDelta& sleep_time,
                       const TimeDelta& unresponsive_time)
       : ThreadWatcher(WatchingParams(thread_id, thread_name, sleep_time,
                       unresponsive_time, ThreadWatcherList::kUnresponsiveCount,
                       true, ThreadWatcherList::kLiveThreadsThreshold)),
         state_changed_(&custom_lock_),
         thread_watcher_state_(INITIALIZED),
@@ skipping 48 matching lines @@
                 old_state == RECEIVED_PONG);
     ThreadWatcher::DeActivateThreadWatching();
   }
 
   void PostPingMessage() override {
     State old_state = UpdateState(SENT_PING);
     EXPECT_TRUE(old_state == ACTIVATED || old_state == RECEIVED_PONG);
     ThreadWatcher::PostPingMessage();
   }
 
-  void OnPongMessage(uint64 ping_sequence_number) override {
+  void OnPongMessage(uint64_t ping_sequence_number) override {
     State old_state = UpdateState(RECEIVED_PONG);
     EXPECT_TRUE(old_state == SENT_PING || old_state == DEACTIVATED);
     ThreadWatcher::OnPongMessage(ping_sequence_number);
   }
 
-  void OnCheckResponsiveness(uint64 ping_sequence_number) override {
+  void OnCheckResponsiveness(uint64_t ping_sequence_number) override {
     ThreadWatcher::OnCheckResponsiveness(ping_sequence_number);
     {
       base::AutoLock auto_lock(custom_lock_);
       if (responsive_) {
         base::subtle::Release_Store(&success_response_,
             base::subtle::Acquire_Load(&success_response_) + 1);
         check_response_state_ = SUCCESSFUL;
       } else {
         base::subtle::Release_Store(&failed_response_,
             base::subtle::Acquire_Load(&failed_response_) + 1);
@@ skipping 21 matching lines @@
     UpdateWaitState(ALL_DONE);
   }
 
   State WaitForStateChange(const TimeDelta& wait_time, State expected_state) {
     DCHECK(!WatchDogThread::CurrentlyOnWatchDogThread());
     UpdateWaitState(STARTED_WAITING);
 
     State exit_state = INITIALIZED;
     // Keep the thread that is running the tests waiting until ThreadWatcher
     // object's state changes to the expected_state or until wait_time elapses.
-    for (uint32 i = 0; i < unresponsive_threshold_; ++i) {
+    for (uint32_t i = 0; i < unresponsive_threshold_; ++i) {
         TimeTicks end_time = TimeTicks::Now() + wait_time;
         {
           base::AutoLock auto_lock(custom_lock_);
           while (thread_watcher_state_ != expected_state &&
                  TimeTicks::Now() < end_time) {
             TimeDelta state_change_wait_time = end_time - TimeTicks::Now();
             state_changed_.TimedWait(state_change_wait_time);
           }
           // Capture the thread_watcher_state_ before it changes and return it
           // to the caller.
           exit_state = thread_watcher_state_;
           if (exit_state == expected_state)
             break;
         }
     }
     UpdateWaitState(STOPPED_WAITING);
     return exit_state;
   }
 
   CheckResponseState WaitForCheckResponse(const TimeDelta& wait_time,
                                           CheckResponseState expected_state) {
     DCHECK(!WatchDogThread::CurrentlyOnWatchDogThread());
     UpdateWaitState(STARTED_WAITING);
 
     CheckResponseState exit_state = UNKNOWN;
     // Keep the thread that is running the tests waiting until ThreadWatcher
     // object's check_response_state_ changes to the expected_state or until
     // wait_time elapses.
-    for (uint32 i = 0; i < unresponsive_threshold_; ++i) {
+    for (uint32_t i = 0; i < unresponsive_threshold_; ++i) {
         TimeTicks end_time = TimeTicks::Now() + wait_time;
         {
           base::AutoLock auto_lock(custom_lock_);
           while (check_response_state_ != expected_state &&
                  TimeTicks::Now() < end_time) {
             TimeDelta state_change_wait_time = end_time - TimeTicks::Now();
             state_changed_.TimedWait(state_change_wait_time);
           }
           // Capture the check_response_state_ before it changes and return it
           // to the caller.
@@ skipping 109 matching lines @@
     "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;
-  uint32 unresponsive_threshold;
+  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, ",");
   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);
 
   // Parse command_line arguments.
   ThreadWatcherList::CrashOnHangThreadMap crash_on_hang_threads;
-  uint32 unresponsive_threshold;
+  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, ",");
   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);
 
   // Parse command_line arguments.
   ThreadWatcherList::CrashOnHangThreadMap crash_on_hang_threads;
-  uint32 unresponsive_threshold;
+  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, ",");
   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 crash_live_threads_threshold = it->second.live_threads_threshold;
+    uint32_t crash_live_threads_threshold = it->second.live_threads_threshold;
     EXPECT_EQ(5u, crash_live_threads_threshold);
 
-    uint32 crash_unresponsive_threshold = it->second.unresponsive_threshold;
-    uint32 crash_on_unresponsive_seconds =
+    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());
@@ skipping 20 matching lines @@
   // Activate watching IO thread.
   WatchDogThread::PostTask(
       FROM_HERE,
       base::Bind(&ThreadWatcher::ActivateThreadWatching,
                  base::Unretained(io_watcher_)));
 
   // Activate would have started ping/pong messaging. Expect atleast one
   // ping/pong messaging sequence to happen.
   io_watcher_->WaitForStateChange(kSleepTime + TimeDelta::FromMinutes(1),
                                   RECEIVED_PONG);
-  EXPECT_GT(io_watcher_->ping_sent_, static_cast<uint64>(0));
-  EXPECT_GT(io_watcher_->pong_received_, static_cast<uint64>(0));
+  EXPECT_GT(io_watcher_->ping_sent_, static_cast<uint64_t>(0));
+  EXPECT_GT(io_watcher_->pong_received_, static_cast<uint64_t>(0));
   EXPECT_TRUE(io_watcher_->active());
   EXPECT_GE(io_watcher_->saved_ping_time_, time_before_ping);
-  EXPECT_GE(io_watcher_->saved_ping_sequence_number_, static_cast<uint64>(0));
+  EXPECT_GE(io_watcher_->saved_ping_sequence_number_, static_cast<uint64_t>(0));
 
   // Verify watched thread is responding with ping/pong messaging.
   io_watcher_->WaitForCheckResponse(
       kUnresponsiveTime + TimeDelta::FromMinutes(1), SUCCESSFUL);
   EXPECT_GT(base::subtle::NoBarrier_Load(&(io_watcher_->success_response_)),
       static_cast<base::subtle::Atomic32>(0));
   EXPECT_EQ(base::subtle::NoBarrier_Load(&(io_watcher_->failed_response_)),
       static_cast<base::subtle::Atomic32>(0));
 
   // DeActivate thread watching for shutdown.
@@ skipping 53 matching lines @@
 
   // Check for IO thread to perform ping/pong messaging.
   WatchDogThread::PostTask(
       FROM_HERE,
       base::Bind(&ThreadWatcher::ActivateThreadWatching,
                  base::Unretained(io_watcher_)));
 
   // Verify DB thread is responding with ping/pong messaging.
   db_watcher_->WaitForCheckResponse(
       kUnresponsiveTime + TimeDelta::FromMinutes(1), SUCCESSFUL);
-  EXPECT_GT(db_watcher_->ping_sent_, static_cast<uint64>(0));
-  EXPECT_GT(db_watcher_->pong_received_, static_cast<uint64>(0));
-  EXPECT_GE(db_watcher_->ping_sequence_number_, static_cast<uint64>(0));
+  EXPECT_GT(db_watcher_->ping_sent_, static_cast<uint64_t>(0));
+  EXPECT_GT(db_watcher_->pong_received_, static_cast<uint64_t>(0));
+  EXPECT_GE(db_watcher_->ping_sequence_number_, static_cast<uint64_t>(0));
   EXPECT_GT(base::subtle::NoBarrier_Load(&(db_watcher_->success_response_)),
       static_cast<base::subtle::Atomic32>(0));
   EXPECT_EQ(base::subtle::NoBarrier_Load(&(db_watcher_->failed_response_)),
       static_cast<base::subtle::Atomic32>(0));
 
   // Verify IO thread is responding with ping/pong messaging.
   io_watcher_->WaitForCheckResponse(
       kUnresponsiveTime + TimeDelta::FromMinutes(1), SUCCESSFUL);
-  EXPECT_GT(io_watcher_->ping_sent_, static_cast<uint64>(0));
-  EXPECT_GT(io_watcher_->pong_received_, static_cast<uint64>(0));
-  EXPECT_GE(io_watcher_->ping_sequence_number_, static_cast<uint64>(0));
+  EXPECT_GT(io_watcher_->ping_sent_, static_cast<uint64_t>(0));
+  EXPECT_GT(io_watcher_->pong_received_, static_cast<uint64_t>(0));
+  EXPECT_GE(io_watcher_->ping_sequence_number_, static_cast<uint64_t>(0));
   EXPECT_GT(base::subtle::NoBarrier_Load(&(io_watcher_->success_response_)),
       static_cast<base::subtle::Atomic32>(0));
   EXPECT_EQ(base::subtle::NoBarrier_Load(&(io_watcher_->failed_response_)),
       static_cast<base::subtle::Atomic32>(0));
 
   // DeActivate thread watching for shutdown.
   WatchDogThread::PostTask(
       FROM_HERE,
       base::Bind(&ThreadWatcher::DeActivateThreadWatching,
                  base::Unretained(io_watcher_)));
@@ skipping 236 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());
 }