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

chrome/browser/metrics/thread_watcher.h

 // 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.
 
 // This file defines a WatchDog thread that monitors the responsiveness of other
 // browser threads like UI, IO, DB, FILE and CACHED threads. It also defines
 // ThreadWatcher class which performs health check on threads that would like to
 // be watched. This file also defines ThreadWatcherList class that has list of
 // all active ThreadWatcher objects.
 //
@@ skipping 14 matching lines @@
 //   |unresponsive_threshold| specifies the number of unanswered ping messages
 //   after which watched (IO) thread is considered as not responsive.
 //   |crash_on_hang| specifies if we want to crash the browser when the watched
 //   (IO) thread has become sufficiently unresponsive, while other threads are
 //   sufficiently responsive. |live_threads_threshold| specifies the number of
 //   browser threads that are to be responsive when we want to crash the browser
 //   because of hung watched (IO) thread.
 //
 //   base::TimeDelta sleep_time = base::TimeDelta::FromSeconds(5);
 //   base::TimeDelta unresponsive_time = base::TimeDelta::FromSeconds(10);
-//   uint32 unresponsive_threshold = ThreadWatcherList::kUnresponsiveCount;
+//   uint32_t unresponsive_threshold = ThreadWatcherList::kUnresponsiveCount;
 //   bool crash_on_hang = false;
-//   uint32 live_threads_threshold = ThreadWatcherList::kLiveThreadsThreshold;
+//   uint32_t live_threads_threshold = ThreadWatcherList::kLiveThreadsThreshold;
 //   ThreadWatcher::StartWatching(
 //       BrowserThread::IO, "IO", sleep_time, unresponsive_time,
 //       unresponsive_threshold, crash_on_hang, live_threads_threshold);
 
 #ifndef CHROME_BROWSER_METRICS_THREAD_WATCHER_H_
 #define CHROME_BROWSER_METRICS_THREAD_WATCHER_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
-#include "base/basictypes.h"
+#include <stdint.h>
+
 #include "base/command_line.h"
 #include "base/gtest_prod_util.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/profiler/stack_sampling_profiler.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "base/threading/watchdog.h"
@@ skipping 11 matching lines @@
 // This class performs health check on threads that would like to be watched.
 class ThreadWatcher {
  public:
   // base::Bind supports methods with up to 6 parameters. WatchingParams is used
   // as a workaround that limitation for invoking ThreadWatcher::StartWatching.
   struct WatchingParams {
     const content::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;
     bool crash_on_hang;
-    uint32 live_threads_threshold;
+    uint32_t live_threads_threshold;
 
     WatchingParams(const content::BrowserThread::ID& thread_id_in,
                    const std::string& thread_name_in,
                    const base::TimeDelta& sleep_time_in,
                    const base::TimeDelta& unresponsive_time_in,
-                   uint32 unresponsive_threshold_in,
+                   uint32_t unresponsive_threshold_in,
                    bool crash_on_hang_in,
-                   uint32 live_threads_threshold_in)
+                   uint32_t live_threads_threshold_in)
         : thread_id(thread_id_in),
           thread_name(thread_name_in),
           sleep_time(sleep_time_in),
           unresponsive_time(unresponsive_time_in),
           unresponsive_threshold(unresponsive_threshold_in),
           crash_on_hang(crash_on_hang_in),
-          live_threads_threshold(live_threads_threshold_in) {
-    }
+          live_threads_threshold(live_threads_threshold_in) {}
   };
 
   // This method starts performing health check on the given |thread_id|. It
   // will create ThreadWatcher object for the given |thread_id|, |thread_name|.
   // |sleep_time| is the wait time between ping messages. |unresponsive_time| is
   // the wait time after ping message is sent, to check if we have received pong
   // message or not. |unresponsive_threshold| is used to determine if the thread
   // is responsive or not. The watched thread is considered unresponsive if it
   // hasn't responded with a pong message for |unresponsive_threshold| number of
   // ping messages. |crash_on_hang| specifies if browser should be crashed when
@@ skipping 16 matching lines @@
   // Return the the wait time to check the responsiveness of the thread.
   base::TimeDelta unresponsive_time() const { return unresponsive_time_; }
 
   // Returns true if we are montioring the thread.
   bool active() const { return active_; }
 
   // Returns |ping_time_| (used by unit tests).
   base::TimeTicks ping_time() const { return ping_time_; }
 
   // Returns |ping_sequence_number_| (used by unit tests).
-  uint64 ping_sequence_number() const { return ping_sequence_number_; }
+  uint64_t ping_sequence_number() const { return ping_sequence_number_; }
 
  protected:
   // Construct a ThreadWatcher for the given |thread_id|. |sleep_time| is the
   // wait time between ping messages. |unresponsive_time| is the wait time after
   // ping message is sent, to check if we have received pong message or not.
   explicit ThreadWatcher(const WatchingParams& params);
 
   virtual ~ThreadWatcher();
 
   // This method activates the thread watching which starts ping/pong messaging.
@@ skipping 14 matching lines @@
   // responsiveness of monitored thread that would be called after waiting
   // |unresponsive_time_|.
   // This method is accessible on WatchDogThread.
   virtual void PostPingMessage();
 
   // This method handles a Pong Message from watched thread. It will track the
   // response time (pong time minus ping time) via histograms. It posts a
   // PostPingMessage() task that would be called after waiting |sleep_time_|. It
   // increments |ping_sequence_number_| by 1.
   // This method is accessible on WatchDogThread.
-  virtual void OnPongMessage(uint64 ping_sequence_number);
+  virtual void OnPongMessage(uint64_t ping_sequence_number);
 
   // This method will determine if the watched thread is responsive or not. If
   // the latest |ping_sequence_number_| is not same as the
   // |ping_sequence_number| that is passed in, then we can assume that watched
   // thread has responded with a pong message.
   // This method is accessible on WatchDogThread.
-  virtual void OnCheckResponsiveness(uint64 ping_sequence_number);
+  virtual void OnCheckResponsiveness(uint64_t ping_sequence_number);
 
   // Set by OnCheckResponsiveness when it determines if the watched thread is
   // responsive or not.
   bool responsive_;
 
  private:
   friend class ThreadWatcherList;
   friend class CustomThreadWatcher;
 
   // Allow tests to access our innards for testing purposes.
@@ skipping 43 matching lines @@
 
   // This is the last time when ping message was sent.
   base::TimeTicks ping_time_;
 
   // This is the last time when we got pong message.
   base::TimeTicks pong_time_;
 
   // This is the sequence number of the next ping for which there is no pong. If
   // the instance is sleeping, then it will be the sequence number for the next
   // ping.
-  uint64 ping_sequence_number_;
+  uint64_t ping_sequence_number_;
 
   // This is set to true if thread watcher is watching.
   bool active_;
 
   // The counter tracks least number of ping messages that will be sent to
   // watched thread before the ping-pong mechanism will go into an extended
   // sleep. If this value is zero, then the mechanism is in an extended sleep,
   // and awaiting some observed user action before continuing.
   int ping_count_;
 
@@ skipping 10 matching lines @@
 
   // Histogram that keeps track of how many threads are not responding when we
   // got no response (GotNoResponse()) from the watched thread. Count includes
   // the thread that got no response.
   base::HistogramBase* unresponsive_count_histogram_;
 
   // This counter tracks the unresponsiveness of watched thread. If this value
   // is zero then watched thread has responded with a pong message. This is
   // incremented by 1 when we got no response (GotNoResponse()) from the watched
   // thread.
-  uint32 unresponsive_count_;
+  uint32_t unresponsive_count_;
 
   // This is set to true when we would have crashed the browser because the
   // watched thread hasn't responded at least |unresponsive_threshold_| times.
   // It is reset to false when watched thread responds with a pong message.
   bool hung_processing_complete_;
 
   // This is used to determine if the watched thread is responsive or not. If
   // watched thread's |unresponsive_count_| is greater than or equal to
   // |unresponsive_threshold_| then we would consider it as unresponsive.
-  uint32 unresponsive_threshold_;
+  uint32_t unresponsive_threshold_;
 
   // This is set to true if we want to crash the browser when the watched thread
   // has become sufficiently unresponsive, while other threads are sufficiently
   // responsive.
   bool crash_on_hang_;
 
   // This specifies the number of browser threads that are to be responsive when
   // we want to crash the browser because watched thread has become sufficiently
   // unresponsive.
-  uint32 live_threads_threshold_;
+  uint32_t live_threads_threshold_;
 
   // We use this factory to create callback tasks for ThreadWatcher object. We
   // use this during ping-pong messaging between WatchDog thread and watched
   // thread.
   base::WeakPtrFactory<ThreadWatcher> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadWatcher);
 };
 
 // Class with a list of all active thread watchers.  A thread watcher is active
@@ skipping 59 matching lines @@
   // |unresponsive_threshold| is 9), then we would always crash if the UI thread
   // was hung (9 unanswered ping messages), no matter what the other threads are
   // doing.
   // Example 3: If the |live_threads_threshold| value of "FILE" was 5 and
   // unresponsive threshold seconds is 90 (or |unresponsive_threshold| is 45),
   // then we would only crash if the FILE thread was the ONLY hung thread
   // (because we watch 6 threads). If there was another unresponsive thread, we
   // would not consider this a problem worth crashing for. FILE thread would be
   // considered as hung if it didn't respond for 45 ping messages.
   struct CrashDataThresholds {
-    CrashDataThresholds(uint32 live_threads_threshold,
-                        uint32 unresponsive_threshold);
+    CrashDataThresholds(uint32_t live_threads_threshold,
+                        uint32_t unresponsive_threshold);
     CrashDataThresholds();
 
-    uint32 live_threads_threshold;
-    uint32 unresponsive_threshold;
+    uint32_t live_threads_threshold;
+    uint32_t unresponsive_threshold;
   };
   typedef std::map<std::string, CrashDataThresholds> CrashOnHangThreadMap;
 
   // This method posts a task on WatchDogThread to start watching all browser
   // threads.
   // This method is accessible on UI thread.
   static void StartWatchingAll(const base::CommandLine& command_line);
 
   // This method posts a task on WatchDogThread to RevokeAll tasks and to
   // deactive thread watching of other threads and tell NotificationService to
   // stop calling Observe.
   // This method is accessible on UI thread.
   static void StopWatchingAll();
 
   // Register() stores a pointer to the given ThreadWatcher in a global map.
   static void Register(ThreadWatcher* watcher);
 
   // This method returns true if the ThreadWatcher object is registerd.
   static bool IsRegistered(const content::BrowserThread::ID thread_id);
 
   // This method returns number of responsive and unresponsive watched threads.
-  static void GetStatusOfThreads(uint32* responding_thread_count,
-                                 uint32* unresponding_thread_count);
+  static void GetStatusOfThreads(uint32_t* responding_thread_count,
+                                 uint32_t* unresponding_thread_count);
 
   // This will ensure that the watching is actively taking place, and awaken
   // all thread watchers that are registered.
   static void WakeUpAll();
 
  private:
   // Allow tests to access our innards for testing purposes.
   friend class CustomThreadWatcher;
   friend class ThreadWatcherListTest;
   friend class ThreadWatcherTest;
   FRIEND_TEST_ALL_PREFIXES(ThreadWatcherAndroidTest,
                            ApplicationStatusNotification);
   FRIEND_TEST_ALL_PREFIXES(ThreadWatcherListTest, Restart);
   FRIEND_TEST_ALL_PREFIXES(ThreadWatcherTest, ThreadNamesOnlyArgs);
   FRIEND_TEST_ALL_PREFIXES(ThreadWatcherTest, ThreadNamesAndLiveThresholdArgs);
   FRIEND_TEST_ALL_PREFIXES(ThreadWatcherTest, CrashOnHangThreadsAllArgs);
 
   // This singleton holds the global list of registered ThreadWatchers.
   ThreadWatcherList();
 
   // Destructor deletes all registered ThreadWatcher instances.
   virtual ~ThreadWatcherList();
 
   // Parses the command line to get |crash_on_hang_threads| map from
   // switches::kCrashOnHangThreads. |crash_on_hang_threads| is a map of
   // |crash_on_hang| thread's names to |CrashDataThresholds|.
-  static void ParseCommandLine(
-      const base::CommandLine& command_line,
-      uint32* unresponsive_threshold,
-      CrashOnHangThreadMap* crash_on_hang_threads);
+  static void ParseCommandLine(const base::CommandLine& command_line,
+                               uint32_t* unresponsive_threshold,
+                               CrashOnHangThreadMap* crash_on_hang_threads);
 
   // Parses the argument |crash_on_hang_thread_names| and creates
   // |crash_on_hang_threads| map of |crash_on_hang| thread's names to
   // |CrashDataThresholds|. If |crash_on_hang_thread_names| doesn't specify
   // |live_threads_threshold|, then it uses |default_live_threads_threshold| as
   // the value. If |crash_on_hang_thread_names| doesn't specify |crash_seconds|,
   // then it uses |default_crash_seconds| as the value.
   static void 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);
 
   // This constructs the |ThreadWatcherList| singleton and starts watching
   // browser threads by calling StartWatching() on each browser thread that is
   // watched. It disarms StartupTimeBomb.
   static void InitializeAndStartWatching(
-      uint32 unresponsive_threshold,
+      uint32_t unresponsive_threshold,
       const CrashOnHangThreadMap& crash_on_hang_threads);
 
   // This method calls ThreadWatcher::StartWatching() to perform health check on
   // the given |thread_id|.
-  static void StartWatching(
-      const content::BrowserThread::ID& thread_id,
-      const std::string& thread_name,
-      const base::TimeDelta& sleep_time,
-      const base::TimeDelta& unresponsive_time,
-      uint32 unresponsive_threshold,
-      const CrashOnHangThreadMap& crash_on_hang_threads);
+  static void StartWatching(const content::BrowserThread::ID& thread_id,
+                            const std::string& thread_name,
+                            const base::TimeDelta& sleep_time,
+                            const base::TimeDelta& unresponsive_time,
+                            uint32_t unresponsive_threshold,
+                            const CrashOnHangThreadMap& crash_on_hang_threads);
 
   // Delete all thread watcher objects and remove them from global map. It also
   // deletes |g_thread_watcher_list_|.
   static void DeleteAll();
 
   // The Find() method can be used to test to see if a given ThreadWatcher was
   // already registered, or to retrieve a pointer to it from the global map.
   static ThreadWatcher* Find(const content::BrowserThread::ID& thread_id);
 
   // Sets |g_stopped_| on the WatchDogThread. This is necessary to reflect the
@@ skipping 215 matching lines @@
   // shutdown_watchdog_ watches for hangs during shutdown.
   base::Watchdog* shutdown_watchdog_;
 
   // The |thread_id_| on which this object is constructed.
   const base::PlatformThreadId thread_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ShutdownWatcherHelper);
 };
 
 #endif  // CHROME_BROWSER_METRICS_THREAD_WATCHER_H_