Move FileWatcher from src/base/ to src/chrome/browser/ and switch

chrome/browser/file_watcher_inotify.cc

 // Copyright (c) 2009 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/file_watcher.h"
+#include "chrome/browser/file_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>
@@ skipping 11 matching lines @@
 #include "base/singleton.h"
 #include "base/task.h"
 #include "base/thread.h"
 #include "base/waitable_event.h"
 
 namespace {
 
 class FileWatcherImpl;
 
 // 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 |path| for changes. |watcher| will be notified on each change.
   // Returns kInvalidWatch on failure.
   Watch AddWatch(const FilePath& path, FileWatcherImpl* watcher);
 
   // Remove |watch|. Returns true on success.
@@ skipping 34 matching lines @@
 class FileWatcherImpl : public FileWatcher::PlatformDelegate {
  public:
   FileWatcherImpl();
   ~FileWatcherImpl();
 
   // Called for each event coming from the watch.
   void OnInotifyEvent(const inotify_event* event);
 
   // Start watching |path| for changes and notify |delegate| on each change.
   // Returns true if watch for |path| has been added successfully.
-  virtual bool Watch(const FilePath& path, FileWatcher::Delegate* delegate,
-                     MessageLoop* backend_loop);
+  virtual bool Watch(const FilePath& path, FileWatcher::Delegate* delegate);
 
  private:
   // Delegate to notify upon changes.
   FileWatcher::Delegate* delegate_;
 
   // Watch returned by InotifyReader.
   InotifyReader::Watch watch_;
 
   // The file we're watching.
   FilePath path_;
 
-  // Loop where we post file change notifications to.
-  MessageLoop* loop_;
-
   DISALLOW_COPY_AND_ASSIGN(FileWatcherImpl);
 };
 
 class FileWatcherImplNotifyTask : public Task {
  public:
   FileWatcherImplNotifyTask(FileWatcher::Delegate* delegate,
                             const FilePath& path)
       : delegate_(delegate), path_(path) {
   }
 
@@ skipping 170 matching lines @@
 
   Singleton<InotifyReader>::get()->RemoveWatch(watch_, this);
 }
 
 void FileWatcherImpl::OnInotifyEvent(const inotify_event* event) {
   // Since we're watching the directory, filter out inotify events
   // if it's not related to the file we're watching.
   if (path_ != path_.DirName().Append(event->name))
     return;
 
-  loop_->PostTask(FROM_HERE,
+  ChromeThread::PostTask(ChromeThread::FILE, FROM_HERE,
       new FileWatcherImplNotifyTask(delegate_, path_));
 }
 
 bool FileWatcherImpl::Watch(const FilePath& path,
-                            FileWatcher::Delegate* delegate,
-                            MessageLoop* backend_loop) {
+                            FileWatcher::Delegate* delegate) {
   // Each FileWatcherImpl can only watch one file.
   DCHECK(watch_ == InotifyReader::kInvalidWatch);
 
   // It's not possible to watch a file that doesn't exist, so instead,
   // watch the parent directory.
   if (!file_util::PathExists(path.DirName()))
     return false;
 
   delegate_ = delegate;
   path_ = path;
-  loop_ = MessageLoop::current();
   watch_ = Singleton<InotifyReader>::get()->AddWatch(path.DirName(), this);
   return watch_ != InotifyReader::kInvalidWatch;
 }
 
 }  // namespace
 
 FileWatcher::FileWatcher() {
   impl_ = new FileWatcherImpl();
 }