Added command line switches "crash-on-hang-threads" and "crash-on-hang-seconds"

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 14 matching lines @@
 //
 //   base::TimeDelta sleep_time = base::TimeDelta::FromSeconds(5);
 //   base::TimeDelta unresponsive_time = base::TimeDelta::FromSeconds(10);
 //   ThreadWatcher::StartWatching(BrowserThread::IO, "IO", sleep_time,
 //                                unresponsive_time);
 
 #ifndef CHROME_BROWSER_METRICS_THREAD_WATCHER_H_
 #define CHROME_BROWSER_METRICS_THREAD_WATCHER_H_
 
 #include <map>
+#include <set>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/command_line.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/synchronization/lock.h"
 #include "base/task.h"
 #include "base/threading/thread.h"
 #include "base/time.h"
 #include "content/browser/browser_thread.h"
@@ skipping 102 matching lines @@
                             Task* 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();
 
+  // Helper method to get |unresponsive_count_|.
+  uint32 unresponsive_count() const { return unresponsive_count_; }
+
   // This is the number of ping messages to be sent when the user is idle.
   // ping_count_ will be initialized to kPingCount whenever user becomes active.
   static const int kPingCount;
 
-  // This value is used to determine if the watched thread is responsive or not.
-  // If unresponsive_count_ is less than kUnresponsiveCount then watched thread
-  // is considered as responsive (in responsive_count_histogram_) otherwise it
-  // is considered as unresponsive (in unresponsive_count_histogram_).
-  static const int kUnresponsiveCount;
-
   // 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_;
 
   // The name of the thread being watched.
   const std::string thread_name_;
 
   // It is the sleep time between between the receipt of a pong message back,
   // and the sending of another ping message.
   const base::TimeDelta sleep_time_;
@@ skipping 35 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::Histogram* 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.
-  int unresponsive_count_;
+  uint32 unresponsive_count_;
 
   // This is set to true when we would have crashed the browser because the
   // watched thread hasn't responded atleast 6 times. It is reset to false when
   // watched thread responds with a pong message.
   bool hung_processing_complete_;
 
   // We use this factory to create callback tasks for ThreadWatcher object. We
   // use this during ping-pong messaging between WatchDog thread and watched
   // thread.
   ScopedRunnableMethodFactory<ThreadWatcher> method_factory_;
 
   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 NotificationObserver {
  public:
   // A map from BrowserThread to the actual instances.
   typedef std::map<BrowserThread::ID, ThreadWatcher*> RegistrationList;
 
   // This singleton holds the global list of registered ThreadWatchers.
-  ThreadWatcherList();
+  explicit ThreadWatcherList(const CommandLine& command_line);
   // Destructor deletes all registered ThreadWatcher instances.
   virtual ~ThreadWatcherList();
 
   // 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);
 
   // This method posts a task on WatchDogThread to start watching all browser
   // threads.
   // This method is accessible on UI thread.
   static void StartWatchingAll();
 
   // 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();
 
   // RemoveAll NotificationTypes that are being observed.
   // This method is accessible on UI thread.
   static void RemoveNotifications();
 
+  // Returns true if watched thread's |unresponsive_count_| is less than
+  // |crash_on_unresponsive_count_|. A watched thread is considered as
+  // unresponsive if it has not responded with a pong message for
+  // |crash_on_unresponsive_count_| number of ping messages.
+  static bool IsResponsive(ThreadWatcher* watcher);
+
+  // Returns true if the watched thread is not responsive and is listed
+  // as one of the threads in "--crash-on-hang-threads" command line switch.
+  static bool CrashOnHang(ThreadWatcher* watcher);
+
   // This method returns number of watched threads that have responded and
-  // threads that have not responded with a pong message.
+  // threads that have not responded with a pong message for
+  // |crash_on_unresponsive_count_| number of ping messages.
   static void GetStatusOfThreads(int* no_of_responding_threads,
                                  int* no_of_unresponding_threads);
 
  private:
   // Allow tests to access our innards for testing purposes.
   FRIEND_TEST_ALL_PREFIXES(ThreadWatcherTest, Registration);
 
   // Delete all thread watcher objects and remove them from global map.
   // This method is accessible on WatchDogThread.
   void DeleteAll();
@@ skipping 21 matching lines @@
 
   static ThreadWatcherList* global_;  // The singleton of this class.
 
   // 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.
   static const int kUnresponsiveSeconds;
 
+  // This is used to initialize |crash_on_unresponsive_count_|.
+  // |crash_on_unresponsive_count_| is used to determine if the watched thread
+  // is responsive or not.

[jar (doing other things), 2011/06/10 00:38:33]

nit: Don't bother explaining the variable... since it has its own comment.  All
you need is:

// Default values for |crash_on_unresponsive_count_|.

[ramant (doing other things), 2011/06/13 03:26:02]

Done.

+  static const int kUnresponsiveCount;
+
   // Lock for access to registered_.
   base::Lock lock_;
 
   // Map of all registered watched threads, from thread_id to ThreadWatcher.
   RegistrationList registered_;
 
   // The registrar that holds NotificationTypes to be observed.
   NotificationRegistrar registrar_;
 
   // This is the last time when woke all thread watchers up.
   base::TimeTicks last_wakeup_time_;
 
+  // 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
+  // |crash_on_unresponsive_count_| then we could crash the browser if the
+  // watched thread is listed in the "--crash-on-hang-threads" command line
+  // switch. It is initialized with |kUnresponsiveCount|, but can be overwritten
+  // by the command line switch "--crash-on-hang-seconds".
+  uint32 crash_on_unresponsive_count_;
+
+  // This is the set of watched thread's names that are to be crashed if they
+  // have not responded with a pong message for |crash_on_unresponsive_count_|
+  // number of ping messages.
+  std::set<std::string> crash_on_hang_thread_names_;
+
   DISALLOW_COPY_AND_ASSIGN(ThreadWatcherList);
 };
 
 // Class for WatchDogThread and in its Init method, we start watching UI, IO,
 // DB, FILE, CACHED threads.
 class WatchDogThread : public base::Thread {
  public:
   // Constructor.
   WatchDogThread();
 
@@ skipping 32 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(WatchDogThread);
 };
 
 // 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_