Remove 1 exit time destructor and 1 static initializer from watchdog.cc

base/threading/watchdog.cc

 // Copyright (c) 2010 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"
 
 namespace base {
 
+namespace {
+
+// When the debugger breaks (when we alarm), all the other alarms that are
+// armed will expire (also alarm).  To diminish this effect, we track any
+// delay due to debugger breaks, and we *try* to adjust the effective start
+// time of other alarms to step past the debugging break.
+// Without this safety net, any alarm will typically trigger a host of follow
+// on alarms from callers that specify old times.
+
+// Lock for access of static data...
+LazyInstance<Lock, LeakyLazyInstanceTraits<Lock> > g_static_lock(
+    LINKER_INITIALIZED);
+
+// When did we last alarm and get stuck (for a while) in a debugger?
+TimeTicks g_last_debugged_alarm_time;
+
+// 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),
     lock_(),
     condition_variable_(&lock_),
     state_(DISARMED),
     duration_(duration),
     thread_watched_name_(thread_watched_name),
@@ skipping 66 matching lines @@
     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!
     {
-      AutoLock static_lock(static_lock_);
-      if (last_debugged_alarm_time_ > watchdog_->start_time_) {
+      AutoLock static_lock(*g_static_lock.Pointer());
+      if (g_last_debugged_alarm_time > watchdog_->start_time_) {
         // False alarm: we started our clock before the debugger break (last
         // alarm time).
-        watchdog_->start_time_ += last_debugged_alarm_delay_;
-        if (last_debugged_alarm_time_ > watchdog_->start_time_)
+        watchdog_->start_time_ += g_last_debugged_alarm_delay;
+        if (g_last_debugged_alarm_time > watchdog_->start_time_)
           // Too many alarms must have taken place.
           watchdog_->state_ = DISARMED;
         continue;
       }
     }
     watchdog_->state_ = DISARMED;  // Only alarm at most once.
     TimeTicks last_alarm_time = TimeTicks::Now();
     watchdog_->Alarm();  // Set a break point here to debug on alarms.
     TimeDelta last_alarm_delay = TimeTicks::Now() - last_alarm_time;
     if (last_alarm_delay <= TimeDelta::FromMilliseconds(2))
       continue;
     // Ignore race of two alarms/breaks going off at roughly the same time.
-    AutoLock static_lock(static_lock_);
+    AutoLock static_lock(*g_static_lock.Pointer());
     // This was a real debugger break.
-    last_debugged_alarm_time_ = last_alarm_time;
-    last_debugged_alarm_delay_ = last_alarm_delay;
+    g_last_debugged_alarm_time = last_alarm_time;
+    g_last_debugged_alarm_delay = last_alarm_delay;
   }
 }
 
 void Watchdog::ThreadDelegate::SetThreadName() const {
   std::string name = watchdog_->thread_watched_name_ + " Watchdog";
   PlatformThread::SetName(name.c_str());
   DVLOG(1) << "Watchdog active: " << name;
 }
 
 // static
 void Watchdog::ResetStaticData() {
-  AutoLock lock(static_lock_);
-  last_debugged_alarm_time_ = TimeTicks();
-  last_debugged_alarm_delay_ = TimeDelta();
+  AutoLock lock(*g_static_lock.Pointer());
+  g_last_debugged_alarm_time = TimeTicks();
+  g_last_debugged_alarm_delay = TimeDelta();
 }
 
-// static
-Lock Watchdog::static_lock_;  // Lock for access of static data...
-// static
-TimeTicks Watchdog::last_debugged_alarm_time_ = TimeTicks();
-// static
-TimeDelta Watchdog::last_debugged_alarm_delay_;
-
 }  // namespace base