Fix memory leak in ThreadWatcher.

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 120 matching lines @@
 
   // Returns true if we are montioring the thread.
   bool active() const { return active_; }
 
   // Returns |ping_time_| (used by unit tests).
   base::TimeTicks ping_time() const { return ping_time_; }
 
   // Returns |ping_sequence_number_| (used by unit tests).
   uint64_t ping_sequence_number() const { return ping_sequence_number_; }
 
+  virtual ~ThreadWatcher();

[Ilya Sherman, 2016/08/31 03:54:42]

nit: Please move this to the top of the class definition:
https://google.github.io/styleguide/cppguide.html#Declaration_Order

[Joshua LeVasseur, 2016/08/31 19:06:50]

Done.

+
  protected:
   // Construct a ThreadWatcher for the given |thread_id|. |sleep_time| is the
   // wait time between ping messages. |unresponsive_time| is the wait time after
   // ping message is sent, to check if we have received pong message or not.
   explicit ThreadWatcher(const WatchingParams& params);
 
-  virtual ~ThreadWatcher();
-
   // This method activates the thread watching which starts ping/pong messaging.
   virtual void ActivateThreadWatching();
 
   // This method de-activates the thread watching and revokes all tasks.
   virtual void DeActivateThreadWatching();
 
   // 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
   // |unresponsive_threshold_|.
@@ skipping 228 matching lines @@
   // This method is accessible on UI thread.
   static void StartWatchingAll(const base::CommandLine& command_line);
 
   // 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();
 
   // Register() stores a pointer to the given ThreadWatcher in a global map.
-  static void Register(ThreadWatcher* watcher);
-
-  // This method returns true if the ThreadWatcher object is registerd.
-  static bool IsRegistered(const content::BrowserThread::ID thread_id);
+  // It takes ownership of the ThreadWatcher.  Returns true if it was

[Ilya Sherman, 2016/08/31 03:54:42]

nit: No need to document the ownership transfer -- that's clear just from the
use of unique_ptr.

[Joshua LeVasseur, 2016/08/31 19:06:50]

Done.

+  // successfully registered.
+  static bool Register(std::unique_ptr<ThreadWatcher> watcher);
 
   // This method returns number of responsive and unresponsive watched threads.
   static void GetStatusOfThreads(uint32_t* responding_thread_count,
                                  uint32_t* 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:
@@ skipping 276 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_