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

chrome/browser/metrics/thread_watcher.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>  // ceil
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/debug/dump_without_crashing.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
+#include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "build/build_config.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/metrics/thread_watcher_report_hang.h"
@@ skipping 130 matching lines @@
           FROM_HERE,
           base::Bind(&ThreadWatcher::OnCheckResponsiveness,
                      weak_ptr_factory_.GetWeakPtr(), ping_sequence_number_),
           unresponsive_time_);
   } else {
     // Watched thread might have gone away, stop watching it.
     DeActivateThreadWatching();
   }
 }
 
-void ThreadWatcher::OnPongMessage(uint64 ping_sequence_number) {
+void ThreadWatcher::OnPongMessage(uint64_t ping_sequence_number) {
   DCHECK(WatchDogThread::CurrentlyOnWatchDogThread());
 
   // Record watched thread's response time.
   base::TimeTicks now = base::TimeTicks::Now();
   base::TimeDelta response_time = now - ping_time_;
   response_time_histogram_->AddTime(response_time);
 
   // Save the current time when we have got pong message.
   pong_time_ = now;
 
@@ skipping 10 matching lines @@
   // ping messages.
   if (!active_ || --ping_count_ <= 0)
     return;
 
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&ThreadWatcher::PostPingMessage,
                             weak_ptr_factory_.GetWeakPtr()),
       sleep_time_);
 }
 
-void ThreadWatcher::OnCheckResponsiveness(uint64 ping_sequence_number) {
+void ThreadWatcher::OnCheckResponsiveness(uint64_t ping_sequence_number) {
   DCHECK(WatchDogThread::CurrentlyOnWatchDogThread());
   // If we have stopped watching then consider thread as responding.
   if (!active_) {
     responsive_ = true;
     return;
   }
   // If the latest ping_sequence_number_ is not same as the ping_sequence_number
   // that is passed in, then we can assume OnPongMessage was called.
   // OnPongMessage increments ping_sequence_number_.
   if (ping_sequence_number_ != ping_sequence_number) {
@@ skipping 72 matching lines @@
 
   // Record total unresponsive_time since last pong message.
   base::TimeDelta unresponse_time = base::TimeTicks::Now() - pong_time_;
   unresponsive_time_histogram_->AddTime(unresponse_time);
 
   // We have already collected stats for the non-responding watched thread.
   if (hung_processing_complete_)
     return;
 
   // Record how other threads are responding.
-  uint32 responding_thread_count = 0;
-  uint32 unresponding_thread_count = 0;
+  uint32_t responding_thread_count = 0;
+  uint32_t unresponding_thread_count = 0;
   ThreadWatcherList::GetStatusOfThreads(&responding_thread_count,
                                         &unresponding_thread_count);
 
   // Record how many watched threads are responding.
   responsive_count_histogram_->Add(responding_thread_count);
 
   // Record how many watched threads are not responding.
   unresponsive_count_histogram_->Add(unresponding_thread_count);
 
   // Crash the browser if the watched thread is to be crashed on hang and if the
@@ skipping 28 matching lines @@
 // static
 const int ThreadWatcherList::kUnresponsiveSeconds = 2;
 // static
 const int ThreadWatcherList::kUnresponsiveCount = 9;
 // static
 const int ThreadWatcherList::kLiveThreadsThreshold = 2;
 // static, non-const for tests.
 int ThreadWatcherList::g_initialize_delay_seconds = 120;
 
 ThreadWatcherList::CrashDataThresholds::CrashDataThresholds(
-    uint32 live_threads_threshold,
-    uint32 unresponsive_threshold)
+    uint32_t live_threads_threshold,
+    uint32_t unresponsive_threshold)
     : live_threads_threshold(live_threads_threshold),
-      unresponsive_threshold(unresponsive_threshold) {
-}
+      unresponsive_threshold(unresponsive_threshold) {}
 
 ThreadWatcherList::CrashDataThresholds::CrashDataThresholds()
     : live_threads_threshold(kLiveThreadsThreshold),
       unresponsive_threshold(kUnresponsiveCount) {
 }
 
 // static
 void ThreadWatcherList::StartWatchingAll(
     const base::CommandLine& command_line) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  uint32 unresponsive_threshold;
+  uint32_t unresponsive_threshold;
   CrashOnHangThreadMap crash_on_hang_threads;
   ParseCommandLine(command_line,
                    &unresponsive_threshold,
                    &crash_on_hang_threads);
 
   ThreadWatcherObserver::SetupNotifications(
       base::TimeDelta::FromSeconds(kSleepSeconds * unresponsive_threshold));
 
   WatchDogThread::PostTask(
       FROM_HERE,
@@ skipping 27 matching lines @@
   g_thread_watcher_list_->registered_[watcher->thread_id()] = watcher;
 }
 
 // static
 bool ThreadWatcherList::IsRegistered(const BrowserThread::ID thread_id) {
   DCHECK(WatchDogThread::CurrentlyOnWatchDogThread());
   return nullptr != ThreadWatcherList::Find(thread_id);
 }
 
 // static
-void ThreadWatcherList::GetStatusOfThreads(uint32* responding_thread_count,
-                                           uint32* unresponding_thread_count) {
+void ThreadWatcherList::GetStatusOfThreads(
+    uint32_t* responding_thread_count,
+    uint32_t* unresponding_thread_count) {
   DCHECK(WatchDogThread::CurrentlyOnWatchDogThread());
   *responding_thread_count = 0;
   *unresponding_thread_count = 0;
   if (!g_thread_watcher_list_)
     return;
 
   for (RegistrationList::iterator it =
            g_thread_watcher_list_->registered_.begin();
        g_thread_watcher_list_->registered_.end() != it;
        ++it) {
@@ skipping 25 matching lines @@
 
 ThreadWatcherList::~ThreadWatcherList() {
   DCHECK(WatchDogThread::CurrentlyOnWatchDogThread());
   DCHECK(this == g_thread_watcher_list_);
   g_thread_watcher_list_ = nullptr;
 }
 
 // static
 void ThreadWatcherList::ParseCommandLine(
     const base::CommandLine& command_line,
-    uint32* unresponsive_threshold,
+    uint32_t* unresponsive_threshold,
     CrashOnHangThreadMap* crash_on_hang_threads) {
   // Initialize |unresponsive_threshold| to a default value.
   *unresponsive_threshold = kUnresponsiveCount;
 
   // Increase the unresponsive_threshold on the Stable and Beta channels to
   // reduce the number of crashes due to ThreadWatcher.
   version_info::Channel channel = chrome::GetChannel();
   if (channel == version_info::Channel::STABLE) {
     *unresponsive_threshold *= 4;
   } else if (channel == version_info::Channel::BETA) {
     *unresponsive_threshold *= 2;
   }
 
 #if defined(OS_WIN)
   // For Windows XP (old systems), double the unresponsive_threshold to give
   // the OS a chance to schedule UI/IO threads a time slice to respond with a
   // pong message (to get around limitations with the OS).
   if (base::win::GetVersion() <= base::win::VERSION_XP)
     *unresponsive_threshold *= 2;
 #endif
 
-  uint32 crash_seconds = *unresponsive_threshold * kUnresponsiveSeconds;
+  uint32_t crash_seconds = *unresponsive_threshold * kUnresponsiveSeconds;
   std::string crash_on_hang_thread_names;
   if (command_line.HasSwitch(switches::kCrashOnHangThreads)) {
     crash_on_hang_thread_names =
         command_line.GetSwitchValueASCII(switches::kCrashOnHangThreads);
   } else if (channel != version_info::Channel::STABLE) {
     // Default to crashing the browser if UI or IO or FILE threads are not
     // responsive except in stable channel.
     crash_on_hang_thread_names = base::StringPrintf(
         "UI:%d:%d,IO:%d:%d,FILE:%d:%d",
         kLiveThreadsThreshold, crash_seconds,
         kLiveThreadsThreshold, crash_seconds,
         kLiveThreadsThreshold, crash_seconds * 5);
   }
 
   ParseCommandLineCrashOnHangThreads(crash_on_hang_thread_names,
                                      kLiveThreadsThreshold,
                                      crash_seconds,
                                      crash_on_hang_threads);
 }
 
 // static
 void ThreadWatcherList::ParseCommandLineCrashOnHangThreads(
     const std::string& crash_on_hang_thread_names,
-    uint32 default_live_threads_threshold,
-    uint32 default_crash_seconds,
+    uint32_t default_live_threads_threshold,
+    uint32_t default_crash_seconds,
     CrashOnHangThreadMap* crash_on_hang_threads) {
   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();
 
-    uint32 live_threads_threshold = default_live_threads_threshold;
-    uint32 crash_seconds = default_crash_seconds;
+    uint32_t live_threads_threshold = default_live_threads_threshold;
+    uint32_t crash_seconds = default_crash_seconds;
     if (values.size() >= 2 &&
         (!base::StringToUint(values[1], &live_threads_threshold))) {
       continue;
     }
     if (values.size() >= 3 &&
         (!base::StringToUint(values[2], &crash_seconds))) {
       continue;
     }
-    uint32 unresponsive_threshold = static_cast<uint32>(
+    uint32_t unresponsive_threshold = static_cast<uint32_t>(
         ceil(static_cast<float>(crash_seconds) / kUnresponsiveSeconds));
 
     CrashDataThresholds crash_data(live_threads_threshold,
                                    unresponsive_threshold);
     // Use the last specifier.
     (*crash_on_hang_threads)[thread_name] = crash_data;
   }
 }
 
 // static
 void ThreadWatcherList::InitializeAndStartWatching(
-    uint32 unresponsive_threshold,
+    uint32_t unresponsive_threshold,
     const CrashOnHangThreadMap& crash_on_hang_threads) {
   DCHECK(WatchDogThread::CurrentlyOnWatchDogThread());
 
   // Disarm the startup timebomb, even if stop has been called.
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&StartupTimeBomb::DisarmStartupTimeBomb));
 
   // This method is deferred in relationship to its StopWatchingAll()
@@ skipping 31 matching lines @@
   StartWatching(BrowserThread::CACHE, "CACHE", kSleepTime, kUnresponsiveTime,
                 unresponsive_threshold, crash_on_hang_threads);
 }
 
 // static
 void ThreadWatcherList::StartWatching(
     const BrowserThread::ID& thread_id,
     const std::string& thread_name,
     const base::TimeDelta& sleep_time,
     const base::TimeDelta& unresponsive_time,
-    uint32 unresponsive_threshold,
+    uint32_t unresponsive_threshold,
     const CrashOnHangThreadMap& crash_on_hang_threads) {
   DCHECK(WatchDogThread::CurrentlyOnWatchDogThread());
 
   CrashOnHangThreadMap::const_iterator it =
       crash_on_hang_threads.find(thread_name);
   bool crash_on_hang = false;
-  uint32 live_threads_threshold = 0;
+  uint32_t live_threads_threshold = 0;
   if (it != crash_on_hang_threads.end()) {
     crash_on_hang = true;
     live_threads_threshold = it->second.live_threads_threshold;
     unresponsive_threshold = it->second.unresponsive_threshold;
   }
 
   ThreadWatcher::StartWatching(
       ThreadWatcher::WatchingParams(thread_id,
                                     thread_name,
                                     sleep_time,
@@ skipping 404 matching lines @@
 
 #if defined(OS_WIN)
   // On Windows XP, give twice the time for shutdown.
   if (base::win::GetVersion() <= base::win::VERSION_XP)
     actual_duration *= 2;
 #endif
 
   shutdown_watchdog_ = new ShutdownWatchDogThread(actual_duration);
   shutdown_watchdog_->Arm();
 }