Move Posix file utils to the base namespace.

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 <string.h>
 #include <sys/inotify.h>
 #include <sys/ioctl.h>
@@ skipping 38 matching lines @@
   // 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 ::base::DefaultLazyInstanceTraits<InotifyReader>;
+  friend struct 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_;
+  hash_map<Watch, WatcherSet> watchers_;
 
   // Lock to protect watchers_.
-  base::Lock lock_;
+  Lock lock_;
 
   // Separate thread on which we run blocking read for inotify events.
-  base::Thread thread_;
+  Thread thread_;
 
   // File descriptor returned by inotify_init.
   const int inotify_fd_;
 
   // Use self-pipe trick to unblock select during shutdown.
   int shutdown_pipe_[2];
 
   // Flag set to true when startup was successful.
   bool valid_;
 
@@ skipping 68 matching lines @@
 };
 
 void InotifyReaderCallback(InotifyReader* reader, int inotify_fd,
                            int shutdown_fd) {
   // Make sure the file descriptors are good for use with select().
   CHECK_LE(0, inotify_fd);
   CHECK_GT(FD_SETSIZE, inotify_fd);
   CHECK_LE(0, shutdown_fd);
   CHECK_GT(FD_SETSIZE, shutdown_fd);
 
-  base::debug::TraceLog::GetInstance()->SetCurrentThreadBlocksMessageLoop();
+  debug::TraceLog::GetInstance()->SetCurrentThreadBlocksMessageLoop();
 
   while (true) {
     fd_set rfds;
     FD_ZERO(&rfds);
     FD_SET(inotify_fd, &rfds);
     FD_SET(shutdown_fd, &rfds);
 
     // Wait until some inotify events are available.
     int select_result =
       HANDLE_EINTR(select(std::max(inotify_fd, shutdown_fd) + 1,
@@ skipping 30 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 base::LazyInstance<InotifyReader>::Leaky g_inotify_reader =
+static LazyInstance<InotifyReader>::Leaky g_inotify_reader =
     LAZY_INSTANCE_INITIALIZER;
 
 InotifyReader::InotifyReader()
     : thread_("inotify_reader"),
       inotify_fd_(inotify_init()),
       valid_(false) {
   if (inotify_fd_ < 0)
     PLOG(ERROR) << "inotify_init() failed";
 
   shutdown_pipe_[0] = -1;
   shutdown_pipe_[1] = -1;
   if (inotify_fd_ >= 0 && pipe(shutdown_pipe_) == 0 && thread_.Start()) {
     thread_.message_loop()->PostTask(
-        FROM_HERE, base::Bind(&InotifyReaderCallback, this, inotify_fd_,
+        FROM_HERE, Bind(&InotifyReaderCallback, this, inotify_fd_,
                               shutdown_pipe_[0]));
     valid_ = true;
   }
 }
 
 InotifyReader::~InotifyReader() {
   if (valid_) {
     // Write to the self-pipe so that the select call in InotifyReaderTask
     // returns.
     ssize_t ret = HANDLE_EINTR(write(shutdown_pipe_[1], "", 1));
     DPCHECK(ret > 0);
     DCHECK_EQ(ret, 1);
     thread_.Stop();
   }
   if (inotify_fd_ >= 0)
     close(inotify_fd_);
   if (shutdown_pipe_[0] >= 0)
     close(shutdown_pipe_[0]);
   if (shutdown_pipe_[1] >= 0)
     close(shutdown_pipe_[1]);
 }
 
 InotifyReader::Watch InotifyReader::AddWatch(
     const FilePath& path, FilePathWatcherImpl* watcher) {
   if (!valid_)
     return kInvalidWatch;
 
-  base::AutoLock auto_lock(lock_);
+  AutoLock auto_lock(lock_);
 
   Watch watch = inotify_add_watch(inotify_fd_, path.value().c_str(),
                                   IN_CREATE | IN_DELETE |
                                   IN_CLOSE_WRITE | IN_MOVE |
                                   IN_ONLYDIR);
 
   if (watch == kInvalidWatch)
     return kInvalidWatch;
 
   watchers_[watch].insert(watcher);
 
   return watch;
 }
 
 bool InotifyReader::RemoveWatch(Watch watch,
                                 FilePathWatcherImpl* watcher) {
   if (!valid_)
     return false;
 
-  base::AutoLock auto_lock(lock_);
+  AutoLock auto_lock(lock_);
 
   watchers_[watch].erase(watcher);
 
   if (watchers_[watch].empty()) {
     watchers_.erase(watch);
     return (inotify_rm_watch(inotify_fd_, watch) == 0);
   }
 
   return true;
 }
 
 void InotifyReader::OnInotifyEvent(const inotify_event* event) {
   if (event->mask & IN_IGNORED)
     return;
 
   FilePath::StringType child(event->len ? event->name : FILE_PATH_LITERAL(""));
-  base::AutoLock auto_lock(lock_);
+  AutoLock auto_lock(lock_);
 
   for (WatcherSet::iterator watcher = watchers_[event->wd].begin();
        watcher != watchers_[event->wd].end();
        ++watcher) {
     (*watcher)->OnFilePathChanged(event->wd,
                                   child,
                                   event->mask & (IN_CREATE | IN_MOVED_TO));
   }
 }
 
 FilePathWatcherImpl::FilePathWatcherImpl() {
 }
 
 void FilePathWatcherImpl::OnFilePathChanged(InotifyReader::Watch fired_watch,
                                             const FilePath::StringType& child,
                                             bool created) {
   if (!message_loop()->BelongsToCurrentThread()) {
     // Switch to message_loop_ to access watches_ safely.
     message_loop()->PostTask(FROM_HERE,
-        base::Bind(&FilePathWatcherImpl::OnFilePathChanged,
+        Bind(&FilePathWatcherImpl::OnFilePathChanged,
                    this,
                    fired_watch,
                    child,
                    created));
     return;
   }
 
   DCHECK(MessageLoopForIO::current());
 
   // Find the entry in |watches_| that corresponds to |fired_watch|.
@@ skipping 46 matching lines @@
                                 bool recursive,
                                 const FilePathWatcher::Callback& callback) {
   DCHECK(target_.empty());
   DCHECK(MessageLoopForIO::current());
   if (recursive) {
     // Recursive watch is not supported on this platform.
     NOTIMPLEMENTED();
     return false;
   }
 
-  set_message_loop(base::MessageLoopProxy::current().get());
+  set_message_loop(MessageLoopProxy::current().get());
   callback_ = callback;
   target_ = path;
   MessageLoop::current()->AddDestructionObserver(this);
 
   std::vector<FilePath::StringType> comps;
   target_.GetComponents(&comps);
   DCHECK(!comps.empty());
   std::vector<FilePath::StringType>::const_iterator comp = comps.begin();
   for (++comp; comp != comps.end(); ++comp)
     watches_.push_back(WatchEntry(InotifyReader::kInvalidWatch, *comp));
 
   watches_.push_back(WatchEntry(InotifyReader::kInvalidWatch,
                                 FilePath::StringType()));
   return UpdateWatches();
 }
 
 void FilePathWatcherImpl::Cancel() {
   if (callback_.is_null()) {
     // Watch was never called, or the |message_loop_| thread is already gone.
     set_cancelled();
     return;
   }
 
   // Switch to the message_loop_ if necessary so we can access |watches_|.
   if (!message_loop()->BelongsToCurrentThread()) {
     message_loop()->PostTask(FROM_HERE,
-                             base::Bind(&FilePathWatcher::CancelWatch,
+                             Bind(&FilePathWatcher::CancelWatch,
                                         make_scoped_refptr(this)));
   } else {
     CancelOnMessageLoopThread();
   }
 }
 
 void FilePathWatcherImpl::CancelOnMessageLoopThread() {
   if (!is_cancelled())
     set_cancelled();
 
@@ skipping 24 matching lines @@
   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_ = g_inotify_reader.Get().AddWatch(path, this);
       if ((watch_entry->watch_ == InotifyReader::kInvalidWatch) &&
           file_util::IsLink(path)) {
         FilePath link;
-        if (file_util::ReadSymbolicLink(path, &link)) {
+        if (ReadSymbolicLink(path, &link)) {
           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.
           watch_entry->watch_ =
               g_inotify_reader.Get().AddWatch(link.DirName(), this);
           if (watch_entry->watch_ != InotifyReader::kInvalidWatch) {
             watch_entry->linkname_ = link.BaseName().value();
@@ skipping 22 matching lines @@
   return true;
 }
 
 }  // namespace
 
 FilePathWatcher::FilePathWatcher() {
   impl_ = new FilePathWatcherImpl();
 }
 
 }  // namespace base