Watchdog - Added a JOINABLE state to avoid StartupTimebomb

base/threading/watchdog.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
 #include "base/threading/watchdog.h"
 
 #include "base/compiler_specific.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/threading/platform_thread.h"
 
@@ skipping 17 matching lines @@
 
 // How long did we sit on a break in the debugger?
 TimeDelta g_last_debugged_alarm_delay;
 
 }  // namespace
 
 // Start thread running in a Disarmed state.
 Watchdog::Watchdog(const TimeDelta& duration,
                    const std::string& thread_watched_name,
                    bool enabled)
-  : init_successful_(false),
+  : enabled_(enabled),
     lock_(),
     condition_variable_(&lock_),
     state_(DISARMED),
     duration_(duration),
     thread_watched_name_(thread_watched_name),
     ALLOW_THIS_IN_INITIALIZER_LIST(delegate_(this)) {
-  if (!enabled)
+  if (!enabled_)
     return;  // Don't start thread, or doing anything really.
-  init_successful_ = PlatformThread::Create(0,  // Default stack size.
-                                            &delegate_,
-                                            &handle_);
-  DCHECK(init_successful_);
+  enabled_ = PlatformThread::Create(0,  // Default stack size.
+                                    &delegate_,
+                                    &handle_);
+  DCHECK(enabled_);
 }
 
 // Notify watchdog thread, and wait for it to finish up.
 Watchdog::~Watchdog() {
-  if (!init_successful_)
+  if (!enabled_)
+    return;
+  if (!IsJoinable())
+    Cleanup();
+  condition_variable_.Signal();
+  PlatformThread::Join(handle_);
+}
+
+void Watchdog::Cleanup() {
+  if (!enabled_)
     return;
   {
     AutoLock lock(lock_);
     state_ = SHUTDOWN;
   }
   condition_variable_.Signal();
-  PlatformThread::Join(handle_);
+}
+
+bool Watchdog::IsJoinable() {
+  if (!enabled_)
+    return true;
+  AutoLock lock(lock_);
+  return (state_ == JOINABLE);
 }
 
 void Watchdog::Arm() {
   ArmAtStartTime(TimeTicks::Now());
 }
 
 void Watchdog::ArmSomeTimeDeltaAgo(const TimeDelta& time_delta) {
   ArmAtStartTime(TimeTicks::Now() - time_delta);
 }
 
@@ skipping 24 matching lines @@
 //------------------------------------------------------------------------------
 // Internal private methods that the watchdog thread uses.
 
 void Watchdog::ThreadDelegate::ThreadMain() {
   SetThreadName();
   TimeDelta remaining_duration;
   while (1) {
     AutoLock lock(watchdog_->lock_);
     while (DISARMED == watchdog_->state_)
       watchdog_->condition_variable_.Wait();
-    if (SHUTDOWN == watchdog_->state_)
+    if (SHUTDOWN == watchdog_->state_) {
+      watchdog_->state_ = JOINABLE;
       return;
+    }
     DCHECK(ARMED == watchdog_->state_);
     remaining_duration = watchdog_->duration_ -
         (TimeTicks::Now() - watchdog_->start_time_);
     if (remaining_duration.InMilliseconds() > 0) {
       // Spurios wake?  Timer drifts?  Go back to sleep for remaining time.
       watchdog_->condition_variable_.TimedWait(remaining_duration);
       continue;
     }
     // We overslept, so this seems like a real alarm.
     // Watch out for a user that stopped the debugger on a different alarm!
@@ skipping 33 matching lines @@
 }
 
 // static
 void Watchdog::ResetStaticData() {
   AutoLock lock(*g_static_lock.Pointer());
   g_last_debugged_alarm_time = TimeTicks();
   g_last_debugged_alarm_delay = TimeDelta();
 }
 
 }  // namespace base