ThreadWatcher: fixes Start/StopWatchingAll.

chrome/browser/metrics/thread_watcher.h

 // 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.
 
 // 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 388 matching lines @@
   static void GetStatusOfThreads(uint32* responding_thread_count,
                                  uint32* unresponding_thread_count);
 
   // This will ensure that the watching is actively taking place, and awaken
   // all thread watchers that are registered.
   static void WakeUpAll();
 
  private:
   // Allow tests to access our innards for testing purposes.
   friend class CustomThreadWatcher;
+  friend class ThreadWatcherListTest;
   friend class ThreadWatcherTest;
+  FRIEND_TEST_ALL_PREFIXES(ThreadWatcherAndroidTest,
+                           ApplicationStatusNotification);
+  FRIEND_TEST_ALL_PREFIXES(ThreadWatcherListTest, Restart);
   FRIEND_TEST_ALL_PREFIXES(ThreadWatcherTest, ThreadNamesOnlyArgs);
   FRIEND_TEST_ALL_PREFIXES(ThreadWatcherTest, ThreadNamesAndLiveThresholdArgs);
   FRIEND_TEST_ALL_PREFIXES(ThreadWatcherTest, CrashOnHangThreadsAllArgs);
-  FRIEND_TEST_ALL_PREFIXES(ThreadWatcherAndroidTest,
-                           ApplicationStatusNotification);
 
   // This singleton holds the global list of registered ThreadWatchers.
   ThreadWatcherList();
 
   // Destructor deletes all registered ThreadWatcher instances.
   virtual ~ThreadWatcherList();
 
   // Parses the command line to get |crash_on_hang_threads| map from
   // switches::kCrashOnHangThreads. |crash_on_hang_threads| is a map of
   // |crash_on_hang| thread's names to |CrashDataThresholds|.
@@ skipping 32 matching lines @@
       const CrashOnHangThreadMap& crash_on_hang_threads);
 
   // Delete all thread watcher objects and remove them from global map. It also
   // deletes |g_thread_watcher_list_|.
   static void DeleteAll();
 
   // The Find() method can be used to test to see if a given ThreadWatcher was
   // already registered, or to retrieve a pointer to it from the global map.
   static ThreadWatcher* Find(const content::BrowserThread::ID& thread_id);
 
+  // Sets |g_stopped_| on the WatchDogThread. This is necessary to reflect the
+  // state between the delayed |StartWatchingAll| and the immediate
+  // |StopWatchingAll|.
+  static void SetStopped(bool stopped);
+
   // The singleton of this class and is used to keep track of information about
   // threads that are being watched.
   static ThreadWatcherList* g_thread_watcher_list_;
 
+  // StartWatchingAll() is delayed in relation to StopWatchingAll(), so if
+  // a Stop comes first, prevent further initialization.
+  static bool g_stopped_;
+
   // 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;
 
   // Default values for |unresponsive_threshold|.
   static const int kUnresponsiveCount;
 
@@ skipping 149 matching lines @@
   // shutdown_watchdog_ watches for hangs during shutdown.
   base::Watchdog* shutdown_watchdog_;
 
   // The |thread_id_| on which this object is constructed.
   const base::PlatformThreadId thread_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ShutdownWatcherHelper);
 };
 
 #endif  // CHROME_BROWSER_METRICS_THREAD_WATCHER_H_