base/files/file_path_watcher_fsevents.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/files/file_path_watcher_fsevents.h"
   6
   7 #include <list>
   8
   9 #include "base/bind.h"
  10 #include "base/files/file_util.h"
  11 #include "base/lazy_instance.h"
  12 #include "base/logging.h"
  13 #include "base/mac/libdispatch_task_runner.h"
  14 #include "base/mac/scoped_cftyperef.h"
  15 #include "base/message_loop/message_loop.h"
  16
  17 namespace base {
  18
  19 namespace {
  20
  21 // The latency parameter passed to FSEventsStreamCreate().
  22 const CFAbsoluteTime kEventLatencySeconds = 0.3;
  23
  24 class FSEventsTaskRunner : public mac::LibDispatchTaskRunner {
  25  public:
  26    FSEventsTaskRunner()
  27        : mac::LibDispatchTaskRunner("org.chromium.FilePathWatcherFSEvents") {
  28    }
  29
  30  protected:
  31    virtual ~FSEventsTaskRunner() {}
  32 };
  33
  34 static LazyInstance<FSEventsTaskRunner>::Leaky g_task_runner =
  35     LAZY_INSTANCE_INITIALIZER;
  36
  37 // Resolve any symlinks in the path.
  38 FilePath ResolvePath(const FilePath& path) {
  39   const unsigned kMaxLinksToResolve = 255;
  40
  41   std::vector<FilePath::StringType> component_vector;
  42   path.GetComponents(&component_vector);
  43   std::list<FilePath::StringType>
  44       components(component_vector.begin(), component_vector.end());
  45
  46   FilePath result;
  47   unsigned resolve_count = 0;
  48   while (resolve_count < kMaxLinksToResolve && !components.empty()) {
  49     FilePath component(*components.begin());
  50     components.pop_front();
  51
  52     FilePath current;
  53     if (component.IsAbsolute()) {
  54       current = component;
  55     } else {
  56       current = result.Append(component);
  57     }
  58
  59     FilePath target;
  60     if (ReadSymbolicLink(current, &target)) {
  61       if (target.IsAbsolute())
  62         result.clear();
  63       std::vector<FilePath::StringType> target_components;
  64       target.GetComponents(&target_components);
  65       components.insert(components.begin(), target_components.begin(),
  66                         target_components.end());
  67       resolve_count++;
  68     } else {
  69       result = current;
  70     }
  71   }
  72
  73   if (resolve_count >= kMaxLinksToResolve)
  74     result.clear();
  75   return result;
  76 }
  77
  78 // The callback passed to FSEventStreamCreate().
  79 void FSEventsCallback(ConstFSEventStreamRef stream,
  80                       void* event_watcher, size_t num_events,
  81                       void* event_paths, const FSEventStreamEventFlags flags[],
  82                       const FSEventStreamEventId event_ids[]) {
  83   FilePathWatcherFSEvents* watcher =
  84       reinterpret_cast<FilePathWatcherFSEvents*>(event_watcher);
  85   DCHECK(g_task_runner.Get().RunsTasksOnCurrentThread());
  86
  87   bool root_changed = watcher->ResolveTargetPath();
  88   std::vector<FilePath> paths;
  89   FSEventStreamEventId root_change_at = FSEventStreamGetLatestEventId(stream);
  90   for (size_t i = 0; i < num_events; i++) {
  91     if (flags[i] & kFSEventStreamEventFlagRootChanged)
  92       root_changed = true;
  93     if (event_ids[i])
  94       root_change_at = std::min(root_change_at, event_ids[i]);
  95     paths.push_back(FilePath(
  96         reinterpret_cast<char**>(event_paths)[i]).StripTrailingSeparators());
  97   }
  98
  99   // Reinitialize the event stream if we find changes to the root. This is
 100   // necessary since FSEvents doesn't report any events for the subtree after
 101   // the directory to be watched gets created.
 102   if (root_changed) {
 103     // Resetting the event stream from within the callback fails (FSEvents spews
 104     // bad file descriptor errors), so post a task to do the reset.
 105     g_task_runner.Get().PostTask(
 106         FROM_HERE,
 107         Bind(&FilePathWatcherFSEvents::UpdateEventStream, watcher,
 108              root_change_at));
 109   }
 110
 111   watcher->OnFilePathsChanged(paths);
 112 }
 113
 114 }  // namespace
 115
 116 FilePathWatcherFSEvents::FilePathWatcherFSEvents() : fsevent_stream_(NULL) {
 117 }
 118
 119 void FilePathWatcherFSEvents::OnFilePathsChanged(
 120     const std::vector<FilePath>& paths) {
 121   if (!message_loop()->BelongsToCurrentThread()) {
 122     message_loop()->PostTask(
 123         FROM_HERE,
 124         Bind(&FilePathWatcherFSEvents::OnFilePathsChanged, this, paths));
 125     return;
 126   }
 127
 128   DCHECK(message_loop()->BelongsToCurrentThread());
 129   if (resolved_target_.empty())
 130     return;
 131
 132   for (size_t i = 0; i < paths.size(); i++) {
 133     if (resolved_target_.IsParent(paths[i]) || resolved_target_ == paths[i]) {
 134       callback_.Run(target_, false);
 135       return;
 136     }
 137   }
 138 }
 139
 140 bool FilePathWatcherFSEvents::Watch(const FilePath& path,
 141                                     bool recursive,
 142                                     const FilePathWatcher::Callback& callback) {
 143   DCHECK(resolved_target_.empty());
 144   DCHECK(MessageLoopForIO::current());
 145   DCHECK(!callback.is_null());
 146
 147   // This class could support non-recursive watches, but that is currently
 148   // left to FilePathWatcherKQueue.
 149   if (!recursive)
 150     return false;
 151
 152   set_message_loop(MessageLoopProxy::current());
 153   callback_ = callback;
 154   target_ = path;
 155
 156   FSEventStreamEventId start_event = FSEventsGetCurrentEventId();
 157   g_task_runner.Get().PostTask(
 158       FROM_HERE,
 159       Bind(&FilePathWatcherFSEvents::StartEventStream, this, start_event));
 160   return true;
 161 }
 162
 163 void FilePathWatcherFSEvents::Cancel() {
 164   if (callback_.is_null()) {
 165     // Watch was never called, so exit.
 166     set_cancelled();
 167     return;
 168   }
 169
 170   // Switch to the dispatch queue thread if necessary, so we can tear down
 171   // the event stream.
 172   if (!g_task_runner.Get().RunsTasksOnCurrentThread()) {
 173     g_task_runner.Get().PostTask(
 174         FROM_HERE,
 175         Bind(&FilePathWatcherFSEvents::CancelOnMessageLoopThread, this));
 176   } else {
 177     CancelOnMessageLoopThread();
 178   }
 179 }
 180
 181 void FilePathWatcherFSEvents::CancelOnMessageLoopThread() {
 182   // For all other implementations, the "message loop thread" is the IO thread,
 183   // as returned by message_loop(). This implementation, however, needs to
 184   // cancel pending work on the Dipatch Queue thread.
 185   DCHECK(g_task_runner.Get().RunsTasksOnCurrentThread());
 186
 187   set_cancelled();
 188   if (fsevent_stream_) {
 189     DestroyEventStream();
 190     callback_.Reset();
 191     target_.clear();
 192     resolved_target_.clear();
 193   }
 194 }
 195
 196 void FilePathWatcherFSEvents::UpdateEventStream(
 197     FSEventStreamEventId start_event) {
 198   DCHECK(g_task_runner.Get().RunsTasksOnCurrentThread());
 199
 200   // It can happen that the watcher gets canceled while tasks that call this
 201   // function are still in flight, so abort if this situation is detected.
 202   if (is_cancelled() || resolved_target_.empty())
 203     return;
 204
 205   if (fsevent_stream_)
 206     DestroyEventStream();
 207
 208   ScopedCFTypeRef<CFStringRef> cf_path(CFStringCreateWithCString(
 209       NULL, resolved_target_.value().c_str(), kCFStringEncodingMacHFS));
 210   ScopedCFTypeRef<CFStringRef> cf_dir_path(CFStringCreateWithCString(
 211       NULL, resolved_target_.DirName().value().c_str(),
 212       kCFStringEncodingMacHFS));
 213   CFStringRef paths_array[] = { cf_path.get(), cf_dir_path.get() };
 214   ScopedCFTypeRef<CFArrayRef> watched_paths(CFArrayCreate(
 215       NULL, reinterpret_cast<const void**>(paths_array), arraysize(paths_array),
 216       &kCFTypeArrayCallBacks));
 217
 218   FSEventStreamContext context;
 219   context.version = 0;
 220   context.info = this;
 221   context.retain = NULL;
 222   context.release = NULL;
 223   context.copyDescription = NULL;
 224
 225   fsevent_stream_ = FSEventStreamCreate(NULL, &FSEventsCallback, &context,
 226                                         watched_paths,
 227                                         start_event,
 228                                         kEventLatencySeconds,
 229                                         kFSEventStreamCreateFlagWatchRoot);
 230   FSEventStreamSetDispatchQueue(fsevent_stream_,
 231                                 g_task_runner.Get().GetDispatchQueue());
 232
 233   if (!FSEventStreamStart(fsevent_stream_))
 234     message_loop()->PostTask(FROM_HERE, Bind(callback_, target_, true));
 235 }
 236
 237 bool FilePathWatcherFSEvents::ResolveTargetPath() {
 238   DCHECK(g_task_runner.Get().RunsTasksOnCurrentThread());
 239   FilePath resolved = ResolvePath(target_).StripTrailingSeparators();
 240   bool changed = resolved != resolved_target_;
 241   resolved_target_ = resolved;
 242   if (resolved_target_.empty())
 243     message_loop()->PostTask(FROM_HERE, Bind(callback_, target_, true));
 244   return changed;
 245 }
 246
 247 void FilePathWatcherFSEvents::DestroyEventStream() {
 248   FSEventStreamStop(fsevent_stream_);
 249   FSEventStreamInvalidate(fsevent_stream_);
 250   FSEventStreamRelease(fsevent_stream_);
 251   fsevent_stream_ = NULL;
 252 }
 253
 254 void FilePathWatcherFSEvents::StartEventStream(
 255     FSEventStreamEventId start_event) {
 256   DCHECK(g_task_runner.Get().RunsTasksOnCurrentThread());
 257   ResolveTargetPath();
 258   UpdateEventStream(start_event);
 259 }
 260
 261 FilePathWatcherFSEvents::~FilePathWatcherFSEvents() {}
 262
 263 }  // namespace base