Support more than 63 handles in QWindowsFileSystemWatcher

We spawn/stop additional threads as needed to watch any number of
files/directories. The old logic of using just one handle per watched
directory (regardless of how many files we watch in it.) is preserved.
In the worst case a thread is started per 63 files to watch.

This enabled Qt Creator to watch all .pro and .pri files even while
having qt's projects.pro and qtcreator.pro open.

Task-number: 185259, 253014
Reviewed-by: denis

3 files changed, 304 insertions, 181 deletions

diff --git a/src/corelib/io/qfilesystemwatcher_p.h b/src/corelib/io/qfilesystemwatcher_p.h
index 850e150..83be197 100644
--- a/src/corelib/io/qfilesystemwatcher_p.h
+++ b/src/corelib/io/qfilesystemwatcher_p.h
@@ -69,13 +69,14 @@ class QFileSystemWatcherEngine : public QThread
     Q_OBJECT
 
 protected:
-    inline QFileSystemWatcherEngine()
+    inline QFileSystemWatcherEngine(bool move = true)
     {
-        moveToThread(this);
+        if (move)
+            moveToThread(this);
     }
 
 public:
-    // fills \a files and \a directires with the \a paths it could
+    // fills \a files and \a directories with the \a paths it could
     // watch, and returns a list of paths this engine could not watch
     virtual QStringList addPaths(const QStringList &paths,
                                  QStringList *files,
diff --git a/src/corelib/io/qfilesystemwatcher_win.cpp b/src/corelib/io/qfilesystemwatcher_win.cpp
index c15b1d2..9eeef02 100644
--- a/src/corelib/io/qfilesystemwatcher_win.cpp
+++ b/src/corelib/io/qfilesystemwatcher_win.cpp
@@ -53,23 +53,268 @@
 
 QT_BEGIN_NAMESPACE
 
+void QWindowsFileSystemWatcherEngine::stop()
+{
+    foreach(QWindowsFileSystemWatcherEngineThread *thread, threads)
+        thread->stop();
+}
+
 QWindowsFileSystemWatcherEngine::QWindowsFileSystemWatcherEngine()
-    : msg(0)
+    : QFileSystemWatcherEngine(false)
 {
-    if (HANDLE h = CreateEvent(0, false, false, 0)) {
-        handles.reserve(MAXIMUM_WAIT_OBJECTS);
-        handles.append(h);
-    }
 }
 
 QWindowsFileSystemWatcherEngine::~QWindowsFileSystemWatcherEngine()
 {
-    if (handles.isEmpty())
+    if (threads.isEmpty())
         return;
 
-    stop();
-    wait();
+    foreach(QWindowsFileSystemWatcherEngineThread *thread, threads) {
+        thread->stop();
+        thread->wait();
+        delete thread;
+    }
+}
+
+QStringList QWindowsFileSystemWatcherEngine::addPaths(const QStringList &paths,
+                                                       QStringList *files,
+                                                       QStringList *directories)
+{
+    // qDebug()<<"Adding"<<paths.count()<<"to existing"<<(files->count() + directories->count())<<"watchers";
+    QStringList p = paths;
+    QMutableListIterator<QString> it(p);
+    while (it.hasNext()) {
+        QString path = it.next();
+        QString normalPath = path;
+        if ((normalPath.endsWith(QLatin1Char('/')) || normalPath.endsWith(QLatin1Char('\\')))
+#ifdef Q_OS_WINCE
+            && normalPath.size() > 1)
+#else
+            )
+#endif
+        normalPath.chop(1);
+        QFileInfo fileInfo(normalPath.toLower());
+        if (!fileInfo.exists())
+            continue;
+
+        bool isDir = fileInfo.isDir();
+        if (isDir) {
+            if (directories->contains(path))
+                continue;
+        } else {
+            if (files->contains(path))
+                continue;
+        }
+
+        // qDebug()<<"Looking for a thread/handle for"<<normalPath;
+
+        const QString absolutePath = isDir ? fileInfo.absoluteFilePath() : fileInfo.absolutePath();
+        const uint flags = isDir
+                           ? (FILE_NOTIFY_CHANGE_DIR_NAME
+                              | FILE_NOTIFY_CHANGE_FILE_NAME)
+                           : (FILE_NOTIFY_CHANGE_DIR_NAME
+                              | FILE_NOTIFY_CHANGE_FILE_NAME
+                              | FILE_NOTIFY_CHANGE_ATTRIBUTES
+                              | FILE_NOTIFY_CHANGE_SIZE
+                              | FILE_NOTIFY_CHANGE_LAST_WRITE
+                              | FILE_NOTIFY_CHANGE_SECURITY);
+
+        QWindowsFileSystemWatcherEngine::PathInfo pathInfo;
+        pathInfo.absolutePath = absolutePath;
+        pathInfo.isDir = isDir;
+        pathInfo.path = path;
+        pathInfo = fileInfo;
+
+        // Look for a thread
+        QWindowsFileSystemWatcherEngineThread *thread = 0;
+        QWindowsFileSystemWatcherEngine::Handle handle;
+        QList<QWindowsFileSystemWatcherEngineThread *>::const_iterator jt, end;
+        end = threads.constEnd();
+        for(jt = threads.constBegin(); jt != end; ++jt) {
+            thread = *jt;
+            QMutexLocker locker(&(thread->mutex));
+
+            handle = thread->handleForDir.value(absolutePath);
+            if (handle.handle != INVALID_HANDLE_VALUE && handle.flags == flags) {
+                // found a thread now insert...
+                // qDebug()<<"  Found a thread"<<thread;
+
+                QHash<QString, QWindowsFileSystemWatcherEngine::PathInfo> &h
+                        = thread->pathInfoForHandle[handle.handle];
+                if (!h.contains(fileInfo.absoluteFilePath())) {
+                    thread->pathInfoForHandle[handle.handle].insert(fileInfo.absoluteFilePath(), pathInfo);
+                    if (isDir)
+                        directories->append(path);
+                    else
+                        files->append(path);
+                }
+                it.remove();
+                thread->wakeup();
+                break;
+            }
+        }
+
+        // no thread found, first create a handle
+        if (handle.handle == INVALID_HANDLE_VALUE || handle.flags != flags) {
+            // qDebug()<<"  No thread found";
+            // Volume and folder paths need a trailing slash for proper notification
+            // (e.g. "c:" -> "c:/").
+            const QString effectiveAbsolutePath =
+                    isDir ? (absolutePath + QLatin1Char('/')) : absolutePath;
+
+            handle.handle = FindFirstChangeNotification((wchar_t*) QDir::toNativeSeparators(effectiveAbsolutePath).utf16(), false, flags);
+            handle.flags = flags;
+            if (handle.handle == INVALID_HANDLE_VALUE)
+                continue;
+
+            // now look for a thread to insert
+            bool found = false;
+            foreach(QWindowsFileSystemWatcherEngineThread *thread, threads) {
+                QMutexLocker(&(thread->mutex));
+                if (thread->handles.count() < MAXIMUM_WAIT_OBJECTS) {
+                    // qDebug() << "  Added handle" << handle.handle << "for" << absolutePath << "to watch" << fileInfo.absoluteFilePath();
+                    // qDebug()<< "  to existing thread"<<thread;
+                    thread->handles.append(handle.handle);
+                    thread->handleForDir.insert(absolutePath, handle);
+
+                    thread->pathInfoForHandle[handle.handle].insert(fileInfo.absoluteFilePath(), pathInfo);
+                    if (isDir)
+                        directories->append(path);
+                    else
+                        files->append(path);
+
+                    it.remove();
+                    found = true;
+                    thread->wakeup();
+                    break;
+                }
+            }
+            if (!found) {
+                QWindowsFileSystemWatcherEngineThread *thread = new QWindowsFileSystemWatcherEngineThread();
+                //qDebug()<<"  ###Creating new thread"<<thread<<"("<<(threads.count()+1)<<"threads)";
+                thread->handles.append(handle.handle);
+                thread->handleForDir.insert(absolutePath, handle);
+
+                thread->pathInfoForHandle[handle.handle].insert(fileInfo.absoluteFilePath(), pathInfo);
+                if (isDir)
+                    directories->append(path);
+                else
+                    files->append(path);
+
+                connect(thread, SIGNAL(fileChanged(const QString &, bool)),
+                        this, SIGNAL(fileChanged(const QString &, bool)));
+                connect(thread, SIGNAL(directoryChanged(const QString &, bool)),
+                        this, SIGNAL(directoryChanged(const QString &, bool)));
+                
+                thread->msg = '@';
+                thread->start();
+                threads.append(thread);
+                it.remove();
+            }
+        }
+    }
+    return p;
+}
+
+QStringList QWindowsFileSystemWatcherEngine::removePaths(const QStringList &paths,
+                                                          QStringList *files,
+                                                          QStringList *directories)
+{
+    // qDebug()<<"removePaths"<<paths;
+    QStringList p = paths;
+    QMutableListIterator<QString> it(p);
+    while (it.hasNext()) {
+        QString path = it.next();
+        QString normalPath = path;
+        if (normalPath.endsWith(QLatin1Char('/')) || normalPath.endsWith(QLatin1Char('\\')))
+            normalPath.chop(1);
+        QFileInfo fileInfo(normalPath.toLower());
+        // qDebug()<<"removing"<<normalPath;
+        QString absolutePath = fileInfo.absoluteFilePath();
+        QList<QWindowsFileSystemWatcherEngineThread *>::iterator jt, end;
+        end = threads.end();
+        for(jt = threads.begin(); jt!= end; ++jt) {
+            QWindowsFileSystemWatcherEngineThread *thread = *jt;
+            if (*jt == 0)
+                continue;
+
+            QMutexLocker locker(&(thread->mutex));
+
+            QWindowsFileSystemWatcherEngine::Handle handle = thread->handleForDir.value(absolutePath);
+            if (handle.handle == INVALID_HANDLE_VALUE) {
+                // perhaps path is a file?
+                absolutePath = fileInfo.absolutePath();
+                handle = thread->handleForDir.value(absolutePath);
+            }
+            if (handle.handle != INVALID_HANDLE_VALUE) {
+                QHash<QString, QWindowsFileSystemWatcherEngine::PathInfo> &h =
+                        thread->pathInfoForHandle[handle.handle];
+                if (h.remove(fileInfo.absoluteFilePath())) {
+                    // ###
+                    files->removeAll(path);
+                    directories->removeAll(path);
+
+                    if (h.isEmpty()) {
+                        // qDebug() << "Closing handle" << handle.handle;
+                        FindCloseChangeNotification(handle.handle);    // This one might generate a notification
+
+                        int indexOfHandle = thread->handles.indexOf(handle.handle);
+                        Q_ASSERT(indexOfHandle != -1);
+                        thread->handles.remove(indexOfHandle);
+
+                        thread->handleForDir.remove(absolutePath);
+                        // h is now invalid
+
+                        it.remove();
+
+                        if (thread->handleForDir.isEmpty()) {
+                            // qDebug()<<"Stopping thread "<<thread;
+                            locker.unlock();
+                            thread->stop();
+                            thread->wait();
+                            locker.relock();
+                            // We can't delete the thread until the mutex locker is
+                            // out of scope
+                        }
+                    }
+                }
+                // Found the file, go to next one
+                break;
+            }
+        }
+    }
+
+    // Remove all threads that we stopped
+    QList<QWindowsFileSystemWatcherEngineThread *>::iterator jt, end;
+    end = threads.end();
+    for(jt = threads.begin(); jt != end; ++jt) {
+        if (!(*jt)->isRunning()) {
+            delete *jt;
+            *jt = 0;
+        }
+    }
+
+    threads.removeAll(0);
+    return p;
+}
+
+///////////
+// QWindowsFileSystemWatcherEngineThread
+///////////
 
+QWindowsFileSystemWatcherEngineThread::QWindowsFileSystemWatcherEngineThread()
+        : msg(0)
+{
+    if (HANDLE h = CreateEvent(0, false, false, 0)) {
+        handles.reserve(MAXIMUM_WAIT_OBJECTS);
+        handles.append(h);
+    }
+    moveToThread(this);
+}
+
+
+QWindowsFileSystemWatcherEngineThread::~QWindowsFileSystemWatcherEngineThread()
+{
     CloseHandle(handles.at(0));
     handles[0] = INVALID_HANDLE_VALUE;
 
@@ -80,13 +325,13 @@ QWindowsFileSystemWatcherEngine::~QWindowsFileSystemWatcherEngine()
     }
 }
 
-void QWindowsFileSystemWatcherEngine::run()
+void QWindowsFileSystemWatcherEngineThread::run()
 {
     QMutexLocker locker(&mutex);
     forever {
         QVector<HANDLE> handlesCopy = handles;
         locker.unlock();
-        // qDebug() << "QWindowsFileSystemWatcherEngine: waiting on" << handlesCopy.count() << "handles";
+        // qDebug() << "QWindowsFileSystemWatcherThread"<<this<<"waiting on" << handlesCopy.count() << "handles";
         DWORD r = WaitForMultipleObjects(handlesCopy.count(), handlesCopy.constData(), false, INFINITE);
         locker.relock();
         do {
@@ -94,7 +339,7 @@ void QWindowsFileSystemWatcherEngine::run()
                 int m = msg;
                 msg = 0;
                 if (m == 'q') {
-                    // qDebug() << "thread told to quit";
+                    // qDebug() << "thread"<<this<<"told to quit";
                     return;
                 }
                 if (m != '@')  {
@@ -109,15 +354,15 @@ void QWindowsFileSystemWatcherEngine::run()
                 // When removing a path, FindCloseChangeNotification might actually fire a notification
                 // for some reason, so we must check if the handle exist in the handles vector
                 if (handles.contains(handle)) {
-                    // qDebug("Acknowledged handle: %d, %p", at, handle);
+                    // qDebug()<<"thread"<<this<<"Acknowledged handle:"<<at<<handle;
                     if (!FindNextChangeNotification(handle)) {
-                        qErrnoWarning("QFileSystemWatcher: FindNextChangeNotification failed");
+                        qErrnoWarning("QFileSystemWatcher: FindNextChangeNotification failed!!");
                     }
 
-                    QHash<QString, PathInfo> &h = pathInfoForHandle[handle];
-                    QMutableHashIterator<QString, PathInfo> it(h);
+                    QHash<QString, QWindowsFileSystemWatcherEngine::PathInfo> &h = pathInfoForHandle[handle];
+                    QMutableHashIterator<QString, QWindowsFileSystemWatcherEngine::PathInfo> it(h);
                     while (it.hasNext()) {
-                        QHash<QString, PathInfo>::iterator x = it.next();
+                        QHash<QString, QWindowsFileSystemWatcherEngine::PathInfo>::iterator x = it.next();
                         QString absolutePath = x.value().absolutePath;
                         QFileInfo fileInfo(x.value().path);
                         // qDebug() << "checking" << x.key();
@@ -162,160 +407,14 @@ void QWindowsFileSystemWatcherEngine::run()
     }
 }
 
-QStringList QWindowsFileSystemWatcherEngine::addPaths(const QStringList &paths,
-                                                      QStringList *files,
-                                                      QStringList *directories)
-{
-    if (handles.isEmpty() || handles.count() == MAXIMUM_WAIT_OBJECTS)
-        return paths;
-
-    QMutexLocker locker(&mutex);
-
-    QStringList p = paths;
-    QMutableListIterator<QString> it(p);
-    while (it.hasNext()) {
-        QString path = it.next();
-        QString normalPath = path;
-        if ((normalPath.endsWith(QLatin1Char('/')) || normalPath.endsWith(QLatin1Char('\\')))
-#ifdef Q_OS_WINCE
-            && normalPath.size() > 1)
-#else
-            )
-#endif
-            normalPath.chop(1);
-        QFileInfo fileInfo(normalPath.toLower());
-        if (!fileInfo.exists())
-            continue;
-
-        bool isDir = fileInfo.isDir();
-        if (isDir) {
-            if (directories->contains(path))
-                continue;
-        } else {
-            if (files->contains(path))
-                continue;
-        }
 
-        const QString absolutePath = isDir ? fileInfo.absoluteFilePath() : fileInfo.absolutePath();
-        const uint flags = isDir
-            ? (FILE_NOTIFY_CHANGE_DIR_NAME
-               | FILE_NOTIFY_CHANGE_FILE_NAME)
-            : (FILE_NOTIFY_CHANGE_DIR_NAME
-               | FILE_NOTIFY_CHANGE_FILE_NAME
-               | FILE_NOTIFY_CHANGE_ATTRIBUTES
-               | FILE_NOTIFY_CHANGE_SIZE
-               | FILE_NOTIFY_CHANGE_LAST_WRITE
-               | FILE_NOTIFY_CHANGE_SECURITY);
-
-        Handle handle = handleForDir.value(absolutePath);
-        if (handle.handle == INVALID_HANDLE_VALUE || handle.flags != flags) {
-            // Volume and folder paths need a trailing slash for proper notification
-            // (e.g. "c:" -> "c:/").
-            const QString effectiveAbsolutePath =
-                isDir ? (absolutePath + QLatin1Char('/')) : absolutePath;
-
-            handle.handle = FindFirstChangeNotification((wchar_t*) QDir::toNativeSeparators(effectiveAbsolutePath).utf16(), false, flags);
-            handle.flags = flags;
-            if (handle.handle == INVALID_HANDLE_VALUE)
-                continue;
-            // qDebug() << "Added handle" << handle << "for" << absolutePath << "to watch" << fileInfo.absoluteFilePath();
-            handles.append(handle.handle);
-            handleForDir.insert(absolutePath, handle);
-        }
-
-        PathInfo pathInfo;
-        pathInfo.absolutePath = absolutePath;
-        pathInfo.isDir = isDir;
-        pathInfo.path = path;
-        pathInfo = fileInfo;
-        QHash<QString, PathInfo> &h = pathInfoForHandle[handle.handle];
-        if (!h.contains(fileInfo.absoluteFilePath())) {
-            pathInfoForHandle[handle.handle].insert(fileInfo.absoluteFilePath(), pathInfo);
-            if (isDir)
-                directories->append(path);
-            else
-                files->append(path);
-        }
-
-        it.remove();
-    }
-
-    if (!isRunning()) {
-        msg = '@';
-        start();
-    } else {
-        wakeup();
-    }
-
-    return p;
-}
-
-QStringList QWindowsFileSystemWatcherEngine::removePaths(const QStringList &paths,
-                                                         QStringList *files,
-                                                         QStringList *directories)
-{
-    QMutexLocker locker(&mutex);
-
-    QStringList p = paths;
-    QMutableListIterator<QString> it(p);
-    while (it.hasNext()) {
-        QString path = it.next();
-        QString normalPath = path;
-        if (normalPath.endsWith(QLatin1Char('/')) || normalPath.endsWith(QLatin1Char('\\')))
-            normalPath.chop(1);
-        QFileInfo fileInfo(normalPath.toLower());
-
-        QString absolutePath = fileInfo.absoluteFilePath();
-        Handle handle = handleForDir.value(absolutePath);
-        if (handle.handle == INVALID_HANDLE_VALUE) {
-            // perhaps path is a file?
-            absolutePath = fileInfo.absolutePath();
-            handle = handleForDir.value(absolutePath);
-            if (handle.handle == INVALID_HANDLE_VALUE)
-                continue;
-        }
-
-        QHash<QString, PathInfo> &h = pathInfoForHandle[handle.handle];
-        if (h.remove(fileInfo.absoluteFilePath())) {
-            // ###
-            files->removeAll(path);
-            directories->removeAll(path);
-
-            if (h.isEmpty()) {
-                // qDebug() << "Closing handle" << handle;
-                FindCloseChangeNotification(handle.handle);    // This one might generate a notification
-
-                int indexOfHandle = handles.indexOf(handle.handle);
-                Q_ASSERT(indexOfHandle != -1);
-                handles.remove(indexOfHandle);
-
-                handleForDir.remove(absolutePath);
-                // h is now invalid
-
-                it.remove();
-            }
-        }
-    }
-
-    if (handleForDir.isEmpty()) {
-        stop();
-        locker.unlock();
-        wait();
-        locker.relock();
-    } else {
-        wakeup();
-    }
-
-    return p;
-}
-
-void QWindowsFileSystemWatcherEngine::stop()
+void QWindowsFileSystemWatcherEngineThread::stop()
 {
     msg = 'q';
     SetEvent(handles.at(0));
 }
 
-void QWindowsFileSystemWatcherEngine::wakeup()
+void QWindowsFileSystemWatcherEngineThread::wakeup()
 {
     msg = '@';
     SetEvent(handles.at(0));
diff --git a/src/corelib/io/qfilesystemwatcher_win_p.h b/src/corelib/io/qfilesystemwatcher_win_p.h
index 5d42cac..405d255 100644
--- a/src/corelib/io/qfilesystemwatcher_win_p.h
+++ b/src/corelib/io/qfilesystemwatcher_win_p.h
@@ -68,27 +68,24 @@
 
 QT_BEGIN_NAMESPACE
 
+class QWindowsFileSystemWatcherEngineThread;
+
+// Even though QWindowsFileSystemWatcherEngine is derived of QThread
+// via QFileSystemWatcher, it does not start a thread.
+// Instead QWindowsFileSystemWatcher creates QWindowsFileSystemWatcherEngineThreads
+// to do the actually watching.
 class QWindowsFileSystemWatcherEngine : public QFileSystemWatcherEngine
 {
     Q_OBJECT
-
 public:
     QWindowsFileSystemWatcherEngine();
     ~QWindowsFileSystemWatcherEngine();
 
-    void run();
-
     QStringList addPaths(const QStringList &paths, QStringList *files, QStringList *directories);
     QStringList removePaths(const QStringList &paths, QStringList *files, QStringList *directories);
 
     void stop();
 
-private:
-    void wakeup();
-
-    QMutex mutex;
-    QVector<HANDLE> handles;
-    int msg;
 
     class Handle
     {
@@ -97,13 +94,12 @@ private:
         uint flags;
 
         Handle()
-            : handle(INVALID_HANDLE_VALUE), flags(0u)
+                : handle(INVALID_HANDLE_VALUE), flags(0u)
         { }
         Handle(const Handle &other)
-            : handle(other.handle), flags(other.flags)
+                : handle(other.handle), flags(other.flags)
         { }
     };
-    QHash<QString, Handle> handleForDir;
 
     class PathInfo {
     public:
@@ -118,7 +114,7 @@ private:
         QDateTime lastModified;
 
         PathInfo &operator=(const QFileInfo &fileInfo)
-        {
+                           {
             ownerId = fileInfo.ownerId();
             groupId = fileInfo.groupId();
             permissions = fileInfo.permissions();
@@ -134,8 +130,35 @@ private:
                     || lastModified != fileInfo.lastModified());
         }
     };
-    QHash<HANDLE, QHash<QString, PathInfo> > pathInfoForHandle;
+private:
+    QList<QWindowsFileSystemWatcherEngineThread *> threads;
+
+};
+
+class QWindowsFileSystemWatcherEngineThread : public QThread
+{
+    Q_OBJECT
+
+public:
+    QWindowsFileSystemWatcherEngineThread();
+    ~QWindowsFileSystemWatcherEngineThread();
+    void run();
+    void stop();
+    void wakeup();
+
+    QMutex mutex;
+    QVector<HANDLE> handles;
+    int msg;
+
+    QHash<QString, QWindowsFileSystemWatcherEngine::Handle> handleForDir;
+
+    QHash<HANDLE, QHash<QString, QWindowsFileSystemWatcherEngine::PathInfo> > pathInfoForHandle;
+
+Q_SIGNALS:
+    void fileChanged(const QString &path, bool removed);
+    void directoryChanged(const QString &path, bool removed);
 };
+
 #endif // QT_NO_FILESYSTEMWATCHER
 
 QT_END_NAMESPACE