Fix file-watcher on mac by always starting/stopping through the run-loop thread.

runtime/bin/file_system_watcher_macos.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/globals.h"
 #if defined(TARGET_OS_MACOS)
 
 #include "bin/file_system_watcher.h"
 
 #include <errno.h>  // NOLINT
@@ skipping 37 matching lines @@
     uint32_t flags;
     char path[PATH_MAX];
   } data;
   uint8_t bytes[PATH_MAX + 8];
 };
 
 class FSEventsWatcher {
  public:
   class Node {
    public:
-    Node(intptr_t base_path_length, int read_fd, int write_fd, bool recursive)
-      : base_path_length_(base_path_length),
-        read_fd_(read_fd),
-        write_fd_(write_fd),
-        recursive_(recursive),
-        ref_(NULL) {}
+    Node(FSEventsWatcher* watcher, intptr_t base_path_length, int read_fd,
+         int write_fd, bool recursive)
+        : watcher_(watcher),
+          ready_(false),

[Søren Gjesse, 2014/02/06 13:04:19]

Indent

[Anders Johnsen, 2014/02/06 13:15:22]

Done.

+            base_path_length_(base_path_length),
+          read_fd_(read_fd),
+          write_fd_(write_fd),
+          recursive_(recursive),
+          ref_(NULL) {}
 
     ~Node() {
       close(write_fd_);
-      FSEventStreamInvalidate(ref_);
-      FSEventStreamRelease(ref_);
     }
 
     void set_ref(FSEventStreamRef ref) {
       ref_ = ref;
     }
 
+    static void StartCallback(CFRunLoopTimerRef timer, void* info) {
+      Node* node = reinterpret_cast<Node*>(info);
+      FSEventStreamScheduleWithRunLoop(
+          node->ref_,
+          node->watcher_->run_loop_,
+          kCFRunLoopDefaultMode);
+      FSEventStreamStart(node->ref_);
+      FSEventStreamFlushSync(node->ref_);
+      node->watcher_->monitor_.Enter();
+      node->ready_ = true;
+      node->watcher_->monitor_.Notify();
+      node->watcher_->monitor_.Exit();
+    }
+
     void Start() {

[Søren Gjesse, 2014/02/06 13:04:19]

ASSERT(!ready_)

[Anders Johnsen, 2014/02/06 13:15:22]

Done.

-      FSEventStreamStart(ref_);
+      CFRunLoopTimerContext context;
+      memset(&context, 0, sizeof(context));
+      context.info = this;
+      CFRunLoopTimerRef timer = CFRunLoopTimerCreate(
+          NULL, 0, 0, 0, 0, StartCallback, &context);
+      CFRunLoopAddTimer(watcher_->run_loop_, timer, kCFRunLoopCommonModes);
+      watcher_->monitor_.Enter();
+      while (!ready_) {
+        watcher_->monitor_.Wait(Monitor::kNoTimeout);
+      }
+      watcher_->monitor_.Exit();
+    }
+
+    static void StopCallback(CFRunLoopTimerRef timer, void* info) {
+      Node* node = reinterpret_cast<Node*>(info);
+      FSEventStreamStop(node->ref_);
+      FSEventStreamInvalidate(node->ref_);
+      FSEventStreamRelease(node->ref_);
+      node->watcher_->monitor_.Enter();
+      node->ready_ = false;
+      node->watcher_->monitor_.Notify();
+      node->watcher_->monitor_.Exit();
     }
 
     void Stop() {

[Søren Gjesse, 2014/02/06 13:04:19]

ASSERT(ready_)

[Anders Johnsen, 2014/02/06 13:15:22]

Done.

-      FSEventStreamStop(ref_);
+      CFRunLoopTimerContext context;
+      memset(&context, 0, sizeof(context));
+      context.info = this;
+      CFRunLoopTimerRef timer = CFRunLoopTimerCreate(
+          NULL, 0, 0, 0, 0, StopCallback, &context);
+      CFRunLoopAddTimer(watcher_->run_loop_, timer, kCFRunLoopCommonModes);
+      watcher_->monitor_.Enter();
+      while (ready_) {
+        watcher_->monitor_.Wait(Monitor::kNoTimeout);
+      }
+      watcher_->monitor_.Exit();
     }
 
+    bool ready() const { return ready_; }
     intptr_t base_path_length() const { return base_path_length_; }
     int read_fd() const { return read_fd_; }
     int write_fd() const { return write_fd_; }
     bool recursive() const { return recursive_; }
 
    private:
+    FSEventsWatcher* watcher_;
+    bool ready_;
     intptr_t base_path_length_;
     int read_fd_;
     int write_fd_;
     bool recursive_;
     FSEventStreamRef ref_;
   };
 
   FSEventsWatcher() : run_loop_(0) {
     Thread::Start(Run, reinterpret_cast<uword>(this));
   }
@@ skipping 37 matching lines @@
     int fds[2];
     VOID_TEMP_FAILURE_RETRY(pipe(fds));
     Socket::SetNonBlocking(fds[0]);
     Socket::SetBlocking(fds[1]);
 
     char base_path[PATH_MAX];
     realpath(path, base_path);
     CFStringRef path_ref = CFStringCreateWithCString(
         NULL, base_path, kCFStringEncodingUTF8);
 
-    Node* node = new Node(strlen(base_path), fds[0], fds[1], recursive);
+    Node* node = new Node(this, strlen(base_path), fds[0], fds[1], recursive);
 
     FSEventStreamContext context;
     context.version = 0;
     context.info = reinterpret_cast<void*>(node);
     context.retain = NULL;
     context.release = NULL;
     context.copyDescription = NULL;
     FSEventStreamRef ref = FSEventStreamCreate(
         NULL,
         Callback,
         &context,
         CFArrayCreate(NULL, reinterpret_cast<const void**>(&path_ref), 1, NULL),
         kFSEventStreamEventIdSinceNow,
         0.10,
         kFSEventStreamCreateFlagNoDefer | kFSEventStreamCreateFlagFileEvents);
 
     node->set_ref(ref);
 
-    FSEventStreamScheduleWithRunLoop(
-        ref,
-        run_loop_,
-        kCFRunLoopDefaultMode);
-
     return node;
   }
 
  private:
   static void Callback(ConstFSEventStreamRef ref,
                        void* client,
                        size_t num_events,
                        void* event_paths,
                        const FSEventStreamEventFlags event_flags[],
                        const FSEventStreamEventId event_ids[]) {
     Node* node = reinterpret_cast<Node*>(client);

[Søren Gjesse, 2014/02/06 13:04:19]

Need to protect access to ready with the monitor.

[Anders Johnsen, 2014/02/06 13:15:22]

As discussed offline, is on same thread as run-loop.

+    if (!node->ready()) return;
     for (size_t i = 0; i < num_events; i++) {
       char *path = reinterpret_cast<char**>(event_paths)[i];
       FSEvent event;
       event.data.exists = File::GetType(path, false) != File::kDoesNotExist;
       path += node->base_path_length();
       // If path is longer the base, skip next character ('/').
       if (path[0] != '\0') path += 1;
       if (!node->recursive() && strstr(path, "/") != NULL) continue;
       event.data.flags = event_flags[i];
       memmove(event.data.path, path, strlen(path) + 1);
       write(node->write_fd(), event.bytes, sizeof(event));
     }
   }
 
   Monitor monitor_;
   CFRunLoopRef run_loop_;
 };
 
 
 #define kCFCoreFoundationVersionNumber10_7      635.00
 bool FileSystemWatcher::IsSupported() {
   return kCFCoreFoundationVersionNumber >= kCFCoreFoundationVersionNumber10_7;
 }
 
 
 intptr_t FileSystemWatcher::Init() {
   FSEventsWatcher* watcher = new FSEventsWatcher();
   watcher->monitor().Enter();
   while (!watcher->has_run_loop()) {
-    watcher->monitor().Wait(1);
+    watcher->monitor().Wait(Monitor::kNoTimeout);
   }
   watcher->monitor().Exit();
   return reinterpret_cast<intptr_t>(watcher);
 }
 
 
 void FileSystemWatcher::Close(intptr_t id) {
   FSEventsWatcher* watcher = reinterpret_cast<FSEventsWatcher*>(id);
   delete watcher;
 }
@@ skipping 70 matching lines @@
   }
   return events;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_MACOS)