Move BrowserThread to content namespace.

chrome/browser/metrics/thread_watcher.h

 // Copyright (c) 2011 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 56 matching lines @@
 class StartupTimeBomb;
 class ThreadWatcherList;
 class ThreadWatcherObserver;
 
 // 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 BrowserThread::ID& thread_id;
+    const content::BrowserThread::ID& thread_id;
     const std::string& thread_name;
     const base::TimeDelta& sleep_time;
     const base::TimeDelta& unresponsive_time;
     uint32 unresponsive_threshold;
     bool crash_on_hang;
     uint32 live_threads_threshold;
 
-    WatchingParams(const BrowserThread::ID& thread_id_in,
+    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,
                    bool crash_on_hang_in,
                    uint32 live_threads_threshold_in)
         : thread_id(thread_id_in),
           thread_name(thread_name_in),
           sleep_time(sleep_time_in),
           unresponsive_time(unresponsive_time_in),
@@ skipping 12 matching lines @@
   // hasn't responded with a pong message for |unresponsive_threshold| number of
   // ping messages. |crash_on_hang| specifies if browser should be crashed when
   // the watched thread is unresponsive. |live_threads_threshold| specifies the
   // number of browser threads that are to be responsive when we want to crash
   // the browser and watched thread has become sufficiently unresponsive. It
   // will register that ThreadWatcher object and activate the thread watching of
   // the given thread_id.
   static void StartWatching(const WatchingParams& params);
 
   // Return the |thread_id_| of the thread being watched.
-  BrowserThread::ID thread_id() const { return thread_id_; }
+  content::BrowserThread::ID thread_id() const { return thread_id_; }
 
   // Return the name of the thread being watched.
   std::string thread_name() const { return thread_name_; }
 
   // Return the sleep time between ping messages to be sent to the thread.
   base::TimeDelta sleep_time() const { return sleep_time_; }
 
   // Return the the wait time to check the responsiveness of the thread.
   base::TimeDelta unresponsive_time() const { return unresponsive_time_; }
 
@@ skipping 61 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(ThreadWatcherTest, ThreadResponding);
   FRIEND_TEST_ALL_PREFIXES(ThreadWatcherTest, ThreadNotResponding);
   FRIEND_TEST_ALL_PREFIXES(ThreadWatcherTest, MultipleThreadsResponding);
   FRIEND_TEST_ALL_PREFIXES(ThreadWatcherTest, MultipleThreadsNotResponding);
 
   // Post constructor initialization.
   void Initialize();
 
   // Watched thread does nothing except post callback_task to the WATCHDOG
   // Thread. This method is called on watched thread.
-  static void OnPingMessage(const BrowserThread::ID& thread_id,
+  static void OnPingMessage(const content::BrowserThread::ID& thread_id,
                             const base::Closure& callback_task);
 
   // This method resets |unresponsive_count_| to zero because watched thread is
   // responding to the ping message with a pong message.
   void ResetHangCounters();
 
   // This method records watched thread is not responding to the ping message.
   // It increments |unresponsive_count_| by 1.
   void GotNoResponse();
 
   // This method returns true if the watched thread has not responded with a
   // pong message for |unresponsive_threshold_| number of ping messages.
   bool IsVeryUnresponsive();
 
   // The |thread_id_| of the thread being watched. Only one instance can exist
   // for the given |thread_id_| of the thread being watched.
-  const BrowserThread::ID thread_id_;
+  const content::BrowserThread::ID thread_id_;
 
   // The name of the thread being watched.
   const std::string thread_name_;
 
   // Used to post messages to watched thread.
   scoped_refptr<base::MessageLoopProxy> watched_loop_;
 
   // It is the sleep time between the receipt of a pong message back, and the
   // sending of another ping message.
   const base::TimeDelta sleep_time_;
@@ skipping 72 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ThreadWatcher);
 };
 
 // Class with a list of all active thread watchers.  A thread watcher is active
 // if it has been registered, which includes determing the histogram name. This
 // class provides utility functions to start and stop watching all browser
 // threads. Only one instance of this class exists.
 class ThreadWatcherList {
  public:
   // A map from BrowserThread to the actual instances.
-  typedef std::map<BrowserThread::ID, ThreadWatcher*> RegistrationList;
+  typedef std::map<content::BrowserThread::ID, ThreadWatcher*> RegistrationList;
 
   // This method posts a task on WatchDogThread to start watching all browser
   // threads.
   // This method is accessible on UI thread.
   static void StartWatchingAll(const 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 BrowserThread::ID thread_id);
+  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);
 
   // This will ensure that the watching is actively taking place, and awaken
   // all thread watchers that are registered.
   static void WakeUpAll();
 
  private:
@@ skipping 23 matching lines @@
   // browser threads by calling StartWatching() on each browser thread that is
   // watched. It disarms StartupTimeBomb.
   static void InitializeAndStartWatching(
       uint32 unresponsive_threshold,
       const std::set<std::string>& crash_on_hang_thread_names,
       uint32 live_threads_threshold);
 
   // This method calls ThreadWatcher::StartWatching() to perform health check on
   // the given |thread_id|.
   static void StartWatching(
-      const BrowserThread::ID& thread_id,
+      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 std::set<std::string>& crash_on_hang_thread_names,
       uint32 live_threads_threshold);
 
   // 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 BrowserThread::ID& thread_id);
+  static ThreadWatcher* Find(const content::BrowserThread::ID& thread_id);
 
   // The singleton of this class and is used to keep track of information about
   // threads that are being watched.
   static ThreadWatcherList* g_thread_watcher_list_;
 
   // This is the wait time between ping messages.
   static const int kSleepSeconds;
 
   // This is the wait time after ping message is sent, to check if we have
   // received pong message or not.
@@ skipping 137 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ShutdownWatcherHelper);
 };
 
 // DISABLE_RUNNABLE_METHOD_REFCOUNT is a convenience macro for disabling
 // refcounting of ThreadWatcher and ThreadWatcherList classes.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(ThreadWatcher);
 DISABLE_RUNNABLE_METHOD_REFCOUNT(ThreadWatcherList);
 
 #endif  // CHROME_BROWSER_METRICS_THREAD_WATCHER_H_