Disarm StartupTimeBomb when it is deleted

chrome/browser/metrics/thread_watcher.cc

 // 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.
 
 #include "chrome/browser/metrics/thread_watcher.h"
 
 #include <math.h>  // ceil
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 572 matching lines @@
   StartWatching(BrowserThread::FILE, "FILE", kSleepTime, kUnresponsiveTime,
                 unresponsive_threshold, crash_on_hang_thread_names,
                 live_threads_threshold);
   StartWatching(BrowserThread::CACHE, "CACHE", kSleepTime, kUnresponsiveTime,
                 unresponsive_threshold, crash_on_hang_thread_names,
                 live_threads_threshold);
 
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
-      base::Bind(StartupTimeBomb::Disarm));
+      base::Bind(&StartupTimeBomb::DisarmStartupTimeBomb));
 }
 
 // static
 void ThreadWatcherList::StartWatching(
     const BrowserThread::ID& thread_id,
     const std::string& thread_name,
     const base::TimeDelta& sleep_time,
     const base::TimeDelta& unresponsive_time,
     uint32 unresponsive_threshold,
     const std::set<std::string>& crash_on_hang_thread_names,
@@ skipping 217 matching lines @@
     CHECK(false);
   }
 
   DISALLOW_COPY_AND_ASSIGN(ShutdownWatchDogThread);
 };
 }  // namespace
 
 // StartupTimeBomb methods and members.
 //
 // static
-base::Watchdog* StartupTimeBomb::startup_watchdog_ = NULL;
+StartupTimeBomb* StartupTimeBomb::g_startup_timebomb_ = NULL;
 
-// static
+StartupTimeBomb::StartupTimeBomb()
+    : startup_watchdog_(NULL),
+      thread_id_(base::PlatformThread::CurrentId()) {
+  CHECK(!g_startup_timebomb_);
+  g_startup_timebomb_ = this;
+}
+
+StartupTimeBomb::~StartupTimeBomb() {
+  DCHECK(this == g_startup_timebomb_);
+  DCHECK_EQ(thread_id_, base::PlatformThread::CurrentId());
+  if (startup_watchdog_)
+    Disarm();
+  g_startup_timebomb_ = NULL;
+}
+
 void StartupTimeBomb::Arm(const base::TimeDelta& duration) {
+  DCHECK_EQ(thread_id_, base::PlatformThread::CurrentId());
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!startup_watchdog_);
   startup_watchdog_ = new StartupWatchDogThread(duration);
   startup_watchdog_->Arm();
 }
 
-// static
 void StartupTimeBomb::Disarm() {
+  DCHECK_EQ(thread_id_, base::PlatformThread::CurrentId());
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (startup_watchdog_) {
     startup_watchdog_->Disarm();
     // Allow the watchdog thread to shutdown on UI. Watchdog thread shutdowns
     // very fast.
     base::ThreadRestrictions::SetIOAllowed(true);
     delete startup_watchdog_;
     startup_watchdog_ = NULL;
   }
 }
 
+// static
+void StartupTimeBomb::DisarmStartupTimeBomb() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (g_startup_timebomb_)
+    g_startup_timebomb_->Disarm();
+}
+
 // ShutdownWatcherHelper methods and members.
 //
 // ShutdownWatcherHelper is a wrapper class for detecting hangs during
 // shutdown.
-ShutdownWatcherHelper::ShutdownWatcherHelper() : shutdown_watchdog_(NULL) {
+ShutdownWatcherHelper::ShutdownWatcherHelper()
+    : shutdown_watchdog_(NULL),
+      thread_id_(base::PlatformThread::CurrentId()) {
 }
 
 ShutdownWatcherHelper::~ShutdownWatcherHelper() {
+  DCHECK_EQ(thread_id_, base::PlatformThread::CurrentId());
   if (shutdown_watchdog_) {
     shutdown_watchdog_->Disarm();
     delete shutdown_watchdog_;
     shutdown_watchdog_ = NULL;
   }
 }
 
 void ShutdownWatcherHelper::Arm(const base::TimeDelta& duration) {
+  DCHECK_EQ(thread_id_, base::PlatformThread::CurrentId());
   DCHECK(!shutdown_watchdog_);
   base::TimeDelta actual_duration = duration;
 
   chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
   if (channel == chrome::VersionInfo::CHANNEL_STABLE) {
     actual_duration *= 50;
   } else if (channel == chrome::VersionInfo::CHANNEL_BETA ||
              channel == chrome::VersionInfo::CHANNEL_DEV) {
     actual_duration *= 25;
   }
 
 #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();
 }