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

chrome/common/file_path_watcher/file_path_watcher_mac.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 "chrome/common/file_path_watcher/file_path_watcher.h"
 
 #include <CoreServices/CoreServices.h>
 #include <set>
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/mac/scoped_cftyperef.h"
+#include "base/message_loop.h"
 #include "base/singleton.h"
 #include "base/time.h"
 
+// Note to future well meaning engineers. Unless kqueue semantics have changed
+// considerably, do NOT try to reimplement this class using kqueue. The main
+// problem is that this class requires the ability to watch a directory
+// and notice changes to any files within it. A kqueue on a directory can watch
+// for creation and deletion of files, but not for modifications to files within
+// the directory. To do this with the current kqueue semantics would require
+// kqueueing every file in the directory, and file descriptors are a limited
+// resource. If you have a good idea on how to get around this, the source for a
+// reasonable implementation of this class using kqueues is attached here:
+// http://code.google.com/p/chromium/issues/detail?id=54822#c13

[dmac, 2011/03/17 17:16:48]

out of curiosity, had you already reached this same conclusion?

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

Yes. Sorry I didn't update the bug. IIRC, there was some email thread in which I
mentioned my findings.

+
 namespace {
 
 // The latency parameter passed to FSEventsStreamCreate().
 const CFAbsoluteTime kEventLatencySeconds = 0.3;
 
 // Mac-specific file watcher implementation based on the FSEvents API.
 class FilePathWatcherImpl : public FilePathWatcher::PlatformDelegate {
  public:
   FilePathWatcherImpl();
 
   // Called from the FSEvents callback whenever there is a change to the paths
   void OnFilePathChanged();
 
   // (Re-)Initialize the event stream to start reporting events from
   // |start_event|.
   void UpdateEventStream(FSEventStreamEventId start_event);
 
   // FilePathWatcher::PlatformDelegate overrides.
-  virtual bool Watch(const FilePath& path, FilePathWatcher::Delegate* delegate);
-  virtual void Cancel();
+  virtual bool Watch(const FilePath& path,
+                     FilePathWatcher::Delegate* delegate,
+                     scoped_refptr<base::MessageLoopProxy> loop) OVERRIDE;
+  virtual void Cancel() OVERRIDE;
+
+  scoped_refptr<base::MessageLoopProxy> run_loop_message_loop() {
+    return run_loop_message_loop_;
+  }
 
  private:
   virtual ~FilePathWatcherImpl() {}
 
   // Destroy the event stream.
   void DestroyEventStream();
 
   // Delegate to notify upon changes.
   scoped_refptr<FilePathWatcher::Delegate> delegate_;
 
   // Target path to watch (passed to delegate).
   FilePath target_;
 
   // Keep track of the last modified time of the file.  We use nulltime
   // to represent the file not existing.
   base::Time last_modified_;
 
   // The time at which we processed the first notification with the
   // |last_modified_| time stamp.
   base::Time first_notification_;
 
   // Backend stream we receive event callbacks from (strong reference).
   FSEventStreamRef fsevent_stream_;
 
+  // Run loop for FSEventStream to run on.
+  scoped_refptr<base::MessageLoopProxy> run_loop_message_loop_;
+
   // Used to detect early cancellation.
   bool canceled_;
 
   DISALLOW_COPY_AND_ASSIGN(FilePathWatcherImpl);
 };
 
 // The callback passed to FSEventStreamCreate().
 void FSEventsCallback(ConstFSEventStreamRef stream,
                       void* event_watcher, size_t num_events,
                       void* event_paths, const FSEventStreamEventFlags flags[],
                       const FSEventStreamEventId event_ids[]) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
   FilePathWatcherImpl* watcher =
       reinterpret_cast<FilePathWatcherImpl*>(event_watcher);
+  DCHECK(watcher->run_loop_message_loop()->BelongsToCurrentThread());
+
   bool root_changed = false;
   FSEventStreamEventId root_change_at = FSEventStreamGetLatestEventId(stream);
   for (size_t i = 0; i < num_events; i++) {
     if (flags[i] & kFSEventStreamEventFlagRootChanged)
       root_changed = true;
     if (event_ids[i])
       root_change_at = std::min(root_change_at, event_ids[i]);
   }
 
   // Reinitialize the event stream if we find changes to the root. This is
   // necessary since FSEvents doesn't report any events for the subtree after
   // the directory to be watched gets created.
   if (root_changed) {
     // Resetting the event stream from within the callback fails (FSEvents spews
     // bad file descriptor errors), so post a task to do the reset.
-    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+    watcher->run_loop_message_loop()->PostTask(FROM_HERE,
         NewRunnableMethod(watcher, &FilePathWatcherImpl::UpdateEventStream,
                           root_change_at));
   }
 
-  BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
+  watcher->message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(watcher, &FilePathWatcherImpl::OnFilePathChanged));
 }
 
 // FilePathWatcherImpl implementation:
 
 FilePathWatcherImpl::FilePathWatcherImpl()
     : fsevent_stream_(NULL),
       canceled_(false) {
 }
 
 void FilePathWatcherImpl::OnFilePathChanged() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  DCHECK(message_loop()->BelongsToCurrentThread());
   DCHECK(!target_.empty());
 
   base::PlatformFileInfo file_info;
   bool file_exists = file_util::GetFileInfo(target_, &file_info);
   if (file_exists && (last_modified_.is_null() ||
       last_modified_ != file_info.last_modified)) {
     last_modified_ = file_info.last_modified;
     first_notification_ = base::Time::Now();
     delegate_->OnFilePathChanged(target_);
   } else if (file_exists && !first_notification_.is_null()) {
@@ skipping 17 matching lines @@
       first_notification_ = base::Time();
     }
     delegate_->OnFilePathChanged(target_);
   } else if (!file_exists && !last_modified_.is_null()) {
     last_modified_ = base::Time();
     delegate_->OnFilePathChanged(target_);
   }
 }
 
 bool FilePathWatcherImpl::Watch(const FilePath& path,
-                                FilePathWatcher::Delegate* delegate) {
+                                FilePathWatcher::Delegate* delegate,
+                                scoped_refptr<base::MessageLoopProxy> loop) {
   DCHECK(target_.value().empty());
+  DCHECK(MessageLoopForIO::current());

[Mattias Nissler (ping if slow), 2011/03/17 10:37:56]

Same question as for the inotify implementation: Why can't we be consistently
using message_loop()->BelongsToCurrentThread()?

[dmac, 2011/03/17 17:16:48]

Same response ;-)

 
+  run_loop_message_loop_ = loop;
   target_ = path;
   delegate_ = delegate;
 
   FSEventStreamEventId start_event = FSEventsGetCurrentEventId();
 
   base::PlatformFileInfo file_info;
   if (file_util::GetFileInfo(target_, &file_info)) {
     last_modified_ = file_info.last_modified;
     first_notification_ = base::Time::Now();
   }
 
-  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+  run_loop_message_loop()->PostTask(FROM_HERE,
       NewRunnableMethod(this, &FilePathWatcherImpl::UpdateEventStream,
                         start_event));
 
   return true;
 }
 
 void FilePathWatcherImpl::Cancel() {
   // Switch to the UI thread if necessary, so we can tear down the event stream.
-  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+  if (run_loop_message_loop().get() &&

[Mattias Nissler (ping if slow), 2011/03/17 10:37:56]

I guess you need the NULL check since Cancel() can be called even if Watch() was
never called, correct? But shouldn't we just bail out in that case, since there
is no reason to run the cleanup? In any case, a comment explaining the situation
would probably be helpful.

[dmac, 2011/03/17 17:16:48]

Done.

+      !run_loop_message_loop()->BelongsToCurrentThread()) {
+    run_loop_message_loop()->PostTask(FROM_HERE,
         NewRunnableMethod(this, &FilePathWatcherImpl::Cancel));
     return;
   }
 
   canceled_ = true;
   if (fsevent_stream_)
     DestroyEventStream();
 }
 
 void FilePathWatcherImpl::UpdateEventStream(FSEventStreamEventId start_event) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(run_loop_message_loop()->BelongsToCurrentThread());
+  DCHECK(MessageLoopForUI::current());

[Mattias Nissler (ping if slow), 2011/03/17 10:37:56]

It seems that we can do the message loop type check at initialization time.

[dmac, 2011/03/17 17:16:48]

We can't actually (unless I'm missing something) because there doesn't appear to
be anyway of getting the type of a MessageLoopProxy.

 
   // It can happen that the watcher gets canceled while tasks that call this
   // function are still in flight, so abort if this situation is detected.
   if (canceled_)
     return;
 
   if (fsevent_stream_)
     DestroyEventStream();
 
   base::mac::ScopedCFTypeRef<CFStringRef> cf_path(CFStringCreateWithCString(
@@ skipping 13 matching lines @@
   context.copyDescription = NULL;
 
   fsevent_stream_ = FSEventStreamCreate(NULL, &FSEventsCallback, &context,
                                         watched_paths,
                                         start_event,
                                         kEventLatencySeconds,
                                         kFSEventStreamCreateFlagWatchRoot);
   FSEventStreamScheduleWithRunLoop(fsevent_stream_, CFRunLoopGetCurrent(),
                                    kCFRunLoopDefaultMode);
   if (!FSEventStreamStart(fsevent_stream_)) {
-    BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
+    message_loop()->PostTask(FROM_HERE,
         NewRunnableMethod(delegate_.get(),
                           &FilePathWatcher::Delegate::OnError));
   }
 }
 
 void FilePathWatcherImpl::DestroyEventStream() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(run_loop_message_loop()->BelongsToCurrentThread());
   FSEventStreamStop(fsevent_stream_);
   FSEventStreamUnscheduleFromRunLoop(fsevent_stream_, CFRunLoopGetCurrent(),
                                      kCFRunLoopDefaultMode);
   FSEventStreamRelease(fsevent_stream_);
   fsevent_stream_ = NULL;
 }
 
 }  // namespace
 
 FilePathWatcher::FilePathWatcher() {
   impl_ = new FilePathWatcherImpl();
 }