Remove some LazyInstance use in base/

base/files/file_descriptor_watcher_posix.cc

 // Copyright 2016 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/files/file_descriptor_watcher_posix.h"
 
 #include "base/bind.h"
-#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_local.h"
 
 namespace base {
 
 namespace {
 
 // MessageLoopForIO used to watch file descriptors for which callbacks are
 // registered from a given thread.
-LazyInstance<ThreadLocalPointer<MessageLoopForIO>>::Leaky
-    tls_message_loop_for_io = LAZY_INSTANCE_INITIALIZER;
+ThreadLocalPointer<MessageLoopForIO>* GetTLSMessageLoopForIO() {
+  static auto tls_message_loop_for_io =
+      new ThreadLocalPointer<MessageLoopForIO>();
+  return tls_message_loop_for_io;
+}
 
 }  // namespace
 
 FileDescriptorWatcher::Controller::~Controller() {
   DCHECK(sequence_checker_.CalledOnValidSequence());
 
   // Delete |watcher_| on the MessageLoopForIO.
   //
   // If the MessageLoopForIO is deleted before Watcher::StartWatching() runs,
   // |watcher_| is leaked. If the MessageLoopForIO is deleted after
@@ skipping 110 matching lines @@
   // MessageLoopForIO. If the MessageLoopForIO is deleted before the delete task
   // runs, the following line takes care of deleting the Watcher.
   delete this;
 }
 
 FileDescriptorWatcher::Controller::Controller(MessageLoopForIO::Mode mode,
                                               int fd,
                                               const Closure& callback)
     : callback_(callback),
       message_loop_for_io_task_runner_(
-          tls_message_loop_for_io.Get().Get()->task_runner()),
+          GetTLSMessageLoopForIO()->Get()->task_runner()),
       weak_factory_(this) {
   DCHECK(!callback_.is_null());
   DCHECK(message_loop_for_io_task_runner_);
   watcher_ = MakeUnique<Watcher>(weak_factory_.GetWeakPtr(), mode, fd);
   StartWatching();
 }
 
 void FileDescriptorWatcher::Controller::StartWatching() {
   DCHECK(sequence_checker_.CalledOnValidSequence());
   // It is safe to use Unretained() below because |watcher_| can only be deleted
@@ skipping 12 matching lines @@
   callback_.Run();
 
   // If |this| wasn't deleted, re-enable the watch.
   if (weak_this)
     StartWatching();
 }
 
 FileDescriptorWatcher::FileDescriptorWatcher(
     MessageLoopForIO* message_loop_for_io) {
   DCHECK(message_loop_for_io);
-  DCHECK(!tls_message_loop_for_io.Get().Get());
-  tls_message_loop_for_io.Get().Set(message_loop_for_io);
+  DCHECK(!GetTLSMessageLoopForIO());
+  GetTLSMessageLoopForIO()->Set(message_loop_for_io);
 }
 
 FileDescriptorWatcher::~FileDescriptorWatcher() {
-  tls_message_loop_for_io.Get().Set(nullptr);
+  GetTLSMessageLoopForIO()->Set(nullptr);
 }
 
 std::unique_ptr<FileDescriptorWatcher::Controller>
 FileDescriptorWatcher::WatchReadable(int fd, const Closure& callback) {
   return WrapUnique(new Controller(MessageLoopForIO::WATCH_READ, fd, callback));
 }
 
 std::unique_ptr<FileDescriptorWatcher::Controller>
 FileDescriptorWatcher::WatchWritable(int fd, const Closure& callback) {
   return WrapUnique(
       new Controller(MessageLoopForIO::WATCH_WRITE, fd, callback));
 }
 
 }  // namespace base