Rewrite file-system-watcher to better handle the different system APIs.

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 24 matching lines @@
   kFSEventStreamEventFlagItemIsFile = 0x00010000,
   kFSEventStreamEventFlagItemIsDir = 0x00020000,
   kFSEventStreamEventFlagItemIsSymlink = 0x00040000
 };
 #endif
 
 
 namespace dart {
 namespace bin {
 
-static Mutex* watcher_mutex = new Mutex();
-static Monitor* watcher_monitor = new Monitor();
-
-class FSEventsWatcher;
-static FSEventsWatcher* watcher = NULL;
-
 union FSEvent {
   struct {
     uint32_t exists;
     uint32_t flags;
     char path[PATH_MAX];
   } data;
   uint8_t bytes[PATH_MAX + 8];
 };
 
 class FSEventsWatcher {
@@ skipping 31 matching lines @@
     bool recursive() const { return recursive_; }
 
    private:
     intptr_t base_path_length_;
     int read_fd_;
     int write_fd_;
     bool recursive_;
     FSEventStreamRef ref_;
   };
 
-  FSEventsWatcher() : run_loop_(0), users_(0) {
+  FSEventsWatcher() : run_loop_(0) {
     Thread::Start(Run, reinterpret_cast<uword>(this));
   }
 
   ~FSEventsWatcher() {
     CFRunLoopStop(run_loop_);
   }
 
+  Monitor& monitor() { return monitor_; }
+
+  bool has_run_loop() const { return run_loop_ != NULL; }
+
   static void TimerCallback(CFRunLoopTimerRef timer, void* context) {
     // Dummy callback to keep RunLoop alive.
   }
 
   static void Run(uword arg) {
     FSEventsWatcher* watcher = reinterpret_cast<FSEventsWatcher*>(arg);
     watcher->run_loop_ = CFRunLoopGetCurrent();
 
     // Notify, as the run-loop is set.
-    watcher_monitor->Enter();
-    watcher_monitor->Notify();
-    watcher_monitor->Exit();
+    watcher->monitor().Enter();
+    watcher->monitor().Notify();
+    watcher->monitor().Exit();
 
     CFRunLoopTimerRef timer = CFRunLoopTimerCreate(
         NULL,
         CFAbsoluteTimeGetCurrent() + 1,
         1,
         0,
         0,
         TimerCallback,
         NULL);
 
     CFRunLoopAddTimer(watcher->run_loop_, timer, kCFRunLoopCommonModes);
 
     CFRunLoopRun();
   }
 
-  static void Increment() {
-    if (watcher == NULL) {
-      watcher_monitor->Enter();
-      watcher = new FSEventsWatcher();
-      while (watcher->run_loop_ == NULL) {
-        watcher_monitor->Wait(Monitor::kNoTimeout);
-      }
-      watcher_monitor->Exit();
-    }
-    watcher->users_++;
-  }
-
-  static void Decrement() {
-    ASSERT(watcher->users_ > 0);
-    watcher->users_--;
-    if (watcher->users_ == 0) {
-      delete watcher;
-      watcher = NULL;
-    }
-  }
-
   Node* AddPath(const char* path, int events, bool recursive) {
     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);
@@ skipping 40 matching lines @@
       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_;
-  int users_;
 };
 
 
 #define kCFCoreFoundationVersionNumber10_7      635.00
 bool FileSystemWatcher::IsSupported() {
   return kCFCoreFoundationVersionNumber >= kCFCoreFoundationVersionNumber10_7;
 }
 
 
-intptr_t FileSystemWatcher::WatchPath(const char* path,
+intptr_t FileSystemWatcher::Init() {
+  FSEventsWatcher* watcher = new FSEventsWatcher();
+  watcher->monitor().Enter();
+  while (!watcher->has_run_loop()) {
+    watcher->monitor().Wait(1);
+  }
+  watcher->monitor().Exit();
+  return reinterpret_cast<intptr_t>(watcher);
+}
+
+
+void FileSystemWatcher::Close(intptr_t id) {
+  FSEventsWatcher* watcher = reinterpret_cast<FSEventsWatcher*>(id);
+  delete watcher;
+}
+
+
+intptr_t FileSystemWatcher::WatchPath(intptr_t id,
+                                      const char* path,
                                       int events,
                                       bool recursive) {
-  MutexLocker lock(watcher_mutex);
-  FSEventsWatcher::Increment();
-
+  FSEventsWatcher* watcher = reinterpret_cast<FSEventsWatcher*>(id);
   FSEventsWatcher::Node* node = watcher->AddPath(path, events, recursive);
   node->Start();
   return reinterpret_cast<intptr_t>(node);
 }
 
 
-void FileSystemWatcher::UnwatchPath(intptr_t id) {
-  MutexLocker lock(watcher_mutex);
-
-  FSEventsWatcher::Node* node = reinterpret_cast<FSEventsWatcher::Node*>(id);
+void FileSystemWatcher::UnwatchPath(intptr_t id, intptr_t path_id) {
+  USE(id);
+  FSEventsWatcher::Node* node =
+      reinterpret_cast<FSEventsWatcher::Node*>(path_id);
   node->Stop();
   delete node;
-
-  FSEventsWatcher::Decrement();
 }
 
 
-intptr_t FileSystemWatcher::GetSocketId(intptr_t id) {
-  return reinterpret_cast<FSEventsWatcher::Node*>(id)->read_fd();
+intptr_t FileSystemWatcher::GetSocketId(intptr_t id, intptr_t path_id) {
+  return reinterpret_cast<FSEventsWatcher::Node*>(path_id)->read_fd();
 }
 
 
-Dart_Handle FileSystemWatcher::ReadEvents(intptr_t id) {
-  intptr_t fd = GetSocketId(id);
+Dart_Handle FileSystemWatcher::ReadEvents(intptr_t id, intptr_t path_id) {
+  intptr_t fd = GetSocketId(id, path_id);
   intptr_t avail = FDUtils::AvailableBytes(fd);
   int count = avail / sizeof(FSEvent);
   if (count <= 0) return Dart_NewList(0);
   Dart_Handle events = Dart_NewList(count);
   FSEvent e;
   for (int i = 0; i < count; i++) {
     intptr_t bytes = TEMP_FAILURE_RETRY(read(fd, e.bytes, sizeof(e)));
     if (bytes < 0) {
       return DartUtils::NewDartOSError();
     }
     size_t path_len = strlen(e.data.path);
-    Dart_Handle event = Dart_NewList(4);
+    Dart_Handle event = Dart_NewList(5);
     int flags = e.data.flags;
     int mask = 0;
     if (flags & kFSEventStreamEventFlagItemRenamed) {
       if (path_len == 0) {
         // The moved path is the path being watched.
         mask |= kDeleteSelf;
       } else {
         mask |= e.data.exists ? kCreate : kDelete;
       }
     }
     if (flags & kFSEventStreamEventFlagItemModified) mask |= kModifyContent;
     if (flags & kFSEventStreamEventFlagItemXattrMod) mask |= kModefyAttribute;
     if (flags & kFSEventStreamEventFlagItemCreated) mask |= kCreate;
     if (flags & kFSEventStreamEventFlagItemIsDir) mask |= kIsDir;
     if (flags & kFSEventStreamEventFlagItemRemoved) {
       if (path_len == 0) {
         // The removed path is the path being watched.
         mask |= kDeleteSelf;
       } else {
         mask |= kDelete;
       }
     }
     Dart_ListSetAt(event, 0, Dart_NewInteger(mask));
     Dart_ListSetAt(event, 1, Dart_NewInteger(1));
     Dart_ListSetAt(event, 2, Dart_NewStringFromUTF8(
         reinterpret_cast<uint8_t*>(e.data.path), path_len));
     Dart_ListSetAt(event, 3, Dart_NewBoolean(true));
+    Dart_ListSetAt(event, 4, Dart_NewInteger(path_id));
     Dart_ListSetAt(events, i, event);
   }
   return events;
 }
 
 }  // namespace bin
 }  // namespace dart
 
 #endif  // defined(TARGET_OS_MACOS)