Move FilePathWatcher class from browser/... to common/...

content/common/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 "content/common/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/logging.h"
 #include "base/message_loop.h"
+#include "base/message_loop_proxy.h"
 #include "base/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/task.h"
 #include "base/threading/thread.h"
 
 namespace {
 
 class FilePathWatcherImpl;
 
 // Singleton to manage all inotify watches.
@@ skipping 52 matching lines @@
   // the currently watched path for |fired_watch|. The flag |created| is true if
   // the object appears, and |is_directory| is set when the event refers to a
   // directory.
   void OnFilePathChanged(InotifyReader::Watch fired_watch,
                          const FilePath::StringType& child,
                          bool created,
                          bool is_directory);
 
   // 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, FilePathWatcher::Delegate* delegate);
+  virtual bool Watch(const FilePath& path,
+                     FilePathWatcher::Delegate* delegate,
+                     scoped_refptr<base::MessageLoopProxy> loop) OVERRIDE;
 
   // Cancel the watch. This unregisters the instance with InotifyReader.
-  virtual void Cancel();
+  virtual void Cancel() OVERRIDE;
 
  private:
   virtual ~FilePathWatcherImpl() {}
 
   // Inotify watches are installed for all directory components of |target_|. A
   // WatchEntry instance holds the watch descriptor for a component and the
   // subdirectory for that identifies the next component.
   struct WatchEntry {
     WatchEntry(InotifyReader::Watch watch, const FilePath::StringType& subdir)
         : watch_(watch),
@@ skipping 161 matching lines @@
 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_);
 
   for (WatcherSet::iterator watcher = watchers_[event->wd].begin();
        watcher != watchers_[event->wd].end();
        ++watcher) {
-    BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
+    (*watcher)->message_loop()->PostTask(FROM_HERE,

[Mattias Nissler (ping if slow), 2011/03/17 18:14:27]

This is what I was referring to in my other comment. It seems strange to get the
message loop from the watcher and then use it to post a task to that exact
watcher. I think we should just tell the watcher to its thing and it'll do the
thread switching internally.

         NewRunnableMethod(*watcher,
                           &FilePathWatcherImpl::OnFilePathChanged,
                           event->wd,
                           child,
                           event->mask & (IN_CREATE | IN_MOVED_TO),
                           event->mask & IN_ISDIR));
   }
 }
 
 FilePathWatcherImpl::FilePathWatcherImpl()
     : delegate_(NULL) {
 }
 
 void FilePathWatcherImpl::OnFilePathChanged(InotifyReader::Watch fired_watch,
                                             const FilePath::StringType& child,
                                             bool created,
                                             bool is_directory) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK(MessageLoopForIO::current());
 
   // Find the entry in |watches_| that corresponds to |fired_watch|.
   WatchVector::const_iterator watch_entry(watches_.begin());
   for ( ; watch_entry != watches_.end(); ++watch_entry) {
     if (fired_watch == watch_entry->watch_)
       break;
   }
 
   // If this notification is from a previous generation of watches or the watch
   // has been cancelled (|watches_| is empty then), bail out.
@@ skipping 22 matching lines @@
   //  - One of the parent directories appears. The event corresponding to the
   //    target appearing might have been missed in this case, so recheck.
   if (target_changed ||
       (change_on_target_path && !created) ||
       (change_on_target_path && file_util::PathExists(target_))) {
     delegate_->OnFilePathChanged(target_);
   }
 }
 
 bool FilePathWatcherImpl::Watch(const FilePath& path,
-                                FilePathWatcher::Delegate* delegate) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+                                FilePathWatcher::Delegate* delegate,
+                                scoped_refptr<base::MessageLoopProxy>) {
   DCHECK(target_.empty());
+  DCHECK(MessageLoopForIO::current());
 
   delegate_ = delegate;
   target_ = path;
   std::vector<FilePath::StringType> comps;
   target_.GetComponents(&comps);
   DCHECK(!comps.empty());
   for (std::vector<FilePath::StringType>::const_iterator comp(++comps.begin());
        comp != comps.end(); ++comp) {
     watches_.push_back(WatchEntry(InotifyReader::kInvalidWatch, *comp));
   }
   watches_.push_back(WatchEntry(InotifyReader::kInvalidWatch,
                                 FilePath::StringType()));
   return UpdateWatches();
 }
 
 void FilePathWatcherImpl::Cancel() {
-  // Switch to the file thread if necessary so we can access |watches_|.
-  if (!BrowserThread::CurrentlyOn(BrowserThread::FILE)) {
-    BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
+  if (!message_loop().get()) {
+    // Watch was never called, so exit.
+    return;
+  }
+    // Switch to the file thread if necessary so we can access |watches_|.

[Mattias Nissler (ping if slow), 2011/03/17 18:14:27]

indentation

+  if (!message_loop()->BelongsToCurrentThread()) {
+    message_loop()->PostTask(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)
       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));
+  DCHECK(message_loop()->BelongsToCurrentThread());
 
   // 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_ = g_inotify_reader.Get().AddWatch(path, this);
       if (watch_entry->watch_ == InotifyReader::kInvalidWatch) {
@@ skipping 10 matching lines @@
   }
 
   return true;
 }
 
 }  // namespace
 
 FilePathWatcher::FilePathWatcher() {
   impl_ = new FilePathWatcherImpl();
 }