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 "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, false),
         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;
+
   CustomThreadWatcher* io_watcher_;
   CustomThreadWatcher* webkit_watcher_;
+  ThreadWatcherList* thread_watcher_list_;
 
   ThreadWatcherTest() {
     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();
 
+    CommandLine command_line(CommandLine::NO_PROGRAM);
+    command_line.AppendSwitchASCII(switches::kCrashOnHangSeconds,
+                                   crash_on_hang_seconds);
+    command_line.AppendSwitchASCII(switches::kCrashOnHangThreads,
+                                   crash_on_hang_threads);
+
     // Setup the registry for thread watchers.
-    thread_watcher_list_ = new ThreadWatcherList();
+    thread_watcher_list_ = new ThreadWatcherList(command_line);
 
     // Create thread watcher object for the IO thread.
     io_watcher_ = new CustomThreadWatcher(io_thread_id, io_thread_name,
                                           kSleepTime, kUnresponsiveTime);
 
     // Create thread watcher object for the WEBKIT thread.
     webkit_watcher_ = new CustomThreadWatcher(
         webkit_thread_id, webkit_thread_name, kSleepTime, kUnresponsiveTime);
   }
 
   ~ThreadWatcherTest() {
     ThreadWatcherList::StopWatchingAll();
     io_watcher_ = NULL;
     webkit_watcher_ = NULL;
     io_thread_.reset();
     webkit_thread_.reset();
     watchdog_thread_.reset();
     delete thread_watcher_list_;
   }
 
  private:
   scoped_ptr<BrowserThread> webkit_thread_;
   scoped_ptr<BrowserThread> io_thread_;
   scoped_ptr<WatchDogThread> watchdog_thread_;
-  ThreadWatcherList* thread_watcher_list_;
 };
 
 // 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";
+
+TEST_F(ThreadWatcherTest, CommandLineArgs) {
+  // Check ThreadWatcherTestList has the right crash_on_hang_seconds.
+  uint32 crash_on_unresponsive_count =
+      thread_watcher_list_->CrashOnUnresponsiveCount();
+  uint32 crash_on_unresponsive_seconds =
+      ThreadWatcherList::kUnresponsiveSeconds * crash_on_unresponsive_count;
+  int crash_seconds = atoi(crash_on_hang_seconds.c_str());
+  EXPECT_EQ(crash_on_unresponsive_seconds, static_cast<uint32>(crash_seconds));
+
+  // Check ThreadWatcherTestList has the right crash_on_hang_threads.
+  StringTokenizer t(crash_on_hang_threads, ",");
+  while (t.GetNext())
+    EXPECT_TRUE(thread_watcher_list_->CrashOnHang(t.token()));
+}
 
 // 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());
@@ skipping 160 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);
 }