Remove some LazyInstance use in base/

base/files/file_path_watcher_linux.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/files/file_path_watcher.h"
 
 #include <errno.h>
 #include <stddef.h>
 #include <string.h>
 #include <sys/inotify.h>
 #include <sys/ioctl.h>
 #include <sys/select.h>
 #include <unistd.h>
 
 #include <algorithm>
 #include <map>
 #include <memory>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
-#include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/sequenced_task_runner_handle.h"
@@ skipping 18 matching lines @@
   // change. Returns kInvalidWatch on failure.
   Watch AddWatch(const FilePath& path, FilePathWatcherImpl* watcher);
 
   // Remove |watch| if it's valid.
   void RemoveWatch(Watch watch, FilePathWatcherImpl* watcher);
 
   // Callback for InotifyReaderTask.
   void OnInotifyEvent(const inotify_event* event);
 
  private:
-  friend struct DefaultLazyInstanceTraits<InotifyReader>;
-
+  friend InotifyReader* GetInotifyReader();
   typedef std::set<FilePathWatcherImpl*> WatcherSet;
 
   InotifyReader();
-  // There is no destructor because |g_inotify_reader| is a
-  // base::LazyInstace::Leaky object. Having a destructor causes build
-  // issues with GCC 6 (http://crbug.com/636346).
+  // There is no destructor because GetInotifyReader() is leaky. Having a
+  // destructor causes build issues with GCC 6 (http://crbug.com/636346).
 
   // We keep track of which delegates want to be notified on which watches.
   hash_map<Watch, WatcherSet> watchers_;
 
   // Lock to protect watchers_.
   Lock lock_;
 
   // Separate thread on which we run blocking read for inotify events.
   Thread thread_;
 
@@ skipping 152 matching lines @@
     while (i < bytes_read) {
       inotify_event* event = reinterpret_cast<inotify_event*>(&buffer[i]);
       size_t event_size = sizeof(inotify_event) + event->len;
       DCHECK(i + event_size <= static_cast<size_t>(bytes_read));
       reader->OnInotifyEvent(event);
       i += event_size;
     }
   }
 }
 
-static LazyInstance<InotifyReader>::Leaky g_inotify_reader =
-    LAZY_INSTANCE_INITIALIZER;
+InotifyReader* GetInotifyReader() {
+  static auto inotify_reader = new InotifyReader();
+  return inotify_reader;
+}
 
 InotifyReader::InotifyReader()
     : thread_("inotify_reader"),
       inotify_fd_(inotify_init()),
       valid_(false) {
   if (inotify_fd_ < 0)
     PLOG(ERROR) << "inotify_init() failed";
 
   if (inotify_fd_ >= 0 && thread_.Start()) {
     thread_.task_runner()->PostTask(
@@ skipping 193 matching lines @@
     return;
   }
 
   DCHECK(task_runner()->RunsTasksOnCurrentThread());
   DCHECK(!is_cancelled());
 
   set_cancelled();
   callback_.Reset();
 
   for (size_t i = 0; i < watches_.size(); ++i)
-    g_inotify_reader.Get().RemoveWatch(watches_[i].watch, this);
+    GetInotifyReader()->RemoveWatch(watches_[i].watch, this);
   watches_.clear();
   target_.clear();
   RemoveRecursiveWatches();
 }
 
 void FilePathWatcherImpl::UpdateWatches() {
   // Ensure this runs on the task_runner() exclusively in order to avoid
   // concurrency issues.
   DCHECK(task_runner()->RunsTasksOnCurrentThread());
   DCHECK(HasValidWatchVector());
 
   // Walk the list of watches and update them as we go.
   FilePath path(FILE_PATH_LITERAL("/"));
   for (size_t i = 0; i < watches_.size(); ++i) {
     WatchEntry& watch_entry = watches_[i];
     InotifyReader::Watch old_watch = watch_entry.watch;
     watch_entry.watch = InotifyReader::kInvalidWatch;
     watch_entry.linkname.clear();
-    watch_entry.watch = g_inotify_reader.Get().AddWatch(path, this);
+    watch_entry.watch = GetInotifyReader()->AddWatch(path, this);
     if (watch_entry.watch == InotifyReader::kInvalidWatch) {
       // Ignore the error code (beyond symlink handling) to attempt to add
       // watches on accessible children of unreadable directories. Note that
       // this is a best-effort attempt; we may not catch events in this
       // scenario.
       if (IsLink(path))
         AddWatchForBrokenSymlink(path, &watch_entry);
     }
     if (old_watch != watch_entry.watch)
-      g_inotify_reader.Get().RemoveWatch(old_watch, this);
+      GetInotifyReader()->RemoveWatch(old_watch, this);
     path = path.Append(watch_entry.subdir);
   }
 
   UpdateRecursiveWatches(InotifyReader::kInvalidWatch,
                          false /* is directory? */);
 }
 
 void FilePathWatcherImpl::UpdateRecursiveWatches(
     InotifyReader::Watch fired_watch,
     bool is_dir) {
@@ skipping 25 matching lines @@
       target_;
 
   std::map<FilePath, InotifyReader::Watch>::iterator start_it =
       recursive_watches_by_path_.lower_bound(changed_dir);
   std::map<FilePath, InotifyReader::Watch>::iterator end_it = start_it;
   for (; end_it != recursive_watches_by_path_.end(); ++end_it) {
     const FilePath& cur_path = end_it->first;
     if (!changed_dir.IsParent(cur_path))
       break;
     if (!DirectoryExists(cur_path))
-      g_inotify_reader.Get().RemoveWatch(end_it->second, this);
+      GetInotifyReader()->RemoveWatch(end_it->second, this);
   }
   recursive_watches_by_path_.erase(start_it, end_it);
   UpdateRecursiveWatchesForPath(changed_dir);
 }
 
 void FilePathWatcherImpl::UpdateRecursiveWatchesForPath(const FilePath& path) {
   DCHECK(recursive_);
   DCHECK(!path.empty());
   DCHECK(DirectoryExists(path));
 
   // Note: SHOW_SYM_LINKS exposes symlinks as symlinks, so they are ignored
   // rather than followed. Following symlinks can easily lead to the undesirable
   // situation where the entire file system is being watched.
   FileEnumerator enumerator(
       path,
       true /* recursive enumeration */,
       FileEnumerator::DIRECTORIES | FileEnumerator::SHOW_SYM_LINKS);
   for (FilePath current = enumerator.Next();
        !current.empty();
        current = enumerator.Next()) {
     DCHECK(enumerator.GetInfo().IsDirectory());
 
     if (!ContainsKey(recursive_watches_by_path_, current)) {
       // Add new watches.
-      InotifyReader::Watch watch =
-          g_inotify_reader.Get().AddWatch(current, this);
+      InotifyReader::Watch watch = GetInotifyReader()->AddWatch(current, this);
       TrackWatchForRecursion(watch, current);
     } else {
       // Update existing watches.
       InotifyReader::Watch old_watch = recursive_watches_by_path_[current];
       DCHECK_NE(InotifyReader::kInvalidWatch, old_watch);
-      InotifyReader::Watch watch =
-          g_inotify_reader.Get().AddWatch(current, this);
+      InotifyReader::Watch watch = GetInotifyReader()->AddWatch(current, this);
       if (watch != old_watch) {
-        g_inotify_reader.Get().RemoveWatch(old_watch, this);
+        GetInotifyReader()->RemoveWatch(old_watch, this);
         recursive_paths_by_watch_.erase(old_watch);
         recursive_watches_by_path_.erase(current);
         TrackWatchForRecursion(watch, current);
       }
     }
   }
 }
 
 void FilePathWatcherImpl::TrackWatchForRecursion(InotifyReader::Watch watch,
                                                  const FilePath& path) {
@@ skipping 11 matching lines @@
 }
 
 void FilePathWatcherImpl::RemoveRecursiveWatches() {
   if (!recursive_)
     return;
 
   for (hash_map<InotifyReader::Watch, FilePath>::const_iterator it =
            recursive_paths_by_watch_.begin();
        it != recursive_paths_by_watch_.end();
        ++it) {
-    g_inotify_reader.Get().RemoveWatch(it->first, this);
+    GetInotifyReader()->RemoveWatch(it->first, this);
   }
   recursive_paths_by_watch_.clear();
   recursive_watches_by_path_.clear();
 }
 
 void FilePathWatcherImpl::AddWatchForBrokenSymlink(const FilePath& path,
                                                    WatchEntry* watch_entry) {
   DCHECK_EQ(InotifyReader::kInvalidWatch, watch_entry->watch);
   FilePath link;
   if (!ReadSymbolicLink(path, &link))
     return;
 
   if (!link.IsAbsolute())
     link = path.DirName().Append(link);
 
   // Try watching symlink target directory. If the link target is "/", then we
   // shouldn't get here in normal situations and if we do, we'd watch "/" for
   // changes to a component "/" which is harmless so no special treatment of
   // this case is required.
   InotifyReader::Watch watch =
-      g_inotify_reader.Get().AddWatch(link.DirName(), this);
+      GetInotifyReader()->AddWatch(link.DirName(), this);
   if (watch == InotifyReader::kInvalidWatch) {
     // TODO(craig) Symlinks only work if the parent directory for the target
     // exist. Ideally we should make sure we've watched all the components of
     // the symlink path for changes. See crbug.com/91561 for details.
     DPLOG(WARNING) << "Watch failed for "  << link.DirName().value();
     return;
   }
   watch_entry->watch = watch;
   watch_entry->linkname = link.BaseName().value();
 }
 
 bool FilePathWatcherImpl::HasValidWatchVector() const {
   if (watches_.empty())
     return false;
   for (size_t i = 0; i < watches_.size() - 1; ++i) {
     if (watches_[i].subdir.empty())
       return false;
   }
   return watches_.back().subdir.empty();
 }
 
 }  // namespace
 
 FilePathWatcher::FilePathWatcher() {
   sequence_checker_.DetachFromSequence();
   impl_ = MakeUnique<FilePathWatcherImpl>();
 }
 
 }  // namespace base