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

chrome/browser/metrics/thread_watcher_unittest.cc

 // 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.
 
+#include <math.h>
+
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
+#include "base/string_tokenizer.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/platform_thread.h"
 #include "base/time.h"
 #include "build/build_config.h"
 #include "chrome/browser/metrics/thread_watcher.h"
+#include "chrome/common/chrome_switches.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 enum State {
   INITIALIZED,        // Created ThreadWatch object.
   ACTIVATED,          // Thread watching activated.
   SENT_PING,          // Sent ping message to watched thread.
@@ skipping 31 matching lines @@
   uint64 pong_received_;
   uint64 success_response_;
   uint64 failed_response_;
   base::TimeTicks saved_ping_time_;
   uint64 saved_ping_sequence_number_;
 
   CustomThreadWatcher(const BrowserThread::ID thread_id,
                       const std::string thread_name,
                       const TimeDelta& sleep_time,
                       const TimeDelta& unresponsive_time)
-      : ThreadWatcher(thread_id, thread_name, sleep_time, unresponsive_time),
+      : ThreadWatcher(thread_id, thread_name, sleep_time, unresponsive_time,
+                      ThreadWatcherList::kUnresponsiveCount, true,
+                      ThreadWatcherList::kLiveThreadsThreshold),
         state_changed_(&custom_lock_),
         thread_watcher_state_(INITIALIZED),
         wait_state_(UNINITIALIZED),
         check_response_state_(UNKNOWN),
         ping_sent_(0),
         pong_received_(0),
         success_response_(0),
         failed_response_(0),
         saved_ping_time_(base::TimeTicks::Now()),
         saved_ping_sequence_number_(0) {
@@ skipping 148 matching lines @@
 DISABLE_RUNNABLE_METHOD_REFCOUNT(CustomThreadWatcher);
 
 class ThreadWatcherTest : public ::testing::Test {
  public:
   static const TimeDelta kSleepTime;
   static const TimeDelta kUnresponsiveTime;
   static const BrowserThread::ID io_thread_id;
   static const std::string io_thread_name;
   static const BrowserThread::ID webkit_thread_id;
   static const std::string webkit_thread_name;
+  static const std::string crash_on_hang_seconds;
+  static const std::string crash_on_hang_threads;
+  static const std::string crash_on_live;
   CustomThreadWatcher* io_watcher_;
   CustomThreadWatcher* webkit_watcher_;
+  ThreadWatcherList* thread_watcher_list_;
 
-  ThreadWatcherTest() {
+  ThreadWatcherTest()
+      : setup_complete_(&lock_),
+        initialized_(false) {
     webkit_thread_.reset(new BrowserThread(BrowserThread::WEBKIT));
     io_thread_.reset(new BrowserThread(BrowserThread::IO));
     watchdog_thread_.reset(new WatchDogThread());
     webkit_thread_->Start();
     io_thread_->Start();
     watchdog_thread_->Start();
 
+    WatchDogThread::PostTask(
+        FROM_HERE,
+        NewRunnableMethod(this, &ThreadWatcherTest::SetUpObjects));
+
+    WaitForSetUp(TimeDelta::FromMinutes(1));
+  }
+
+  void SetUpObjects() {
+    DCHECK(WatchDogThread::CurrentlyOnWatchDogThread());
+
     // Setup the registry for thread watchers.
     thread_watcher_list_ = new ThreadWatcherList();
 
     // Create thread watcher object for the IO thread.
     io_watcher_ = new CustomThreadWatcher(io_thread_id, io_thread_name,
                                           kSleepTime, kUnresponsiveTime);
+    EXPECT_EQ(io_watcher_, thread_watcher_list_->Find(io_thread_id));
 
     // Create thread watcher object for the WEBKIT thread.
     webkit_watcher_ = new CustomThreadWatcher(
         webkit_thread_id, webkit_thread_name, kSleepTime, kUnresponsiveTime);
+    EXPECT_EQ(webkit_watcher_, thread_watcher_list_->Find(webkit_thread_id));
+
+    {
+      base::AutoLock lock(lock_);
+      initialized_ = true;
+    }
+    setup_complete_.Signal();
+  }
+
+  void WaitForSetUp(TimeDelta wait_time) {
+    DCHECK(!WatchDogThread::CurrentlyOnWatchDogThread());
+    TimeTicks end_time = TimeTicks::Now() + wait_time;
+    {
+      base::AutoLock auto_lock(lock_);
+      while (!initialized_ && TimeTicks::Now() < end_time)
+        setup_complete_.TimedWait(end_time - TimeTicks::Now());
+    }
   }
 
   ~ThreadWatcherTest() {
-    ThreadWatcherList::StopWatchingAll();
+    ThreadWatcherList::DeleteAll();
     io_watcher_ = NULL;
     webkit_watcher_ = NULL;
     io_thread_.reset();
     webkit_thread_.reset();
     watchdog_thread_.reset();
-    delete thread_watcher_list_;
+    thread_watcher_list_ = NULL;
   }
 
  private:
+  base::Lock lock_;
+  base::ConditionVariable setup_complete_;
+  bool initialized_;
   scoped_ptr<BrowserThread> webkit_thread_;
   scoped_ptr<BrowserThread> io_thread_;
   scoped_ptr<WatchDogThread> watchdog_thread_;
-  ThreadWatcherList* thread_watcher_list_;
 };
 
+// DISABLE_RUNNABLE_METHOD_REFCOUNT is a convenience macro for disabling
+// refcounting of ThreadWatcherTest classes.
+DISABLE_RUNNABLE_METHOD_REFCOUNT(ThreadWatcherTest);
+
 // Define static constants.
 const TimeDelta ThreadWatcherTest::kSleepTime =
     TimeDelta::FromMilliseconds(50);
 const TimeDelta ThreadWatcherTest::kUnresponsiveTime =
     TimeDelta::FromMilliseconds(500);
 const BrowserThread::ID ThreadWatcherTest::io_thread_id = BrowserThread::IO;
 const std::string ThreadWatcherTest::io_thread_name = "IO";
 const BrowserThread::ID ThreadWatcherTest::webkit_thread_id =
     BrowserThread::WEBKIT;
 const std::string ThreadWatcherTest::webkit_thread_name = "WEBKIT";
+const std::string ThreadWatcherTest::crash_on_hang_seconds = "24";
+const std::string ThreadWatcherTest::crash_on_hang_threads = "IO,UI";
+const std::string ThreadWatcherTest::crash_on_live = "3";
+
+TEST_F(ThreadWatcherTest, CommandLineArgs) {
+  // Setup command_line arguments.
+  CommandLine command_line(CommandLine::NO_PROGRAM);
+  command_line.AppendSwitchASCII(switches::kCrashOnHangSeconds,
+                                 crash_on_hang_seconds);
+  command_line.AppendSwitchASCII(switches::kCrashOnHangThreads,
+                                 crash_on_hang_threads);
+  command_line.AppendSwitchASCII(switches::kCrashOnLive,
+                                 crash_on_live);
+
+  // Parse command_line arguments.
+  uint32 unresponsive_threshold;
+  std::set<std::string> crash_on_hang_thread_names;
+  uint32 live_threads_threshold;
+  ThreadWatcherList::ParseCommandLine(command_line,
+                                      &unresponsive_threshold,
+                                      &crash_on_hang_thread_names,
+                                      &live_threads_threshold);
+
+  // Verify the data.
+  uint32 crash_on_unresponsive_seconds =
+      ThreadWatcherList::kUnresponsiveSeconds * unresponsive_threshold;
+  EXPECT_EQ(static_cast<int>(crash_on_unresponsive_seconds),
+            atoi(crash_on_hang_seconds.c_str()));
+
+  // Check ThreadWatcherTestList has the right crash_on_hang_threads.
+  StringTokenizer tokens(crash_on_hang_threads, ",");
+  while (tokens.GetNext()) {
+    std::string thread_name = tokens.token();
+    std::set<std::string>::iterator it =
+        crash_on_hang_thread_names.find(thread_name);
+    bool crash_on_hang = (it != crash_on_hang_thread_names.end());
+    EXPECT_TRUE(crash_on_hang);
+  }
+
+  EXPECT_EQ(static_cast<int>(live_threads_threshold),
+            atoi(crash_on_live.c_str()));
+}
 
 // Test registration. When thread_watcher_list_ goes out of scope after
 // TearDown, all thread watcher objects will be deleted.
 TEST_F(ThreadWatcherTest, Registration) {
-  EXPECT_EQ(io_watcher_, ThreadWatcherList::Find(io_thread_id));
-  EXPECT_EQ(webkit_watcher_, ThreadWatcherList::Find(webkit_thread_id));
-
   // Check ThreadWatcher object has all correct parameters.
   EXPECT_EQ(io_thread_id, io_watcher_->thread_id());
   EXPECT_EQ(io_thread_name, io_watcher_->thread_name());
   EXPECT_EQ(kSleepTime, io_watcher_->sleep_time());
   EXPECT_EQ(kUnresponsiveTime, io_watcher_->unresponsive_time());
   EXPECT_FALSE(io_watcher_->active());
 
   // Check ThreadWatcher object of watched WEBKIT thread has correct data.
   EXPECT_EQ(webkit_thread_id, webkit_watcher_->thread_id());
   EXPECT_EQ(webkit_thread_name, webkit_watcher_->thread_name());
@@ skipping 153 matching lines @@
       FROM_HERE,
       NewRunnableMethod(io_watcher_, &ThreadWatcher::DeActivateThreadWatching));
   WatchDogThread::PostTask(
       FROM_HERE,
       NewRunnableMethod(
           webkit_watcher_, &ThreadWatcher::DeActivateThreadWatching));
 
   // Wait for the io_watcher_'s VeryLongMethod to finish.
   io_watcher_->WaitForWaitStateChange(kUnresponsiveTime * 10, ALL_DONE);
 }