1 files changed, 36 insertions, 44 deletions

diff --git a/src/3rdParty/efsw/WatcherFSEvents.cpp b/src/3rdParty/efsw/WatcherFSEvents.cpp
index b562d3c..f963374 100755..100644
--- a/src/3rdParty/efsw/WatcherFSEvents.cpp
+++ b/src/3rdParty/efsw/WatcherFSEvents.cpp
@@ -8,22 +8,11 @@
 namespace efsw {
 
 WatcherFSEvents::WatcherFSEvents() :
-        Watcher(), FWatcher( NULL ), FSStream( NULL ), WatcherGen( NULL ), initializedAsync( false ) {}
-
-WatcherFSEvents::WatcherFSEvents( WatchID id, std::string directory, FileWatchListener* listener,
-                                                                  bool recursive, WatcherFSEvents* /*parent*/ ) :
-        Watcher( id, directory, listener, recursive ),
-        FWatcher( NULL ),
-        FSStream( NULL ),
-        WatcherGen( NULL ),
-        initializedAsync( false ) {}
+        Watcher(), FWatcher( NULL ), FSStream( NULL ), WatcherGen( NULL ) {}
 
 WatcherFSEvents::~WatcherFSEvents() {
         if ( NULL != FSStream ) {
-                if ( initializedAsync ) {
-                        FSEventStreamStop( FSStream );
-                }
-
+                FSEventStreamStop( FSStream );
                 FSEventStreamInvalidate( FSStream );
                 FSEventStreamRelease( FSStream );
         }
@@ -39,7 +28,9 @@ void WatcherFSEvents::init() {
         Uint32 streamFlags = kFSEventStreamCreateFlagNone;
 
         if ( FileWatcherFSEvents::isGranular() ) {
-                streamFlags = efswFSEventStreamCreateFlagFileEvents;
+                streamFlags = efswFSEventStreamCreateFlagFileEvents | efswFSEventStreamCreateFlagNoDefer |
+                                          efswFSEventStreamCreateFlagUseExtendedData |
+                                          efswFSEventStreamCreateFlagUseCFTypes;
         } else {
                 WatcherGen = new WatcherGeneric( ID, Directory, Listener, FWatcher.load(), Recursive );
         }
@@ -52,49 +43,49 @@ void WatcherFSEvents::init() {
         ctx.release = NULL;
         ctx.copyDescription = NULL;
 
+        dispatch_queue_t queue = dispatch_queue_create( NULL, NULL );
+
         FSStream =
                 FSEventStreamCreate( kCFAllocatorDefault, &FileWatcherFSEvents::FSEventCallback, &ctx,
-                                                         CFDirectoryArray, kFSEventStreamEventIdSinceNow, 0.25, streamFlags );
-        FWatcher.load()->mNeedInitMutex.lock();
-        FWatcher.load()->mNeedInit.push_back( this );
-        FWatcher.load()->mNeedInitMutex.unlock();
+                                                         CFDirectoryArray, kFSEventStreamEventIdSinceNow, 0., streamFlags );
 
-        CFRelease( CFDirectoryArray );
-        CFRelease( CFDirectory );
-}
+        FSEventStreamSetDispatchQueue( FSStream, queue );
 
-void WatcherFSEvents::initAsync() {
-        FSEventStreamScheduleWithRunLoop( FSStream, FWatcher.load()->mRunLoopRef.load(),
-                                                                          kCFRunLoopDefaultMode );
         FSEventStreamStart( FSStream );
-        initializedAsync = true;
+
+        CFRelease( CFDirectoryArray );
+        CFRelease( CFDirectory );
 }
 
 void WatcherFSEvents::sendFileAction( WatchID watchid, const std::string& dir,
                                                                           const std::string& filename, Action action,
                                                                           std::string oldFilename ) {
         Listener->handleFileAction( watchid, FileSystem::precomposeFileName( dir ),
-                                                                FileSystem::precomposeFileName( filename ), action, oldFilename );
+                                                                FileSystem::precomposeFileName( filename ), action,
+                                                                FileSystem::precomposeFileName( oldFilename ) );
 }
 
 void WatcherFSEvents::handleAddModDel( const Uint32& flags, const std::string& path,
-                                                                           std::string& dirPath, std::string& filePath ) {
-        if ( flags & efswFSEventStreamEventFlagItemCreated ) {
-                if ( FileInfo::exists( path ) ) {
-                        sendFileAction( ID, dirPath, filePath, Actions::Add );
-                }
+                                                                           std::string& dirPath, std::string& filePath, Uint64 inode ) {
+        if ( ( flags & efswFSEventStreamEventFlagItemCreated ) && FileInfo::exists( path ) &&
+                 ( !SanitizeEvents || FilesAdded.find( inode ) != FilesAdded.end() ) ) {
+                sendFileAction( ID, dirPath, filePath, Actions::Add );
+
+                if ( SanitizeEvents )
+                        FilesAdded.insert( inode );
         }
 
-        if ( flags & efswFSEventsModified ) {
+        if ( flags & ModifiedFlags ) {
                 sendFileAction( ID, dirPath, filePath, Actions::Modified );
         }
 
-        if ( flags & efswFSEventStreamEventFlagItemRemoved ) {
+        if ( ( flags & efswFSEventStreamEventFlagItemRemoved ) && !FileInfo::exists( path ) ) {
                 // Since i don't know the order, at least i try to keep the data consistent with the real
                 // state
-                if ( !FileInfo::exists( path ) ) {
-                        sendFileAction( ID, dirPath, filePath, Actions::Delete );
-                }
+                sendFileAction( ID, dirPath, filePath, Actions::Delete );
+
+                if ( SanitizeEvents )
+                        FilesAdded.erase( inode );
         }
 }
 
@@ -136,19 +127,20 @@ void WatcherFSEvents::handleActions( std::vector<FSEvent>& events ) {
                         // been added modified and erased, but i can't know if first was erased and then added
                         // and modified, or added, then modified and then erased. I don't know what they were
                         // thinking by doing this...
-                        efDEBUG( "Event in: %s - flags: %ld\n", event.Path.c_str(), event.Flags );
+                        efDEBUG( "Event in: %s - flags: 0x%x\n", event.Path.c_str(), event.Flags );
 
                         if ( event.Flags & efswFSEventStreamEventFlagItemRenamed ) {
                                 if ( ( i + 1 < esize ) &&
                                          ( events[i + 1].Flags & efswFSEventStreamEventFlagItemRenamed ) &&
-                                         ( events[i + 1].Id == event.Id + 1 ) ) {
+                                         ( events[i + 1].inode == event.inode ) ) {
                                         FSEvent& nEvent = events[i + 1];
                                         std::string newDir( FileSystem::pathRemoveFileName( nEvent.Path ) );
                                         std::string newFilepath( FileSystem::fileNameFromPath( nEvent.Path ) );
 
                                         if ( event.Path != nEvent.Path ) {
                                                 if ( dirPath == newDir ) {
-                                                        if ( !FileInfo::exists( event.Path ) ) {
+                                                        if ( !FileInfo::exists( event.Path ) ||
+                                                                 0 == strcasecmp( event.Path.c_str(), nEvent.Path.c_str() ) ) {
                                                                 sendFileAction( ID, dirPath, newFilepath, Actions::Moved,
                                                                                                 filePath );
                                                         } else {
@@ -159,12 +151,12 @@ void WatcherFSEvents::handleActions( std::vector<FSEvent>& events ) {
                                                         sendFileAction( ID, dirPath, filePath, Actions::Delete );
                                                         sendFileAction( ID, newDir, newFilepath, Actions::Add );
 
-                                                        if ( nEvent.Flags & efswFSEventsModified ) {
+                                                        if ( nEvent.Flags & ModifiedFlags ) {
                                                                 sendFileAction( ID, newDir, newFilepath, Actions::Modified );
                                                         }
                                                 }
                                         } else {
-                                                handleAddModDel( nEvent.Flags, nEvent.Path, dirPath, filePath );
+                                                handleAddModDel( nEvent.Flags, nEvent.Path, dirPath, filePath, event.inode );
                                         }
 
                                         if ( nEvent.Flags & ( efswFSEventStreamEventFlagItemCreated |
@@ -180,14 +172,14 @@ void WatcherFSEvents::handleActions( std::vector<FSEvent>& events ) {
                                 } else if ( FileInfo::exists( event.Path ) ) {
                                         sendFileAction( ID, dirPath, filePath, Actions::Add );
 
-                                        if ( event.Flags & efswFSEventsModified ) {
+                                        if ( event.Flags & ModifiedFlags ) {
                                                 sendFileAction( ID, dirPath, filePath, Actions::Modified );
                                         }
                                 } else {
                                         sendFileAction( ID, dirPath, filePath, Actions::Delete );
                                 }
                         } else {
-                                handleAddModDel( event.Flags, event.Path, dirPath, filePath );
+                                handleAddModDel( event.Flags, event.Path, dirPath, filePath, event.inode );
                         }
                 } else {
                         efDEBUG( "Directory: %s changed\n", event.Path.c_str() );
@@ -197,7 +189,7 @@ void WatcherFSEvents::handleActions( std::vector<FSEvent>& events ) {
 }
 
 void WatcherFSEvents::process() {
-        std::set<std::string>::iterator it = DirsChanged.begin();
+        std::unordered_set<std::string>::iterator it = DirsChanged.begin();
 
         for ( ; it != DirsChanged.end(); it++ ) {
                 if ( !FileWatcherFSEvents::isGranular() ) {