[Merge to 55.0.2846.2] Revert of Fix memory leak in ThreadWatcher. (patchset #3 id:40001 of https:/…

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 84 matching lines @@
                    uint32_t live_threads_threshold_in)
         : thread_id(thread_id_in),
           thread_name(thread_name_in),
           sleep_time(sleep_time_in),
           unresponsive_time(unresponsive_time_in),
           unresponsive_threshold(unresponsive_threshold_in),
           crash_on_hang(crash_on_hang_in),
           live_threads_threshold(live_threads_threshold_in) {}
   };
 
-  virtual ~ThreadWatcher();
-
   // This method starts performing health check on the given |thread_id|. It
   // will create ThreadWatcher object for the given |thread_id|, |thread_name|.
   // |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. |unresponsive_threshold| is used to determine if the thread
   // is responsive or not. The watched thread is considered unresponsive if it
   // hasn't responded with a pong message for |unresponsive_threshold| number of
   // ping messages. |crash_on_hang| specifies if browser should be crashed when
   // the watched thread is unresponsive. |live_threads_threshold| specifies the
   // number of browser threads that are to be responsive when we want to crash
@@ skipping 22 matching lines @@
 
   // Returns |ping_sequence_number_| (used by unit tests).
   uint64_t ping_sequence_number() const { return ping_sequence_number_; }
 
  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.
-  // Returns true if it was successfully registered.
-  static bool Register(std::unique_ptr<ThreadWatcher> watcher);
+  static void Register(ThreadWatcher* watcher);
+
+  // This method returns true if the ThreadWatcher object is registerd.
+  static bool IsRegistered(const content::BrowserThread::ID thread_id);
 
   // 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 277 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_