ThreadWatcher: fixes Start/StopWatchingAll.

chrome/browser/metrics/thread_watcher.cc

 // Copyright (c) 2012 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 "chrome/browser/metrics/thread_watcher.h"
 
 #include <math.h>  // ceil
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 391 matching lines @@
 bool ThreadWatcher::IsVeryUnresponsive() {
   DCHECK(WatchDogThread::CurrentlyOnWatchDogThread());
   return unresponsive_count_ >= unresponsive_threshold_;
 }
 
 // ThreadWatcherList methods and members.
 //
 // static
 ThreadWatcherList* ThreadWatcherList::g_thread_watcher_list_ = NULL;
 // static
+bool ThreadWatcherList::g_stopped_ = false;
+// static
 const int ThreadWatcherList::kSleepSeconds = 1;
 // static
 const int ThreadWatcherList::kUnresponsiveSeconds = 2;
 // static
 const int ThreadWatcherList::kUnresponsiveCount = 9;
 // static
 const int ThreadWatcherList::kLiveThreadsThreshold = 2;
 // static, non-const for tests.
 int ThreadWatcherList::g_initialize_delay_seconds = 120;
 
@@ skipping 14 matching lines @@
   // TODO(rtenneti): Enable ThreadWatcher.
   uint32 unresponsive_threshold;
   CrashOnHangThreadMap crash_on_hang_threads;
   ParseCommandLine(command_line,
                    &unresponsive_threshold,
                    &crash_on_hang_threads);
 
   ThreadWatcherObserver::SetupNotifications(
       base::TimeDelta::FromSeconds(kSleepSeconds * unresponsive_threshold));
 
+  WatchDogThread::PostTask(
+      FROM_HERE,
+      base::Bind(&ThreadWatcherList::SetStopped, false));
+
   WatchDogThread::PostDelayedTask(
       FROM_HERE,
       base::Bind(&ThreadWatcherList::InitializeAndStartWatching,
                  unresponsive_threshold,
                  crash_on_hang_threads),
       base::TimeDelta::FromSeconds(g_initialize_delay_seconds));
 }
 
 // static
 void ThreadWatcherList::StopWatchingAll() {
@@ skipping 172 matching lines @@
     (*crash_on_hang_threads)[thread_name] = crash_data;
   }
 }
 
 // static
 void ThreadWatcherList::InitializeAndStartWatching(
     uint32 unresponsive_threshold,
     const CrashOnHangThreadMap& crash_on_hang_threads) {
   DCHECK(WatchDogThread::CurrentlyOnWatchDogThread());
 
+  // This method is deferred in relationship to its StopWatchingAll()
+  // counterpart. If a previous initialization has already happened, or if
+  // stop has been called, there's nothing left to do here.
+  if (g_thread_watcher_list_ || g_stopped_)
+    return;
+
   ThreadWatcherList* thread_watcher_list = new ThreadWatcherList();
   CHECK(thread_watcher_list);
 
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&StartupTimeBomb::DisarmStartupTimeBomb));
 
   const base::TimeDelta kSleepTime =
       base::TimeDelta::FromSeconds(kSleepSeconds);
@@ skipping 45 matching lines @@
 // static
 void ThreadWatcherList::DeleteAll() {
   if (!WatchDogThread::CurrentlyOnWatchDogThread()) {
     WatchDogThread::PostTask(
         FROM_HERE,
         base::Bind(&ThreadWatcherList::DeleteAll));
     return;
   }
 
   DCHECK(WatchDogThread::CurrentlyOnWatchDogThread());
+
+  SetStopped(true);
+
   if (!g_thread_watcher_list_)
     return;
 
   // Delete all thread watcher objects.
   while (!g_thread_watcher_list_->registered_.empty()) {
     RegistrationList::iterator it = g_thread_watcher_list_->registered_.begin();
     delete it->second;
     g_thread_watcher_list_->registered_.erase(it);
   }
 
   delete g_thread_watcher_list_;
 }
 
 // static
 ThreadWatcher* ThreadWatcherList::Find(const BrowserThread::ID& thread_id) {
   DCHECK(WatchDogThread::CurrentlyOnWatchDogThread());
   if (!g_thread_watcher_list_)
     return NULL;
   RegistrationList::iterator it =
       g_thread_watcher_list_->registered_.find(thread_id);
   if (g_thread_watcher_list_->registered_.end() == it)
     return NULL;
   return it->second;
 }
 
+// static
+void ThreadWatcherList::SetStopped(bool stopped) {
+  DCHECK(WatchDogThread::CurrentlyOnWatchDogThread());
+  g_stopped_ = stopped;
+}
+
 // ThreadWatcherObserver methods and members.
 //
 // static
 ThreadWatcherObserver* ThreadWatcherObserver::g_thread_watcher_observer_ = NULL;
 
 ThreadWatcherObserver::ThreadWatcherObserver(
     const base::TimeDelta& wakeup_interval)
     : last_wakeup_time_(base::TimeTicks::Now()),
       wakeup_interval_(wakeup_interval) {
   CHECK(!g_thread_watcher_observer_);
@@ skipping 247 matching lines @@
 
 #if defined(OS_WIN)
   // On Windows XP, give twice the time for shutdown.
   if (base::win::GetVersion() <= base::win::VERSION_XP)
     actual_duration *= 2;
 #endif
 
   shutdown_watchdog_ = new ShutdownWatchDogThread(actual_duration);
   shutdown_watchdog_->Arm();
 }