Force a crash of the browser if IO thread hasn't responded

chrome/browser/metrics/thread_watcher.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/threading/thread_restrictions.h"
 #include "build/build_config.h"
 #include "chrome/browser/metrics/metrics_service.h"
 #include "chrome/browser/metrics/thread_watcher.h"
 #include "content/common/notification_service.h"
 
@@ skipping 14 matching lines @@
       sleep_time_(sleep_time),
       unresponsive_time_(unresponsive_time),
       ping_time_(base::TimeTicks::Now()),
       pong_time_(ping_time_),
       ping_sequence_number_(0),
       active_(false),
       ping_count_(kPingCount),
       response_time_histogram_(NULL),
       unresponsive_time_histogram_(NULL),
       unresponsive_count_(0),
+      hung_processing_complete_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
   Initialize();
 }
 
 ThreadWatcher::~ThreadWatcher() {}
 
 // static
 void ThreadWatcher::StartWatching(const BrowserThread::ID& thread_id,
                                   const std::string& thread_name,
                                   const base::TimeDelta& sleep_time,
@@ skipping 180 matching lines @@
 void ThreadWatcher::OnPingMessage(const BrowserThread::ID& thread_id,
                                   Task* callback_task) {
   // This method is called on watched thread.
   DCHECK(BrowserThread::CurrentlyOn(thread_id));
   WatchDogThread::PostTask(FROM_HERE, callback_task);
 }
 
 void ThreadWatcher::GotGoodResponse() {
   DCHECK(WatchDogThread::CurrentlyOnWatchDogThread());
   unresponsive_count_ = 0;
+  hung_processing_complete_ = false;
 }
 
 void ThreadWatcher::GotNoResponse() {
   DCHECK(WatchDogThread::CurrentlyOnWatchDogThread());
 
   // Record how other threads are responding when we don't get a response for
   // ping message atleast three times.
   if (++unresponsive_count_ < 3)
     return;
 
   // Record total unresponsive_time since last pong message.
   base::TimeDelta unresponse_time = base::TimeTicks::Now() - pong_time_;
   unresponsive_time_histogram_->AddTime(unresponse_time);
 
+  // We have already collected stats for the non-responding watched thread.
+  if (hung_processing_complete_)
+    return;
+
   int no_of_responding_threads = 0;
   int no_of_unresponding_threads = 0;
   ThreadWatcherList::GetStatusOfThreads(&no_of_responding_threads,
                                         &no_of_unresponding_threads);
 
   // Record how many watched threads are responding.
   responsive_count_histogram_->Add(no_of_responding_threads);
 
   // Record how many watched threads are not responding.
   unresponsive_count_histogram_->Add(no_of_unresponding_threads);
+
+  // Crash the browser if IO thread hasn't responded atleast 3 times and if the
+  // number of other threads is equal to 1. We picked 1 to reduce the number of
+  // crashes and to get some sample data.
+  if (thread_id_ == BrowserThread::IO && no_of_responding_threads == 1) {
+    int* crash = NULL;
+    CHECK(crash++);

[Peter Kasting, 2011/05/17 00:41:05]

Why is this better than simply NOTREACHED();?

+  }
+
+  hung_processing_complete_ = true;
 }
 
 // ThreadWatcherList methods and members.
 //
 // static
 ThreadWatcherList* ThreadWatcherList::global_ = NULL;
 // static
 const int ThreadWatcherList::kSleepSeconds = 2;
 // static
 const int ThreadWatcherList::kUnresponsiveSeconds = 4;
@@ skipping 251 matching lines @@
   watchdog_thread_ = NULL;
 }
 
 void WatchDogThread::CleanUpAfterMessageLoopDestruction() {
 #if defined(OS_WIN)
   // Closes the COM library on the current thread. CoInitialize must
   // be balanced by a corresponding call to CoUninitialize.
   CoUninitialize();
 #endif
 }