Remove some LazyInstance use in base/

base/threading/watchdog.cc

 // 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"
 
 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.
 
 struct StaticData {
   // Lock for access of static data...
   Lock lock;
 
   // When did we last alarm and get stuck (for a while) in a debugger?
   TimeTicks last_debugged_alarm_time;
 
   // How long did we sit on a break in the debugger?
   TimeDelta last_debugged_alarm_delay;
 };
 
-LazyInstance<StaticData>::Leaky g_static_data = LAZY_INSTANCE_INITIALIZER;
+StaticData* GetStaticData() {
+  static auto static_data = new StaticData();
+  return static_data;
+}
 
 }  // namespace
 
 // Start thread running in a Disarmed state.
 Watchdog::Watchdog(const TimeDelta& duration,
                    const std::string& thread_watched_name,
                    bool enabled)
   : enabled_(enabled),
     lock_(),
     condition_variable_(&lock_),
@@ skipping 67 matching lines @@
 void Watchdog::Alarm() {
   DVLOG(1) << "Watchdog alarmed for " << thread_watched_name_;
 }
 
 //------------------------------------------------------------------------------
 // Internal private methods that the watchdog thread uses.
 
 void Watchdog::ThreadDelegate::ThreadMain() {
   SetThreadName();
   TimeDelta remaining_duration;
-  StaticData* static_data = g_static_data.Pointer();
+  StaticData* static_data = GetStaticData();
   while (1) {
     AutoLock lock(watchdog_->lock_);
     while (DISARMED == watchdog_->state_)
       watchdog_->condition_variable_.Wait();
     if (SHUTDOWN == watchdog_->state_) {
       watchdog_->state_ = JOINABLE;
       return;
     }
     DCHECK(ARMED == watchdog_->state_);
     remaining_duration = watchdog_->duration_ -
@@ skipping 35 matching lines @@
 }
 
 void Watchdog::ThreadDelegate::SetThreadName() const {
   std::string name = watchdog_->thread_watched_name_ + " Watchdog";
   PlatformThread::SetName(name);
   DVLOG(1) << "Watchdog active: " << name;
 }
 
 // static
 void Watchdog::ResetStaticData() {
-  StaticData* static_data = g_static_data.Pointer();
+  StaticData* static_data = GetStaticData();
   AutoLock lock(static_data->lock);
   static_data->last_debugged_alarm_time = TimeTicks();
   static_data->last_debugged_alarm_delay = TimeDelta();
 }
 
 }  // namespace base