Add a new GetInstance() method for remaining files with singleton classes under chrome/browser.

chrome/browser/file_path_watcher/file_path_watcher_inotify.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 "chrome/browser/file_path_watcher/file_path_watcher.h"
 
 #include <errno.h>
 #include <string.h>
 #include <sys/inotify.h>
 #include <sys/ioctl.h>
 #include <sys/select.h>
 #include <unistd.h>
 
 #include <algorithm>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/eintr_wrapper.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/hash_tables.h"
+#include "base/lazy_instance.h"
 #include "base/lock.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/scoped_ptr.h"
-#include "base/singleton.h"
 #include "base/task.h"
 #include "base/thread.h"
 
 namespace {
 
 class FilePathWatcherImpl;
 
 // Singleton to manage all inotify watches.
 // TODO(tony): It would be nice if this wasn't a singleton.
 // http://crbug.com/38174
 class InotifyReader {
  public:
   typedef int Watch;  // Watch descriptor used by AddWatch and RemoveWatch.
   static const Watch kInvalidWatch = -1;
 
   // Watch directory |path| for changes. |watcher| will be notified on each
   // change. Returns kInvalidWatch on failure.
   Watch AddWatch(const FilePath& path, FilePathWatcherImpl* watcher);
 
   // Remove |watch|. Returns true on success.
   bool RemoveWatch(Watch watch, FilePathWatcherImpl* watcher);
 
   // Callback for InotifyReaderTask.
   void OnInotifyEvent(const inotify_event* event);
 
  private:
-  friend struct DefaultSingletonTraits<InotifyReader>;
+  friend struct ::base::DefaultLazyInstanceTraits<InotifyReader>;
 
   typedef std::set<FilePathWatcherImpl*> WatcherSet;
 
   InotifyReader();
   ~InotifyReader();
 
   // We keep track of which delegates want to be notified on which watches.
   base::hash_map<Watch, WatcherSet> watchers_;
 
   // Lock to protect watchers_.
@@ skipping 127 matching lines @@
   }
 
  private:
   InotifyReader* reader_;
   int inotify_fd_;
   int shutdown_fd_;
 
   DISALLOW_COPY_AND_ASSIGN(InotifyReaderTask);
 };
 
+static base::LazyInstance<InotifyReader> g_inotify_reader(
+    base::LINKER_INITIALIZED);
+
 InotifyReader::InotifyReader()
     : thread_("inotify_reader"),
       inotify_fd_(inotify_init()),
       valid_(false) {
   shutdown_pipe_[0] = -1;
   shutdown_pipe_[1] = -1;
   if (inotify_fd_ >= 0 && pipe(shutdown_pipe_) == 0 && thread_.Start()) {
     thread_.message_loop()->PostTask(
         FROM_HERE, new InotifyReaderTask(this, inotify_fd_, shutdown_pipe_[0]));
     valid_ = true;
@@ skipping 147 matching lines @@
   // Switch to the file thread if necessary so we can access |watches_|.
   if (!BrowserThread::CurrentlyOn(BrowserThread::FILE)) {
     BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
         NewRunnableMethod(this, &FilePathWatcherImpl::Cancel));
     return;
   }
 
   for (WatchVector::iterator watch_entry(watches_.begin());
        watch_entry != watches_.end(); ++watch_entry) {
     if (watch_entry->watch_ != InotifyReader::kInvalidWatch)
-      Singleton<InotifyReader>::get()->RemoveWatch(watch_entry->watch_, this);
+      g_inotify_reader.Get().RemoveWatch(watch_entry->watch_, this);
   }
   watches_.clear();
   delegate_ = NULL;
   target_.clear();
 }
 
 bool FilePathWatcherImpl::UpdateWatches() {
   // Ensure this runs on the file thread exclusively in order to avoid
   // concurrency issues.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   // Walk the list of watches and update them as we go.
   FilePath path(FILE_PATH_LITERAL("/"));
   bool path_valid = true;
   for (WatchVector::iterator watch_entry(watches_.begin());
        watch_entry != watches_.end(); ++watch_entry) {
     InotifyReader::Watch old_watch = watch_entry->watch_;
     if (path_valid) {
-      watch_entry->watch_ =
-          Singleton<InotifyReader>::get()->AddWatch(path, this);
+      watch_entry->watch_ = g_inotify_reader.Get().AddWatch(path, this);
       if (watch_entry->watch_ == InotifyReader::kInvalidWatch) {
         path_valid = false;
       }
     } else {
       watch_entry->watch_ = InotifyReader::kInvalidWatch;
     }
     if (old_watch != InotifyReader::kInvalidWatch &&
         old_watch != watch_entry->watch_) {
-      Singleton<InotifyReader>::get()->RemoveWatch(old_watch, this);
+      g_inotify_reader.Get().RemoveWatch(old_watch, this);
     }
     path = path.Append(watch_entry->subdir_);
   }
 
   return true;
 }
 
 }  // namespace
 
 FilePathWatcher::FilePathWatcher() {
   impl_ = new FilePathWatcherImpl();
 }