Trying changes to see the perfomance impact on Mac....

chrome/browser/metrics/thread_watcher.h

 // 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.
 
 //------------------------------------------------------------------------------
 
 #ifndef CHROME_BROWSER_METRICS_THREAD_WATCHER_H_
 #define CHROME_BROWSER_METRICS_THREAD_WATCHER_H_
 #pragma once
 
-#if 0
-
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
+#include "base/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/task.h"
 #include "base/threading/thread.h"
 #include "base/time.h"
-#include "chrome/browser/browser_process_sub_thread.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/common/notification_observer.h"
 #include "chrome/common/notification_registrar.h"
 
 class CustomThreadWatcher;
 class ThreadWatcherList;
 
 //------------------------------------------------------------------------------
 // This class performs health check on threads that would like to be watched. It
 // sends ping message to the watched thread and the watched thread responds back
@@ skipping 63 matching lines @@
   // This will ensure that the watching is actively taking place, and awaken
   // (i.e., post a PostPingMessage) if the watcher has stopped pinging due to
   // lack of user activity. It will also reset ping_count_ to kPingCount.
   virtual void WakeUp();
 
   // This method records when ping message was sent and it will Post a task
   // (OnPingMessage) to the watched thread that does nothing but respond with
   // OnPongMessage. It also posts a task (OnCheckResponsiveness) to check
   // responsiveness of monitored thread that would be called after waiting
   // unresponsive_time_.
-  // This method is accessible on WATCHDOG thread.
+  // This method is accessible on WatchDogThread.
   virtual void PostPingMessage();
 
   // This method handles a Pong Message from watched thread. It will track the
   // response time (pong time minus ping time) via histograms. It posts a
   // PostPingMessage task that would be called after waiting sleep_time_.  It
   // increments ping_sequence_number_ by 1.
-  // This method is accessible on WATCHDOG thread.
+  // This method is accessible on WatchDogThread.
   virtual void OnPongMessage(uint64 ping_sequence_number);
 
   // This method will determine if the watched thread is responsive or not. If
   // the latest ping_sequence_number_ is not same as the ping_sequence_number
   // that is passed in, then we can assume that watched thread has responded
   // with a pong message.
-  // This method is accessible on WATCHDOG thread.
+  // This method is accessible on WatchDogThread.
   virtual bool OnCheckResponsiveness(uint64 ping_sequence_number);
 
  private:
   friend class ThreadWatcherList;
 
   // Allow tests to access our innards for testing purposes.
   FRIEND_TEST(ThreadWatcherTest, Registration);
   FRIEND_TEST(ThreadWatcherTest, ThreadResponding);
   FRIEND_TEST(ThreadWatcherTest, ThreadNotResponding);
   FRIEND_TEST(ThreadWatcherTest, MultipleThreadsResponding);
@@ skipping 61 matching lines @@
   typedef std::map<BrowserThread::ID, ThreadWatcher*> RegistrationList;
 
   // This singleton holds the global list of registered ThreadWatchers.
   ThreadWatcherList();
   // Destructor deletes all registered ThreadWatcher instances.
   ~ThreadWatcherList();
 
   // Register() stores a pointer to the given ThreadWatcher in a global map.
   static void Register(ThreadWatcher* watcher);
 
-  // This method posts a task on WATCHDOG thread to RevokeAll tasks and to
+  // This method posts a task on WatchDogThread to RevokeAll tasks and to
   // deactive thread watching of other threads and tell NotificationService to
   // stop calling Observe.
+  // This method is accessible on UI thread.
   static void StopWatchingAll();
 
   // RemoveAll NotificationTypes that are being observed.
+  // This method is accessible on UI thread.
   static void RemoveNotifications();
 
  private:
   // Allow tests to access our innards for testing purposes.
   FRIEND_TEST(ThreadWatcherTest, Registration);
 
+  // Delete all thread watcher objects and remove them from global map.
+  // This method is accessible on WatchDogThread.
+  void DeleteAll();
+
   // This will ensure that the watching is actively taking place. It will wakeup
   // all thread watchers every 2 seconds. This is the implementation of
   // NotificationObserver. When a matching notification is posted to the
   // notification service, this method is called.
+  // This method is accessible on UI thread.
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
   // This will ensure that the watching is actively taking place, and awaken
   // all thread watchers that are registered.
+  // This method is accessible on WatchDogThread.
   virtual void WakeUpAll();
 
   // 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 BrowserThread::ID thread_id);
 
   // Helper function should be called only while holding lock_.
   ThreadWatcher* PreLockedFind(const BrowserThread::ID thread_id);
 
   static ThreadWatcherList* global_;  // The singleton of this class.
 
   // Lock for access to registered_.
   base::Lock lock_;
   RegistrationList registered_;
 
   // The registrar that holds NotificationTypes to be observed.
   NotificationRegistrar registrar_;
 
   // This is the last time when woke all thread watchers up.
   base::TimeTicks last_wakeup_time_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadWatcherList);
 };
 
 //------------------------------------------------------------------------------
-// Class for WATCHDOG thread and in its Init method, we start watching UI, IO,
+// Class for WatchDogThread and in its Init method, we start watching UI, IO,
 // DB, FILE, CACHED threads.
-class WatchDogThread : public BrowserProcessSubThread {
+class WatchDogThread : public base::Thread {
  public:
+  // Constructor.
   WatchDogThread();
+
+  // Destroys the thread and stops the thread.
   virtual ~WatchDogThread();
 
+  // Start watching all browser threads.
+  static void StartWatchingAll();
+
+  // Returns current message loop for the watchdog thread. This only returns
+  // non-null after a successful call to Start.  After Stop has been called,
+  // this will return NULL.
+  static MessageLoop* CurrentMessageLoop();
+
+  // Callable on any thread.  Returns whether you're currently on a
+  // watchdog_thread_.
+  static bool CurrentlyOnWatchDogThread();
+
  protected:
   virtual void Init();
+  virtual void CleanUp();
+  virtual void CleanUpAfterMessageLoopDestruction();
+
+  // This lock protects watchdog_thread_.
+  static base::Lock lock_;
+  static WatchDogThread* watchdog_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(WatchDogThread);
 };
 
-
 DISABLE_RUNNABLE_METHOD_REFCOUNT(ThreadWatcher);
 DISABLE_RUNNABLE_METHOD_REFCOUNT(ThreadWatcherList);
 
-#endif  // 0
-
 #endif  // CHROME_BROWSER_METRICS_THREAD_WATCHER_H_