File indexing completed on 2024-04-21 03:55:05

 /*
     This file is part of the KDE project
     SPDX-FileCopyrightText: 1998, 1999 Torben Weis <weis@kde.org>
     SPDX-FileCopyrightText: 2000 Carsten Pfeiffer <pfeiffer@kde.org>
     SPDX-FileCopyrightText: 2003-2005 David Faure <faure@kde.org>
     SPDX-FileCopyrightText: 2001-2006 Michael Brade <brade@kde.org>
     SPDX-FileCopyrightText: 2023 Alexander Lohnau <alexander.lohnau@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "kcoredirlister.h"
 #include "kcoredirlister_p.h"
 
 #include "../utils_p.h"
 #include "kiocoredebug.h"
 #include "kmountpoint.h"
 #include <kio/listjob.h>
 
 #include <KJobUiDelegate>
 #include <KLocalizedString>
 
 #include <QDir>
 #include <QFile>
 #include <QFileInfo>
 #include <QMimeDatabase>
 #include <QRegularExpression>
 #include <QTextStream>
 #include <QThreadStorage>
 
 #include <QLoggingCategory>
 Q_DECLARE_LOGGING_CATEGORY(KIO_CORE_DIRLISTER)
 Q_LOGGING_CATEGORY(KIO_CORE_DIRLISTER, "kf.kio.core.dirlister", QtWarningMsg)
 
 // Enable this to get printDebug() called often, to see the contents of the cache
 // #define DEBUG_CACHE
 
 // Make really sure it doesn't get activated in the final build
 #ifdef NDEBUG
 #undef DEBUG_CACHE
 #endif
 
 QThreadStorage<KCoreDirListerCache> s_kDirListerCache;
 
 KCoreDirListerCache::KCoreDirListerCache()
     : itemsCached(10)
     , // keep the last 10 directories around
     m_cacheHiddenFiles(10) // keep the last 10 ".hidden" files around
 {
     qCDebug(KIO_CORE_DIRLISTER);
 
     connect(&pendingUpdateTimer, &QTimer::timeout, this, &KCoreDirListerCache::processPendingUpdates);
     pendingUpdateTimer.setSingleShot(true);
 
     connect(KDirWatch::self(), &KDirWatch::dirty, this, &KCoreDirListerCache::slotFileDirty);
     connect(KDirWatch::self(), &KDirWatch::created, this, &KCoreDirListerCache::slotFileCreated);
     connect(KDirWatch::self(), &KDirWatch::deleted, this, &KCoreDirListerCache::slotFileDeleted);
 
 #ifndef KIO_ANDROID_STUB
     kdirnotify = new org::kde::KDirNotify(QString(), QString(), QDBusConnection::sessionBus(), this);
     connect(kdirnotify, &org::kde::KDirNotify::FileRenamedWithLocalPath, this, &KCoreDirListerCache::slotFileRenamed);
     connect(kdirnotify, &org::kde::KDirNotify::FilesAdded, this, &KCoreDirListerCache::slotFilesAdded);
     connect(kdirnotify, &org::kde::KDirNotify::FilesChanged, this, &KCoreDirListerCache::slotFilesChanged);
     connect(kdirnotify, &org::kde::KDirNotify::FilesRemoved, this, qOverload<const QStringList &>(&KCoreDirListerCache::slotFilesRemoved));
 #endif
 }
 
 KCoreDirListerCache::~KCoreDirListerCache()
 {
     qCDebug(KIO_CORE_DIRLISTER);
 
     qDeleteAll(itemsInUse);
     itemsInUse.clear();
 
     itemsCached.clear();
     directoryData.clear();
     m_cacheHiddenFiles.clear();
 
     if (KDirWatch::exists()) {
         KDirWatch::self()->disconnect(this);
     }
 }
 
 // setting _reload to true will emit the old files and
 // call updateDirectory
 bool KCoreDirListerCache::listDir(KCoreDirLister *lister, const QUrl &dirUrl, bool _keep, bool _reload)
 {
     QUrl _url(dirUrl);
     _url.setPath(QDir::cleanPath(_url.path())); // kill consecutive slashes
 
     // like this we don't have to worry about trailing slashes any further
     _url = _url.adjusted(QUrl::StripTrailingSlash);
 
     QString resolved;
     if (_url.isLocalFile()) {
         // Resolve symlinks (#213799)
         const QString local = _url.toLocalFile();
         resolved = QFileInfo(local).canonicalFilePath();
         if (local != resolved) {
             canonicalUrls[QUrl::fromLocalFile(resolved)].append(_url);
         }
         // TODO: remove entry from canonicalUrls again in forgetDirs
         // Note: this is why we use a QStringList value in there rather than a std::set:
         // we can just remove one entry and not have to worry about other dirlisters
         // (the non-unicity of the stringlist gives us the refcounting, basically).
     }
 
     qCDebug(KIO_CORE_DIRLISTER) << lister << "url=" << _url << "keep=" << _keep << "reload=" << _reload;
 #ifdef DEBUG_CACHE
     printDebug();
 #endif
 
     if (!_keep) {
         // stop any running jobs for lister
         stop(lister, true /*silent*/);
 
         // clear our internal list for lister
         forgetDirs(lister);
 
         lister->d->rootFileItem = KFileItem();
     } else if (lister->d->lstDirs.contains(_url)) {
         // stop the job listing _url for this lister
         stopListingUrl(lister, _url, true /*silent*/);
 
         // remove the _url as well, it will be added in a couple of lines again!
         // forgetDirs with three args does not do this
         // TODO: think about moving this into forgetDirs
         lister->d->lstDirs.removeAll(_url);
 
         // clear _url for lister
         forgetDirs(lister, _url, true);
 
         if (lister->d->url == _url) {
             lister->d->rootFileItem = KFileItem();
         }
     }
 
     lister->d->complete = false;
 
     lister->d->lstDirs.append(_url);
 
     if (lister->d->url.isEmpty() || !_keep) { // set toplevel URL only if not set yet
         lister->d->url = _url;
     }
 
     DirItem *itemU = itemsInUse.value(_url);
 
     KCoreDirListerCacheDirectoryData &dirData = directoryData[_url]; // find or insert
 
     if (dirData.listersCurrentlyListing.isEmpty()) {
         // if there is an update running for _url already we get into
         // the following case - it will just be restarted by updateDirectory().
 
         dirData.listersCurrentlyListing.append(lister);
 
         DirItem *itemFromCache = nullptr;
         if (itemU || (!_reload && (itemFromCache = itemsCached.take(_url)))) {
             if (itemU) {
                 qCDebug(KIO_CORE_DIRLISTER) << "Entry already in use:" << _url;
                 // if _reload is set, then we'll emit cached items and then updateDirectory.
             } else {
                 qCDebug(KIO_CORE_DIRLISTER) << "Entry in cache:" << _url;
                 itemsInUse.insert(_url, itemFromCache);
                 itemU = itemFromCache;
             }
             if (lister->d->autoUpdate) {
                 itemU->incAutoUpdate();
             }
             if (itemFromCache && itemFromCache->watchedWhileInCache) {
                 // item is promoted from cache, update item autoupdate refcount accordingly
                 itemFromCache->watchedWhileInCache = false;
                 itemFromCache->decAutoUpdate();
             }
 
             Q_EMIT lister->started(_url);
 
             // List items from the cache in a delayed manner, just like things would happen
             // if we were not using the cache.
             new KCoreDirListerPrivate::CachedItemsJob(lister, _url, _reload);
 
         } else {
             // dir not in cache or _reload is true
             if (_reload) {
                 qCDebug(KIO_CORE_DIRLISTER) << "Reloading directory:" << _url;
                 itemsCached.remove(_url);
             } else {
                 qCDebug(KIO_CORE_DIRLISTER) << "Listing directory:" << _url;
             }
 
             itemU = new DirItem(_url, resolved);
             itemsInUse.insert(_url, itemU);
             if (lister->d->autoUpdate) {
                 itemU->incAutoUpdate();
             }
 
             KIO::ListJob *job = KIO::listDir(_url, KIO::HideProgressInfo);
             if (lister->requestMimeTypeWhileListing()) {
                 job->addMetaData(QStringLiteral("details"), QString::number(KIO::StatDefaultDetails | KIO::StatMimeType));
             }
             runningListJobs.insert(job, KIO::UDSEntryList());
 
             lister->jobStarted(job);
             lister->d->connectJob(job);
 
             connect(job, &KIO::ListJob::entries, this, &KCoreDirListerCache::slotEntries);
             connect(job, &KJob::result, this, &KCoreDirListerCache::slotResult);
             connect(job, &KIO::ListJob::redirection, this, &KCoreDirListerCache::slotRedirection);
 
             Q_EMIT lister->started(_url);
 
             qCDebug(KIO_CORE_DIRLISTER) << "Entry now being listed by" << dirData.listersCurrentlyListing;
         }
     } else {
         qCDebug(KIO_CORE_DIRLISTER) << "Entry currently being listed:" << _url << "by" << dirData.listersCurrentlyListing;
 #ifdef DEBUG_CACHE
         printDebug();
 #endif
 
         Q_EMIT lister->started(_url);
 
         // Maybe listersCurrentlyListing/listersCurrentlyHolding should be QSets?
         Q_ASSERT(!dirData.listersCurrentlyListing.contains(lister));
         dirData.listersCurrentlyListing.append(lister);
 
         // a new lister is listing this _url, incr watch refcount
         if (lister->d->autoUpdate) {
             itemU->incAutoUpdate();
         }
 
         KIO::ListJob *job = jobForUrl(_url);
         // job will be 0 if we were listing from cache rather than listing from a kio job.
         if (job) {
             lister->jobStarted(job);
             lister->d->connectJob(job);
         }
         Q_ASSERT(itemU);
 
         // List existing items in a delayed manner, just like things would happen
         // if we were not using the cache.
         qCDebug(KIO_CORE_DIRLISTER) << "Listing" << itemU->lstItems.count() << "cached items soon";
         auto *cachedItemsJob = new KCoreDirListerPrivate::CachedItemsJob(lister, _url, _reload);
         if (job) {
             // The ListJob will take care of emitting completed.
             // ### If it finishes before the CachedItemsJob, then we'll emit cached items after completed(), not sure how bad this is.
             cachedItemsJob->setEmitCompleted(false);
         }
 
 #ifdef DEBUG_CACHE
         printDebug();
 #endif
     }
 
     return true;
 }
 
 KCoreDirListerPrivate::CachedItemsJob *KCoreDirListerPrivate::cachedItemsJobForUrl(const QUrl &url) const
 {
     for (CachedItemsJob *job : m_cachedItemsJobs) {
         if (job->url() == url) {
             return job;
         }
     }
     return nullptr;
 }
 
 KCoreDirListerPrivate::CachedItemsJob::CachedItemsJob(KCoreDirLister *lister, const QUrl &url, bool reload)
     : KJob(lister)
     , m_lister(lister)
     , m_url(url)
     , m_reload(reload)
     , m_emitCompleted(true)
 {
     qCDebug(KIO_CORE_DIRLISTER) << "Creating CachedItemsJob" << this << "for lister" << lister << url;
     if (lister->d->cachedItemsJobForUrl(url)) {
         qCWarning(KIO_CORE) << "Lister" << lister << "has a cached items job already for" << url;
     }
     lister->d->m_cachedItemsJobs.append(this);
     setAutoDelete(true);
     start();
 }
 
 // Called by start() via QueuedConnection
 void KCoreDirListerPrivate::CachedItemsJob::done()
 {
     if (!m_lister) { // job was already killed, but waiting deletion due to deleteLater
         return;
     }
     s_kDirListerCache.localData().emitItemsFromCache(this, m_lister, m_url, m_reload, m_emitCompleted);
     emitResult();
 }
 
 bool KCoreDirListerPrivate::CachedItemsJob::doKill()
 {
     qCDebug(KIO_CORE_DIRLISTER) << this;
     s_kDirListerCache.localData().forgetCachedItemsJob(this, m_lister, m_url);
     if (!property("_kdlc_silent").toBool()) {
         Q_EMIT m_lister->listingDirCanceled(m_url);
 
         Q_EMIT m_lister->canceled();
     }
     m_lister = nullptr;
     return true;
 }
 
 void KCoreDirListerCache::emitItemsFromCache(KCoreDirListerPrivate::CachedItemsJob *cachedItemsJob,
                                              KCoreDirLister *lister,
                                              const QUrl &_url,
                                              bool _reload,
                                              bool _emitCompleted)
 {
     lister->d->complete = false;
 
     DirItem *itemU = s_kDirListerCache.localData().itemsInUse.value(_url);
     if (!itemU) {
         qCWarning(KIO_CORE) << "Can't find item for directory" << _url << "anymore";
     } else {
         const QList<KFileItem> items = itemU->lstItems;
         const KFileItem rootItem = itemU->rootItem;
         _reload = _reload || !itemU->complete;
 
         if (lister->d->rootFileItem.isNull() && !rootItem.isNull() && lister->d->url == _url) {
             lister->d->rootFileItem = rootItem;
         }
         if (!items.isEmpty()) {
             qCDebug(KIO_CORE_DIRLISTER) << "emitting" << items.count() << "for lister" << lister;
             lister->d->addNewItems(_url, items);
             lister->d->emitItems();
         }
     }
 
     forgetCachedItemsJob(cachedItemsJob, lister, _url);
 
     // Emit completed, unless we were told not to,
     // or if listDir() was called while another directory listing for this dir was happening,
     // so we "joined" it. We detect that using jobForUrl to ensure it's a real ListJob,
     // not just a lister-specific CachedItemsJob (which wouldn't emit completed for us).
     if (_emitCompleted) {
         lister->d->complete = true;
 
         Q_EMIT lister->listingDirCompleted(_url);
         Q_EMIT lister->completed();
 
         if (_reload) {
             updateDirectory(_url);
         }
     }
 }
 
 void KCoreDirListerCache::forgetCachedItemsJob(KCoreDirListerPrivate::CachedItemsJob *cachedItemsJob, KCoreDirLister *lister, const QUrl &_url)
 {
     // Modifications to data structures only below this point;
     // so that addNewItems is called with a consistent state
 
     lister->d->m_cachedItemsJobs.removeAll(cachedItemsJob);
 
     KCoreDirListerCacheDirectoryData &dirData = directoryData[_url];
     Q_ASSERT(dirData.listersCurrentlyListing.contains(lister));
 
     KIO::ListJob *listJob = jobForUrl(_url);
     if (!listJob) {
         Q_ASSERT(!dirData.listersCurrentlyHolding.contains(lister));
         qCDebug(KIO_CORE_DIRLISTER) << "Moving from listing to holding, because no more job" << lister << _url;
         dirData.listersCurrentlyHolding.append(lister);
         dirData.listersCurrentlyListing.removeAll(lister);
     } else {
         qCDebug(KIO_CORE_DIRLISTER) << "Still having a listjob" << listJob << ", so not moving to currently-holding.";
     }
 }
 
 void KCoreDirListerCache::stop(KCoreDirLister *lister, bool silent)
 {
     qCDebug(KIO_CORE_DIRLISTER) << "lister:" << lister << "silent=" << silent;
 
     const QList<QUrl> urls = lister->d->lstDirs;
     for (const QUrl &url : urls) {
         stopListingUrl(lister, url, silent);
     }
 }
 
 void KCoreDirListerCache::stopListingUrl(KCoreDirLister *lister, const QUrl &_u, bool silent)
 {
     QUrl url(_u);
     url = url.adjusted(QUrl::StripTrailingSlash);
 
     KCoreDirListerPrivate::CachedItemsJob *cachedItemsJob = lister->d->cachedItemsJobForUrl(url);
     if (cachedItemsJob) {
         if (silent) {
             cachedItemsJob->setProperty("_kdlc_silent", true);
         }
         cachedItemsJob->kill(); // removes job from list, too
     }
 
     // TODO: consider to stop all the "child jobs" of url as well
     qCDebug(KIO_CORE_DIRLISTER) << lister << " url=" << url;
 
     const auto dirit = directoryData.find(url);
     if (dirit == directoryData.end()) {
         return;
     }
     KCoreDirListerCacheDirectoryData &dirData = dirit.value();
     if (dirData.listersCurrentlyListing.contains(lister)) {
         qCDebug(KIO_CORE_DIRLISTER) << " found lister" << lister << "in list - for" << url;
         if (dirData.listersCurrentlyListing.count() == 1) {
             // This was the only dirlister interested in the list job -> kill the job
             stopListJob(url, silent);
         } else {
             // Leave the job running for the other dirlisters, just unsubscribe us.
             dirData.listersCurrentlyListing.removeAll(lister);
             if (!silent) {
                 Q_EMIT lister->canceled();
                 Q_EMIT lister->listingDirCanceled(url);
             }
         }
     }
 }
 
 // Helper for stop() and stopListingUrl()
 void KCoreDirListerCache::stopListJob(const QUrl &url, bool silent)
 {
     // Old idea: if it's an update job, let's just leave the job running.
     // After all, update jobs do run for "listersCurrentlyHolding",
     // so there's no reason to kill them just because @p lister is now a holder.
 
     // However it could be a long-running non-local job (e.g. filenamesearch), which
     // the user wants to abort, and which will never be used for updating...
     // And in any case slotEntries/slotResult is not meant to be called by update jobs.
     // So, change of plan, let's kill it after all, in a way that triggers slotResult/slotUpdateResult.
 
     KIO::ListJob *job = jobForUrl(url);
     if (job) {
         qCDebug(KIO_CORE_DIRLISTER) << "Killing list job" << job << "for" << url;
         if (silent) {
             job->setProperty("_kdlc_silent", true);
         }
         job->kill(KJob::EmitResult);
     }
 }
 
 void KCoreDirListerCache::setAutoUpdate(KCoreDirLister *lister, bool enable)
 {
     // IMPORTANT: this method does not check for the current autoUpdate state!
 
     for (const QUrl &url : std::as_const(lister->d->lstDirs)) {
         DirItem *dirItem = itemsInUse.value(url);
         Q_ASSERT(dirItem);
         if (enable) {
             dirItem->incAutoUpdate();
         } else {
             dirItem->decAutoUpdate();
         }
     }
 }
 
 void KCoreDirListerCache::forgetDirs(KCoreDirLister *lister)
 {
     qCDebug(KIO_CORE_DIRLISTER) << lister;
 
     Q_EMIT lister->clear();
     // clear lister->d->lstDirs before calling forgetDirs(), so that
     // it doesn't contain things that itemsInUse doesn't. When emitting
     // the canceled signals, lstDirs must not contain anything that
     // itemsInUse does not contain. (otherwise it might crash in findByName()).
     const QList<QUrl> lstDirsCopy = lister->d->lstDirs;
     lister->d->lstDirs.clear();
 
     qCDebug(KIO_CORE_DIRLISTER) << "Iterating over dirs" << lstDirsCopy;
     for (const QUrl &dir : lstDirsCopy) {
         forgetDirs(lister, dir, false);
     }
 }
 
 static bool manually_mounted(const QString &path, const KMountPoint::List &possibleMountPoints)
 {
     KMountPoint::Ptr mp = possibleMountPoints.findByPath(path);
     if (!mp) { // not listed in fstab -> yes, manually mounted
         if (possibleMountPoints.isEmpty()) { // no fstab at all -> don't assume anything
             return false;
         }
         return true;
     }
     // noauto -> manually mounted. Otherwise, mounted at boot time, won't be unmounted any time soon hopefully.
     return mp->mountOptions().contains(QLatin1String("noauto"));
 }
 
 void KCoreDirListerCache::forgetDirs(KCoreDirLister *lister, const QUrl &_url, bool notify)
 {
     qCDebug(KIO_CORE_DIRLISTER) << lister << " _url: " << _url;
 
     const QUrl url = _url.adjusted(QUrl::StripTrailingSlash);
 
     DirectoryDataHash::iterator dit = directoryData.find(url);
     if (dit == directoryData.end()) {
         return;
     }
     KCoreDirListerCacheDirectoryData &dirData = *dit;
     dirData.listersCurrentlyHolding.removeAll(lister);
 
     // This lister doesn't care for updates running in <url> anymore
     KIO::ListJob *job = jobForUrl(url);
     if (job) {
         lister->d->jobDone(job);
     }
 
     DirItem *item = itemsInUse.value(url);
     Q_ASSERT(item);
     bool insertIntoCache = false;
 
     if (dirData.listersCurrentlyHolding.isEmpty() && dirData.listersCurrentlyListing.isEmpty()) {
         // item not in use anymore -> move into cache if complete
         directoryData.erase(dit);
         itemsInUse.remove(url);
 
         // this job is a running update which nobody cares about anymore
         if (job) {
             killJob(job);
             qCDebug(KIO_CORE_DIRLISTER) << "Killing update job for " << url;
 
             // Well, the user of KCoreDirLister doesn't really care that we're stopping
             // a background-running job from a previous URL (in listDir) -> commented out.
             // stop() already emitted canceled.
             // emit lister->canceled( url );
             if (lister->d->numJobs() == 0) {
                 lister->d->complete = true;
                 // emit lister->canceled();
             }
         }
 
         if (notify) {
             lister->d->lstDirs.removeAll(url);
             Q_EMIT lister->clearDir(url);
         }
 
         insertIntoCache = item->complete;
         if (insertIntoCache) {
             // TODO(afiestas): remove use of KMountPoint+manually_mounted and port to Solid:
             // 1) find Volume for the local path "item->url.toLocalFile()" (which could be anywhere
             // under the mount point) -- probably needs a new operator in libsolid query parser
             // 2) [**] becomes: if (Drive is hotpluggable or Volume is removable) "set to dirty" else "keep watch"
             const KMountPoint::List possibleMountPoints = KMountPoint::possibleMountPoints(KMountPoint::NeedMountOptions);
 
             // Should we forget the dir for good, or keep a watch on it?
             // Generally keep a watch, except when it would prevent
             // unmounting a removable device (#37780)
             const bool isLocal = item->url.isLocalFile();
             bool isManuallyMounted = false;
             bool containsManuallyMounted = false;
             if (isLocal) {
                 isManuallyMounted = manually_mounted(item->url.toLocalFile(), possibleMountPoints);
                 if (!isManuallyMounted) {
                     // Look for a manually-mounted directory inside
                     // If there's one, we can't keep a watch either, FAM would prevent unmounting the CDROM
                     // I hope this isn't too slow
                     auto kit = item->lstItems.constBegin();
                     const auto kend = item->lstItems.constEnd();
                     for (; kit != kend && !containsManuallyMounted; ++kit) {
                         if ((*kit).isDir() && manually_mounted((*kit).url().toLocalFile(), possibleMountPoints)) {
                             containsManuallyMounted = true;
                         }
                     }
                 }
             }
 
             if (isManuallyMounted || containsManuallyMounted) { // [**]
                 qCDebug(KIO_CORE_DIRLISTER) << "Not adding a watch on " << item->url << " because it "
                                             << (isManuallyMounted ? "is manually mounted" : "contains a manually mounted subdir");
                 item->complete = false; // set to "dirty"
             } else {
                 item->incAutoUpdate(); // keep watch, incr refcount to account for cache
                 item->watchedWhileInCache = true;
             }
         } else {
             delete item;
             item = nullptr;
         }
     }
 
     if (item && lister->d->autoUpdate) {
         item->decAutoUpdate();
     }
 
     // Inserting into QCache must be done last, since it might delete the item
     if (item && insertIntoCache) {
         qCDebug(KIO_CORE_DIRLISTER) << lister << "item moved into cache:" << url;
         itemsCached.insert(url, item);
     }
 }
 
 void KCoreDirListerCache::updateDirectory(const QUrl &_dir)
 {
     qCDebug(KIO_CORE_DIRLISTER) << _dir;
 
     QUrl dir = _dir.adjusted(QUrl::StripTrailingSlash);
     if (!checkUpdate(dir)) {
         auto parentDir = dir.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash);
         if (checkUpdate(parentDir)) {
             // if the parent is in use, update it instead
             dir = parentDir;
         } else {
             return;
         }
     }
 
     // A job can be running to
     //   - only list a new directory: the listers are in listersCurrentlyListing
     //   - only update a directory: the listers are in listersCurrentlyHolding
     //   - update a currently running listing: the listers are in both
 
     KCoreDirListerCacheDirectoryData &dirData = directoryData[dir];
     const QList<KCoreDirLister *> listers = dirData.listersCurrentlyListing;
     const QList<KCoreDirLister *> holders = dirData.listersCurrentlyHolding;
 
     qCDebug(KIO_CORE_DIRLISTER) << dir << "listers=" << listers << "holders=" << holders;
 
     bool killed = false;
     KIO::ListJob *job = jobForUrl(dir);
     if (job) {
         // the job is running already, tell it to do another update at the end
         // (don't kill it, we would keep doing that during a long download to a slow sshfs mount)
         job->setProperty("need_another_update", true);
         return;
     } else {
         // Emit any cached items.
         // updateDirectory() is about the diff compared to the cached items...
         for (const KCoreDirLister *kdl : listers) {
             KCoreDirListerPrivate::CachedItemsJob *cachedItemsJob = kdl->d->cachedItemsJobForUrl(dir);
             if (cachedItemsJob) {
                 cachedItemsJob->setEmitCompleted(false);
                 cachedItemsJob->done(); // removes from cachedItemsJobs list
                 delete cachedItemsJob;
                 killed = true;
             }
         }
     }
     qCDebug(KIO_CORE_DIRLISTER) << "Killed=" << killed;
 
     // we don't need to emit canceled signals since we only replaced the job,
     // the listing is continuing.
 
     if (!(listers.isEmpty() || killed)) {
         qCWarning(KIO_CORE) << "The unexpected happened.";
         qCWarning(KIO_CORE) << "listers for" << dir << "=" << listers;
         qCWarning(KIO_CORE) << "job=" << job;
         for (const KCoreDirLister *kdl : listers) {
             qCDebug(KIO_CORE_DIRLISTER) << "lister" << kdl << "m_cachedItemsJobs=" << kdl->d->m_cachedItemsJobs;
         }
 #ifndef NDEBUG
         printDebug();
 #endif
     }
     Q_ASSERT(listers.isEmpty() || killed);
 
     job = KIO::listDir(dir, KIO::HideProgressInfo);
     runningListJobs.insert(job, KIO::UDSEntryList());
 
     const bool requestFromListers = std::any_of(listers.cbegin(), listers.cend(), [](KCoreDirLister *lister) {
         return lister->requestMimeTypeWhileListing();
     });
     const bool requestFromholders = std::any_of(holders.cbegin(), holders.cend(), [](KCoreDirLister *lister) {
         return lister->requestMimeTypeWhileListing();
     });
 
     if (requestFromListers || requestFromholders) {
         job->addMetaData(QStringLiteral("details"), QString::number(KIO::StatDefaultDetails | KIO::StatMimeType));
     }
 
     connect(job, &KIO::ListJob::entries, this, &KCoreDirListerCache::slotUpdateEntries);
     connect(job, &KJob::result, this, &KCoreDirListerCache::slotUpdateResult);
 
     qCDebug(KIO_CORE_DIRLISTER) << "update started in" << dir;
 
     for (KCoreDirLister *kdl : listers) {
         kdl->jobStarted(job);
     }
 
     if (!holders.isEmpty()) {
         if (!killed) {
             for (KCoreDirLister *kdl : holders) {
                 kdl->jobStarted(job);
                 Q_EMIT kdl->started(dir);
             }
         } else {
             for (KCoreDirLister *kdl : holders) {
                 kdl->jobStarted(job);
             }
         }
     }
 }
 
 bool KCoreDirListerCache::checkUpdate(const QUrl &_dir)
 {
     if (!itemsInUse.contains(_dir)) {
         DirItem *item = itemsCached[_dir];
         if (item && item->complete) {
             item->complete = false;
             item->watchedWhileInCache = false;
             item->decAutoUpdate();
             qCDebug(KIO_CORE_DIRLISTER) << "directory " << _dir << " not in use, marked dirty.";
         }
         // else
         qCDebug(KIO_CORE_DIRLISTER) << "aborted, directory " << _dir << " not in cache.";
         return false;
     } else {
         return true;
     }
 }
 
 KFileItem KCoreDirListerCache::itemForUrl(const QUrl &url) const
 {
     return findByUrl(nullptr, url);
 }
 
 KCoreDirListerCache::DirItem *KCoreDirListerCache::dirItemForUrl(const QUrl &dir) const
 {
     const QUrl url = dir.adjusted(QUrl::StripTrailingSlash);
     DirItem *item = itemsInUse.value(url);
     if (!item) {
         item = itemsCached[url];
     }
     return item;
 }
 
 QList<KFileItem> *KCoreDirListerCache::itemsForDir(const QUrl &dir) const
 {
     DirItem *item = dirItemForUrl(dir);
     return item ? &item->lstItems : nullptr;
 }
 
 KFileItem KCoreDirListerCache::findByName(const KCoreDirLister *lister, const QString &_name) const
 {
     Q_ASSERT(lister);
 
     auto isMatch = [&_name](const KFileItem &item) {
         return _name == item.name();
     };
 
     for (const auto &dirUrl : std::as_const(lister->d->lstDirs)) {
         DirItem *dirItem = itemsInUse.value(dirUrl);
         Q_ASSERT(dirItem);
 
         auto it = std::find_if(dirItem->lstItems.cbegin(), dirItem->lstItems.cend(), isMatch);
         if (it != dirItem->lstItems.cend()) {
             return *it;
         }
     }
 
     return {};
 }
 
 KFileItem KCoreDirListerCache::findByUrl(const KCoreDirLister *lister, const QUrl &_u) const
 {
     QUrl url(_u);
     url = url.adjusted(QUrl::StripTrailingSlash);
 
     const QUrl parentDir = url.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash);
     DirItem *dirItem = dirItemForUrl(parentDir);
     if (dirItem) {
         // If lister is set, check that it contains this dir
         if (!lister || lister->d->lstDirs.contains(parentDir)) {
             // Binary search
             auto it = std::lower_bound(dirItem->lstItems.begin(), dirItem->lstItems.end(), url);
             if (it != dirItem->lstItems.end() && it->url() == url) {
                 return *it;
             }
         }
     }
 
     // Maybe _u is a directory itself? (see KDirModelTest::testChmodDirectory)
     // We check this last, though, we prefer returning a kfileitem with an actual
     // name if possible (and we make it '.' for root items later).
     dirItem = dirItemForUrl(url);
     if (dirItem && !dirItem->rootItem.isNull() && dirItem->rootItem.url() == url) {
         // If lister is set, check that it contains this dir
         if (!lister || lister->d->lstDirs.contains(url)) {
             return dirItem->rootItem;
         }
     }
 
     return KFileItem();
 }
 
 void KCoreDirListerCache::slotFilesAdded(const QString &dir /*url*/) // from KDirNotify signals
 {
     QUrl urlDir(dir);
     itemsAddedInDirectory(urlDir);
 }
 
 void KCoreDirListerCache::itemsAddedInDirectory(const QUrl &urlDir)
 {
     qCDebug(KIO_CORE_DIRLISTER) << urlDir;
     const QList<QUrl> urls = directoriesForCanonicalPath(urlDir);
     for (const QUrl &u : urls) {
         updateDirectory(u);
     }
 }
 
 void KCoreDirListerCache::slotFilesRemoved(const QStringList &fileList) // from KDirNotify signals
 {
     slotFilesRemoved(QUrl::fromStringList(fileList));
 }
 
 void KCoreDirListerCache::slotFilesRemoved(const QList<QUrl> &fileList)
 {
     qCDebug(KIO_CORE_DIRLISTER) << fileList.count();
     // Group notifications by parent dirs (usually there would be only one parent dir)
     QMap<QUrl, KFileItemList> removedItemsByDir;
     QList<QUrl> deletedSubdirs;
 
     for (const QUrl &url : fileList) {
         const QList<QUrl> dirUrls = directoriesForCanonicalPath(url);
         for (const QUrl &dir : dirUrls) {
             DirItem *dirItem = dirItemForUrl(dir); // is it a listed directory?
             if (dirItem) {
                 deletedSubdirs.append(dir);
                 if (!dirItem->rootItem.isNull()) {
                     removedItemsByDir[url].append(dirItem->rootItem);
                 }
             }
         }
 
         const QUrl parentDir = url.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash);
         const QList<QUrl> parentDirUrls = directoriesForCanonicalPath(parentDir);
         for (const QUrl &dir : parentDirUrls) {
             DirItem *dirItem = dirItemForUrl(dir);
             if (!dirItem) {
                 continue;
             }
 
             const auto dirItemIt = std::find_if(dirItem->lstItems.cbegin(), dirItem->lstItems.cend(), [&url](const KFileItem &fitem) {
                 return fitem.name() == url.fileName();
             });
             if (dirItemIt != dirItem->lstItems.cend()) {
                 const KFileItem fileitem = *dirItemIt;
                 removedItemsByDir[dir].append(fileitem);
                 // If we found a fileitem, we can test if it's a dir. If not, we'll go to deleteDir just in case.
                 if (fileitem.isNull() || fileitem.isDir()) {
                     deletedSubdirs.append(url);
                 }
                 dirItem->lstItems.erase(dirItemIt); // remove fileitem from list
             }
         }
     }
 
     for (auto rit = removedItemsByDir.constBegin(), cend = removedItemsByDir.constEnd(); rit != cend; ++rit) {
         // Tell the views about it before calling deleteDir.
         // They might need the subdirs' file items (see the dirtree).
         auto dit = directoryData.constFind(rit.key());
         if (dit != directoryData.constEnd()) {
             itemsDeleted((*dit).listersCurrentlyHolding, rit.value());
         }
     }
 
     for (const QUrl &url : std::as_const(deletedSubdirs)) {
         // in case of a dir, check if we have any known children, there's much to do in that case
         // (stopping jobs, removing dirs from cache etc.)
         deleteDir(url);
     }
 }
 
 void KCoreDirListerCache::slotFilesChanged(const QStringList &fileList) // from KDirNotify signals
 {
     qCDebug(KIO_CORE_DIRLISTER) << fileList;
     QList<QUrl> dirsToUpdate;
     for (const QString &fileUrl : fileList) {
         const QUrl url(fileUrl);
         const KFileItem &fileitem = findByUrl(nullptr, url);
         if (fileitem.isNull()) {
             qCDebug(KIO_CORE_DIRLISTER) << "item not found for" << url;
             continue;
         }
         if (url.isLocalFile()) {
             pendingUpdates.insert(url.toLocalFile()); // delegate the work to processPendingUpdates
         } else {
             pendingRemoteUpdates.insert(fileitem);
             // For remote files, we won't be able to figure out the new information,
             // we have to do a update (directory listing)
             const QUrl dir = url.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash);
             if (!dirsToUpdate.contains(dir)) {
                 dirsToUpdate.prepend(dir);
             }
         }
     }
 
     for (const QUrl &dirUrl : std::as_const(dirsToUpdate)) {
         updateDirectory(dirUrl);
     }
     // ## TODO problems with current jobs listing/updating that dir
     // ( see kde-2.2.2's kdirlister )
 
     processPendingUpdates();
 }
 
 void KCoreDirListerCache::slotFileRenamed(const QString &_src, const QString &_dst, const QString &dstPath) // from KDirNotify signals
 {
     QUrl src(_src);
     QUrl dst(_dst);
     qCDebug(KIO_CORE_DIRLISTER) << src << "->" << dst;
 #ifdef DEBUG_CACHE
     printDebug();
 #endif
 
     QUrl oldurl = src.adjusted(QUrl::StripTrailingSlash);
     KFileItem fileitem = findByUrl(nullptr, oldurl);
     if (fileitem.isNull()) {
         qCDebug(KIO_CORE_DIRLISTER) << "Item not found:" << oldurl;
         return;
     }
 
     const KFileItem oldItem = fileitem;
 
     // Dest already exists? Was overwritten then (testcase: #151851)
     // We better emit it as deleted -before- doing the renaming, otherwise
     // the "update" mechanism will emit the old one as deleted and
     // kdirmodel will delete the new (renamed) one!
     const KFileItem &existingDestItem = findByUrl(nullptr, dst);
     if (!existingDestItem.isNull()) {
         qCDebug(KIO_CORE_DIRLISTER) << dst << "already existed, let's delete it";
         slotFilesRemoved(QList<QUrl>{dst});
     }
 
     // If the item had a UDS_URL as well as UDS_NAME set, the user probably wants
     // to be updating the name only (since they can't see the URL).
     // Check to see if a URL exists, and if so, if only the file part has changed,
     // only update the name and not the underlying URL.
     bool nameOnly = !fileitem.entry().stringValue(KIO::UDSEntry::UDS_URL).isEmpty();
     nameOnly = nameOnly && src.adjusted(QUrl::RemoveFilename) == dst.adjusted(QUrl::RemoveFilename);
 
     if (!nameOnly && fileitem.isDir()) {
         renameDir(oldurl, dst);
         // #172945 - if the fileitem was the root item of a DirItem that was just removed from the cache,
         // then it's a dangling pointer now...
         fileitem = findByUrl(nullptr, oldurl);
         if (fileitem.isNull()) { // deleted from cache altogether, #188807
             return;
         }
     }
 
     // Now update the KFileItem representing that file or dir (not exclusive with the above!)
     if (!oldItem.isLocalFile() && !oldItem.localPath().isEmpty()
         && dstPath.isEmpty()) { // it uses UDS_LOCAL_PATH and we don't know the new path? needs an update then
         slotFilesChanged(QStringList{src.toString()});
     } else {
         const QUrl &itemOldUrl = fileitem.url();
         if (nameOnly) {
             fileitem.setName(dst.fileName());
         } else {
             fileitem.setUrl(dst);
         }
 
         if (!dstPath.isEmpty()) {
             fileitem.setLocalPath(dstPath);
         }
 
         fileitem.refreshMimeType();
         fileitem.determineMimeType();
         reinsert(fileitem, itemOldUrl);
 
         const std::set<KCoreDirLister *> listers = emitRefreshItem(oldItem, fileitem);
         for (KCoreDirLister *kdl : listers) {
             kdl->d->emitItems();
         }
     }
 
 #ifdef DEBUG_CACHE
     printDebug();
 #endif
 }
 
 std::set<KCoreDirLister *> KCoreDirListerCache::emitRefreshItem(const KFileItem &oldItem, const KFileItem &fileitem)
 {
     qCDebug(KIO_CORE_DIRLISTER) << "old:" << oldItem.name() << oldItem.url() << "new:" << fileitem.name() << fileitem.url();
     // Look whether this item was shown in any view, i.e. held by any dirlister
     const QUrl parentDir = oldItem.url().adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash);
     DirectoryDataHash::iterator dit = directoryData.find(parentDir);
     QList<KCoreDirLister *> listers;
     // Also look in listersCurrentlyListing, in case the user manages to rename during a listing
     if (dit != directoryData.end()) {
         listers += (*dit).listersCurrentlyHolding + (*dit).listersCurrentlyListing;
     }
     if (oldItem.isDir()) {
         // For a directory, look for dirlisters where it's the root item.
         dit = directoryData.find(oldItem.url());
         if (dit != directoryData.end()) {
             listers += (*dit).listersCurrentlyHolding + (*dit).listersCurrentlyListing;
         }
     }
     std::set<KCoreDirLister *> listersToRefresh;
     for (KCoreDirLister *kdl : std::as_const(listers)) {
         // deduplicate listers
         listersToRefresh.insert(kdl);
     }
     for (KCoreDirLister *kdl : std::as_const(listersToRefresh)) {
         // For a directory, look for dirlisters where it's the root item.
         QUrl directoryUrl(oldItem.url());
         if (oldItem.isDir() && kdl->d->rootFileItem == oldItem) {
             const KFileItem oldRootItem = kdl->d->rootFileItem;
             kdl->d->rootFileItem = fileitem;
             kdl->d->addRefreshItem(directoryUrl, oldRootItem, fileitem);
         } else {
             directoryUrl = directoryUrl.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash);
             kdl->d->addRefreshItem(directoryUrl, oldItem, fileitem);
         }
     }
     return listersToRefresh;
 }
 
 QList<QUrl> KCoreDirListerCache::directoriesForCanonicalPath(const QUrl &dir) const
 {
     QList<QUrl> urlList = canonicalUrls.value(dir);
     // make unique
     if (urlList.size() > 1) {
         std::sort(urlList.begin(), urlList.end());
         auto end_unique = std::unique(urlList.begin(), urlList.end());
         urlList.erase(end_unique, urlList.end());
     }
 
     QList<QUrl> dirs({dir});
     dirs.append(urlList);
 
     if (dirs.count() > 1) {
         qCDebug(KIO_CORE_DIRLISTER) << dir << "known as" << dirs;
     }
     return dirs;
 }
 
 // private slots
 
 // Called by KDirWatch - usually when a dir we're watching has been modified,
 // but it can also be called for a file.
 void KCoreDirListerCache::slotFileDirty(const QString &path)
 {
     qCDebug(KIO_CORE_DIRLISTER) << path;
     QUrl url = QUrl::fromLocalFile(path).adjusted(QUrl::StripTrailingSlash);
     // File or dir?
     bool isDir;
     const KFileItem item = itemForUrl(url);
 
     if (!item.isNull()) {
         isDir = item.isDir();
     } else {
         QFileInfo info(path);
         if (!info.exists()) {
             return; // error
         }
         isDir = info.isDir();
     }
 
     if (isDir) {
         const QList<QUrl> urls = directoriesForCanonicalPath(url);
         for (const QUrl &dir : urls) {
             handleDirDirty(dir);
         }
     }
     // Also do this for dirs, e.g. to handle permission changes
     const QList<QUrl> urls = directoriesForCanonicalPath(url.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash));
     for (const QUrl &dir : urls) {
         QUrl aliasUrl(dir);
         aliasUrl.setPath(Utils::concatPaths(aliasUrl.path(), url.fileName()));
         handleFileDirty(aliasUrl);
     }
 }
 
 // Called by slotFileDirty
 void KCoreDirListerCache::handleDirDirty(const QUrl &url)
 {
     // A dir: launch an update job if anyone cares about it
 
     // This also means we can forget about pending updates to individual files in that dir
     const QString dir = url.toLocalFile();
     const QString dirPath = Utils::slashAppended(dir);
 
     for (auto pendingIt = pendingUpdates.cbegin(); pendingIt != pendingUpdates.cend(); /* */) {
         const QString updPath = *pendingIt;
         qCDebug(KIO_CORE_DIRLISTER) << "had pending update" << updPath;
         if (updPath.startsWith(dirPath) && updPath.indexOf(QLatin1Char('/'), dirPath.length()) == -1) { // direct child item
             qCDebug(KIO_CORE_DIRLISTER) << "forgetting about individual update to" << updPath;
             pendingIt = pendingUpdates.erase(pendingIt);
         } else {
             ++pendingIt;
         }
     }
 
     if (checkUpdate(url)) {
         const auto [it, isInserted] = pendingDirectoryUpdates.insert(dir);
         if (isInserted && !pendingUpdateTimer.isActive()) {
             pendingUpdateTimer.start(200);
         }
     }
 }
 
 // Called by slotFileDirty, for every alias of <url>
 void KCoreDirListerCache::handleFileDirty(const QUrl &url)
 {
     // A file: do we know about it already?
     const KFileItem &existingItem = findByUrl(nullptr, url);
     const QUrl dir = url.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash);
     if (existingItem.isNull()) {
         // No - update the parent dir then
         handleDirDirty(dir);
     }
 
     // Delay updating the file, FAM is flooding us with events
     if (checkUpdate(dir)) {
         const QString filePath = url.toLocalFile();
         const auto [it, isInserted] = pendingUpdates.insert(filePath);
         if (isInserted && !pendingUpdateTimer.isActive()) {
             pendingUpdateTimer.start(200);
         }
     }
 }
 
 void KCoreDirListerCache::slotFileCreated(const QString &path) // from KDirWatch
 {
     qCDebug(KIO_CORE_DIRLISTER) << path;
     // XXX: how to avoid a complete rescan here?
     // We'd need to stat that one file separately and refresh the item(s) for it.
     QUrl fileUrl(QUrl::fromLocalFile(path));
     itemsAddedInDirectory(fileUrl.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash));
 }
 
 void KCoreDirListerCache::slotFileDeleted(const QString &path) // from KDirWatch
 {
     qCDebug(KIO_CORE_DIRLISTER) << path;
     const QString fileName = QFileInfo(path).fileName();
     QUrl dirUrl(QUrl::fromLocalFile(path));
     QStringList fileUrls;
     const QList<QUrl> urls = directoriesForCanonicalPath(dirUrl.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash));
     for (const QUrl &url : urls) {
         QUrl urlInfo(url);
         urlInfo.setPath(Utils::concatPaths(urlInfo.path(), fileName));
         fileUrls << urlInfo.toString();
     }
     slotFilesRemoved(fileUrls);
 }
 
 void KCoreDirListerCache::slotEntries(KIO::Job *job, const KIO::UDSEntryList &entries)
 {
     QUrl url(joburl(static_cast<KIO::ListJob *>(job)));
     url = url.adjusted(QUrl::StripTrailingSlash);
 
     qCDebug(KIO_CORE_DIRLISTER) << "new entries for " << url;
 
     DirItem *dir = itemsInUse.value(url);
     if (!dir) {
         qCWarning(KIO_CORE) << "Internal error: job is listing" << url << "but itemsInUse only knows about" << itemsInUse.keys();
         Q_ASSERT(dir);
         return;
     }
 
     DirectoryDataHash::iterator dit = directoryData.find(url);
     if (dit == directoryData.end()) {
         qCWarning(KIO_CORE) << "Internal error: job is listing" << url << "but directoryData doesn't know about that url, only about:" << directoryData.keys();
         Q_ASSERT(dit != directoryData.end());
         return;
     }
     KCoreDirListerCacheDirectoryData &dirData = *dit;
     const QList<KCoreDirLister *> listers = dirData.listersCurrentlyListing;
     if (listers.isEmpty()) {
         qCWarning(KIO_CORE) << "Internal error: job is listing" << url << "but directoryData says no listers are currently listing " << url;
 #ifndef NDEBUG
         printDebug();
 #endif
         Q_ASSERT(!listers.isEmpty());
         return;
     }
 
     // check if anyone wants the MIME types immediately
     bool delayedMimeTypes = true;
     for (const KCoreDirLister *kdl : listers) {
         delayedMimeTypes &= kdl->d->delayedMimeTypes;
     }
 
     CacheHiddenFile *cachedHidden = nullptr;
     bool dotHiddenChecked = false;
     KFileItemList newItems;
     for (const auto &entry : entries) {
         const QString name = entry.stringValue(KIO::UDSEntry::UDS_NAME);
 
         Q_ASSERT(!name.isEmpty());
         if (name.isEmpty()) {
             continue;
         }
 
         if (name == QLatin1Char('.')) {
             // Try to reuse an existing KFileItem (if we listed the parent dir)
             // rather than creating a new one. There are many reasons:
             // 1) renames and permission changes to the item would have to emit the signals
             // twice, otherwise, so that both views manage to recognize the item.
             // 2) with kio_ftp we can only know that something is a symlink when
             // listing the parent, so prefer that item, which has more info.
             // Note that it gives a funky name() to the root item, rather than "." ;)
             dir->rootItem = itemForUrl(url);
             if (dir->rootItem.isNull()) {
                 dir->rootItem = KFileItem(entry, url, delayedMimeTypes, true);
             }
 
             for (KCoreDirLister *kdl : listers) {
                 if (kdl->d->rootFileItem.isNull() && kdl->d->url == url) {
                     kdl->d->rootFileItem = dir->rootItem;
                 }
             }
         } else if (name != QLatin1String("..")) {
             KFileItem item(entry, url, delayedMimeTypes, true);
 
             // get the names of the files listed in ".hidden", if it exists and is a local file
             if (!dotHiddenChecked) {
                 const QString localPath = item.localPath();
                 if (!localPath.isEmpty()) {
                     const QString rootItemPath = QFileInfo(localPath).absolutePath();
                     cachedHidden = cachedDotHiddenForDir(rootItemPath);
                 }
                 dotHiddenChecked = true;
             }
 
             // hide file if listed in ".hidden"
             if (cachedHidden && cachedHidden->listedFiles.find(name) != cachedHidden->listedFiles.cend()) {
                 item.setHidden();
             }
 
             qCDebug(KIO_CORE_DIRLISTER) << "Adding item: " << item.url();
             newItems.append(item);
         }
     }
 
     // sort by url using KFileItem::operator<
     std::sort(newItems.begin(), newItems.end());
 
     // Add the items sorted by url, needed by findByUrl
     dir->insertSortedItems(newItems);
 
     for (KCoreDirLister *kdl : listers) {
         kdl->d->addNewItems(url, newItems);
     }
 
     for (KCoreDirLister *kdl : listers) {
         kdl->d->emitItems();
     }
 }
 
 void KCoreDirListerCache::slotResult(KJob *j)
 {
 #ifdef DEBUG_CACHE
     // printDebug();
 #endif
 
     Q_ASSERT(j);
     KIO::ListJob *job = static_cast<KIO::ListJob *>(j);
     runningListJobs.remove(job);
 
     QUrl jobUrl(joburl(job));
     jobUrl = jobUrl.adjusted(QUrl::StripTrailingSlash); // need remove trailing slashes again, in case of redirections
 
     qCDebug(KIO_CORE_DIRLISTER) << "finished listing" << jobUrl;
 
     const auto dit = directoryData.find(jobUrl);
     if (dit == directoryData.end()) {
         qCWarning(KIO_CORE) << "Nothing found in directoryData for URL" << jobUrl;
 #ifndef NDEBUG
         printDebug();
 #endif
         Q_ASSERT(dit != directoryData.end());
         return;
     }
     KCoreDirListerCacheDirectoryData &dirData = *dit;
     if (dirData.listersCurrentlyListing.isEmpty()) {
         qCWarning(KIO_CORE) << "OOOOPS, nothing in directoryData.listersCurrentlyListing for" << jobUrl;
         // We're about to assert; dump the current state...
 #ifndef NDEBUG
         printDebug();
 #endif
         Q_ASSERT(!dirData.listersCurrentlyListing.isEmpty());
     }
     const QList<KCoreDirLister *> listers = dirData.listersCurrentlyListing;
 
     // move all listers to the holding list, do it before emitting
     // the signals to make sure it exists in KCoreDirListerCache in case someone
     // calls listDir during the signal emission
     Q_ASSERT(dirData.listersCurrentlyHolding.isEmpty());
     dirData.moveListersWithoutCachedItemsJob(jobUrl);
 
     if (job->error()) {
         bool errorShown = false;
         for (KCoreDirLister *kdl : listers) {
             kdl->d->jobDone(job);
             if (job->error() != KJob::KilledJobError) {
                 Q_EMIT kdl->jobError(job);
                 if (kdl->d->m_autoErrorHandling && !errorShown) {
                     errorShown = true; // do it only once
                     if (job->uiDelegate()) {
                         job->uiDelegate()->showErrorMessage();
                     }
                 }
             }
             const bool silent = job->property("_kdlc_silent").toBool();
             if (!silent) {
                 Q_EMIT kdl->listingDirCanceled(jobUrl);
             }
 
             if (kdl->d->numJobs() == 0) {
                 kdl->d->complete = true;
                 if (!silent) {
                     Q_EMIT kdl->canceled();
                 }
             }
         }
     } else {
         DirItem *dir = itemsInUse.value(jobUrl);
         Q_ASSERT(dir);
         dir->complete = true;
 
         for (KCoreDirLister *kdl : listers) {
             kdl->d->jobDone(job);
             Q_EMIT kdl->listingDirCompleted(jobUrl);
             if (kdl->d->numJobs() == 0) {
                 kdl->d->complete = true;
                 Q_EMIT kdl->completed();
             }
         }
     }
 
     // TODO: hmm, if there was an error and job is a parent of one or more
     // of the pending urls we should cancel it/them as well
     processPendingUpdates();
 
     if (job->property("need_another_update").toBool()) {
         updateDirectory(jobUrl);
     }
 
 #ifdef DEBUG_CACHE
     printDebug();
 #endif
 }
 
 void KCoreDirListerCache::slotRedirection(KIO::Job *j, const QUrl &url)
 {
     Q_ASSERT(j);
     KIO::ListJob *job = static_cast<KIO::ListJob *>(j);
 
     QUrl oldUrl(job->url()); // here we really need the old url!
     QUrl newUrl(url);
 
     // strip trailing slashes
     oldUrl = oldUrl.adjusted(QUrl::StripTrailingSlash);
     newUrl = newUrl.adjusted(QUrl::StripTrailingSlash);
 
     if (oldUrl == newUrl) {
         qCDebug(KIO_CORE_DIRLISTER) << "New redirection url same as old, giving up.";
         return;
     } else if (newUrl.isEmpty()) {
         qCDebug(KIO_CORE_DIRLISTER) << "New redirection url is empty, giving up.";
         return;
     }
 
     qCDebug(KIO_CORE_DIRLISTER) << oldUrl << "->" << newUrl;
 
 #ifdef DEBUG_CACHE
     // Can't do that here. KCoreDirListerCache::joburl() will use the new url already,
     // while our data structures haven't been updated yet -> assert fail.
     // printDebug();
 #endif
 
     // I don't think there can be dirItems that are children of oldUrl.
     // Am I wrong here? And even if so, we don't need to delete them, right?
     // DF: redirection happens before listDir emits any item. Makes little sense otherwise.
 
     // oldUrl cannot be in itemsCached because only completed items are moved there
     DirItem *dir = itemsInUse.take(oldUrl);
     Q_ASSERT(dir);
 
     DirectoryDataHash::iterator dit = directoryData.find(oldUrl);
     Q_ASSERT(dit != directoryData.end());
     KCoreDirListerCacheDirectoryData oldDirData = *dit;
     directoryData.erase(dit);
     Q_ASSERT(!oldDirData.listersCurrentlyListing.isEmpty());
     const QList<KCoreDirLister *> listers = oldDirData.listersCurrentlyListing;
     Q_ASSERT(!listers.isEmpty());
 
     for (KCoreDirLister *kdl : listers) {
         kdl->d->redirect(oldUrl, newUrl, false /*clear items*/);
     }
 
     // when a lister was stopped before the job emits the redirection signal, the old url will
     // also be in listersCurrentlyHolding
     const QList<KCoreDirLister *> holders = oldDirData.listersCurrentlyHolding;
     for (KCoreDirLister *kdl : holders) {
         kdl->jobStarted(job);
         // do it like when starting a new list-job that will redirect later
         // TODO: maybe don't emit started if there's an update running for newUrl already?
         Q_EMIT kdl->started(oldUrl);
 
         kdl->d->redirect(oldUrl, newUrl, false /*clear items*/);
     }
 
     const QList<KCoreDirLister *> allListers = listers + holders;
 
     DirItem *newDir = itemsInUse.value(newUrl);
     if (newDir) {
         qCDebug(KIO_CORE_DIRLISTER) << newUrl << "already in use";
 
         // only in this case there can newUrl already be in listersCurrentlyListing or listersCurrentlyHolding
         delete dir;
 
         // get the job if one's running for newUrl already (can be a list-job or an update-job), but
         // do not return this 'job', which would happen because of the use of redirectionURL()
         KIO::ListJob *oldJob = jobForUrl(newUrl, job);
 
         // listers of newUrl with oldJob: forget about the oldJob and use the already running one
         // which will be converted to an updateJob
         KCoreDirListerCacheDirectoryData &newDirData = directoryData[newUrl];
 
         QList<KCoreDirLister *> &curListers = newDirData.listersCurrentlyListing;
         if (!curListers.isEmpty()) {
             qCDebug(KIO_CORE_DIRLISTER) << "and it is currently listed";
 
             Q_ASSERT(oldJob); // ?!
 
             for (KCoreDirLister *kdl : std::as_const(curListers)) { // listers of newUrl
                 kdl->d->jobDone(oldJob);
 
                 kdl->jobStarted(job);
                 kdl->d->connectJob(job);
             }
 
             // append listers of oldUrl with newJob to listers of newUrl with oldJob
             for (KCoreDirLister *kdl : listers) {
                 curListers.append(kdl);
             }
         } else {
             curListers = listers;
         }
 
         if (oldJob) { // kill the old job, be it a list-job or an update-job
             killJob(oldJob);
         }
 
         // holders of newUrl: use the already running job which will be converted to an updateJob
         QList<KCoreDirLister *> &curHolders = newDirData.listersCurrentlyHolding;
         if (!curHolders.isEmpty()) {
             qCDebug(KIO_CORE_DIRLISTER) << "and it is currently held.";
 
             for (KCoreDirLister *kdl : std::as_const(curHolders)) { // holders of newUrl
                 kdl->jobStarted(job);
                 Q_EMIT kdl->started(newUrl);
             }
 
             // append holders of oldUrl to holders of newUrl
             for (KCoreDirLister *kdl : holders) {
                 curHolders.append(kdl);
             }
         } else {
             curHolders = holders;
         }
 
         // emit old items: listers, holders. NOT: newUrlListers/newUrlHolders, they already have them listed
         // TODO: make this a separate method?
         for (KCoreDirLister *kdl : allListers) {
             if (kdl->d->rootFileItem.isNull() && kdl->d->url == newUrl) {
                 kdl->d->rootFileItem = newDir->rootItem;
             }
 
             kdl->d->addNewItems(newUrl, newDir->lstItems);
             kdl->d->emitItems();
         }
     } else if ((newDir = itemsCached.take(newUrl))) {
         qCDebug(KIO_CORE_DIRLISTER) << newUrl << "is unused, but already in the cache.";
 
         delete dir;
         itemsInUse.insert(newUrl, newDir);
         KCoreDirListerCacheDirectoryData &newDirData = directoryData[newUrl];
         newDirData.listersCurrentlyListing = listers;
         newDirData.listersCurrentlyHolding = holders;
 
         // emit old items: listers, holders
         for (KCoreDirLister *kdl : allListers) {
             if (kdl->d->rootFileItem.isNull() && kdl->d->url == newUrl) {
                 kdl->d->rootFileItem = newDir->rootItem;
             }
 
             kdl->d->addNewItems(newUrl, newDir->lstItems);
             kdl->d->emitItems();
         }
     } else {
         qCDebug(KIO_CORE_DIRLISTER) << newUrl << "has not been listed yet.";
 
         dir->rootItem = KFileItem();
         dir->lstItems.clear();
         dir->redirect(newUrl);
         itemsInUse.insert(newUrl, dir);
         KCoreDirListerCacheDirectoryData &newDirData = directoryData[newUrl];
         newDirData.listersCurrentlyListing = listers;
         newDirData.listersCurrentlyHolding = holders;
 
         if (holders.isEmpty()) {
 #ifdef DEBUG_CACHE
             printDebug();
 #endif
             return; // only in this case the job doesn't need to be converted,
         }
     }
 
     // make the job an update job
     job->disconnect(this);
 
     connect(job, &KIO::ListJob::entries, this, &KCoreDirListerCache::slotUpdateEntries);
     connect(job, &KJob::result, this, &KCoreDirListerCache::slotUpdateResult);
 
     // FIXME: autoUpdate-Counts!!
 
 #ifdef DEBUG_CACHE
     printDebug();
 #endif
 }
 
 struct KCoreDirListerCache::ItemInUseChange {
     ItemInUseChange(const QUrl &old, const QUrl &newU, DirItem *di)
         : oldUrl(old)
         , newUrl(newU)
         , dirItem(di)
     {
     }
     QUrl oldUrl;
     QUrl newUrl;
     DirItem *dirItem;
 };
 
 void KCoreDirListerCache::renameDir(const QUrl &oldUrl, const QUrl &newUrl)
 {
     qCDebug(KIO_CORE_DIRLISTER) << oldUrl << "->" << newUrl;
 
     std::vector<ItemInUseChange> itemsToChange;
     std::set<KCoreDirLister *> listers;
 
     // Look at all dirs being listed/shown
     for (auto itu = itemsInUse.begin(), ituend = itemsInUse.end(); itu != ituend; ++itu) {
         DirItem *dir = itu.value();
         const QUrl &oldDirUrl = itu.key();
         qCDebug(KIO_CORE_DIRLISTER) << "itemInUse:" << oldDirUrl;
         // Check if this dir is oldUrl, or a subfolder of it
         if (oldDirUrl == oldUrl || oldUrl.isParentOf(oldDirUrl)) {
             // TODO should use KUrl::cleanpath like isParentOf does
             QString relPath = oldDirUrl.path().mid(oldUrl.path().length() + 1);
 
             QUrl newDirUrl(newUrl); // take new base
             if (!relPath.isEmpty()) {
                 newDirUrl.setPath(Utils::concatPaths(newDirUrl.path(), relPath)); // add unchanged relative path
             }
             qCDebug(KIO_CORE_DIRLISTER) << "new url=" << newDirUrl;
 
             // Update URL in dir item and in itemsInUse
             dir->redirect(newDirUrl);
 
             itemsToChange.emplace_back(oldDirUrl.adjusted(QUrl::StripTrailingSlash), newDirUrl.adjusted(QUrl::StripTrailingSlash), dir);
             // Rename all items under that dir
             // If all items of the directory change the same part of their url, the order is not
             // changed, therefore just change it in the list.
             for (KFileItem &item : dir->lstItems) {
                 const KFileItem oldItem = item;
                 KFileItem newItem = oldItem;
                 const QUrl &oldItemUrl = oldItem.url();
                 QUrl newItemUrl(oldItemUrl);
                 newItemUrl.setPath(Utils::concatPaths(newDirUrl.path(), oldItemUrl.fileName()));
                 qCDebug(KIO_CORE_DIRLISTER) << "renaming" << oldItemUrl << "to" << newItemUrl;
                 newItem.setUrl(newItemUrl);
 
                 listers.merge(emitRefreshItem(oldItem, newItem));
                 // Change the item
                 item.setUrl(newItemUrl);
             }
         }
     }
 
     for (KCoreDirLister *kdl : listers) {
         kdl->d->emitItems();
     }
 
     // Do the changes to itemsInUse out of the loop to avoid messing up iterators,
     // and so that emitRefreshItem can find the stuff in the hash.
     for (const ItemInUseChange &i : itemsToChange) {
         itemsInUse.remove(i.oldUrl);
         itemsInUse.insert(i.newUrl, i.dirItem);
     }
     // Now that all the caches are updated and consistent, emit the redirection.
     for (const ItemInUseChange &i : itemsToChange) {
         emitRedirections(QUrl(i.oldUrl), QUrl(i.newUrl));
     }
     // Is oldUrl a directory in the cache?
     // Remove any child of oldUrl from the cache - even if the renamed dir itself isn't in it!
     removeDirFromCache(oldUrl);
     // TODO rename, instead.
 }
 
 // helper for renameDir, not used for redirections from KIO::listDir().
 void KCoreDirListerCache::emitRedirections(const QUrl &_oldUrl, const QUrl &_newUrl)
 {
     qCDebug(KIO_CORE_DIRLISTER) << _oldUrl << "->" << _newUrl;
     const QUrl oldUrl = _oldUrl.adjusted(QUrl::StripTrailingSlash);
     const QUrl newUrl = _newUrl.adjusted(QUrl::StripTrailingSlash);
 
     KIO::ListJob *job = jobForUrl(oldUrl);
     if (job) {
         killJob(job);
     }
 
     // Check if we were listing this dir. Need to abort and restart with new name in that case.
     DirectoryDataHash::iterator dit = directoryData.find(oldUrl);
     if (dit == directoryData.end()) {
         return;
     }
     const QList<KCoreDirLister *> listers = (*dit).listersCurrentlyListing;
     const QList<KCoreDirLister *> holders = (*dit).listersCurrentlyHolding;
 
     KCoreDirListerCacheDirectoryData &newDirData = directoryData[newUrl];
 
     // Tell the world that the job listing the old url is dead.
     for (KCoreDirLister *kdl : listers) {
         if (job) {
             kdl->d->jobDone(job);
         }
         Q_EMIT kdl->listingDirCanceled(oldUrl);
     }
     newDirData.listersCurrentlyListing += listers;
 
     // Check if we are currently displaying this directory (odds opposite wrt above)
     for (KCoreDirLister *kdl : holders) {
         if (job) {
             kdl->d->jobDone(job);
         }
     }
     newDirData.listersCurrentlyHolding += holders;
     directoryData.erase(dit);
 
     if (!listers.isEmpty()) {
         updateDirectory(newUrl);
 
         // Tell the world about the new url
         for (KCoreDirLister *kdl : listers) {
             Q_EMIT kdl->started(newUrl);
         }
     }
 
     // And notify the dirlisters of the redirection
     for (KCoreDirLister *kdl : holders) {
         kdl->d->redirect(oldUrl, newUrl, true /*keep items*/);
     }
 }
 
 void KCoreDirListerCache::removeDirFromCache(const QUrl &dir)
 {
     qCDebug(KIO_CORE_DIRLISTER) << dir;
     const QList<QUrl> cachedDirs = itemsCached.keys(); // seems slow, but there's no qcache iterator...
     for (const QUrl &cachedDir : cachedDirs) {
         if (dir == cachedDir || dir.isParentOf(cachedDir)) {
             itemsCached.remove(cachedDir);
         }
     }
 }
 
 void KCoreDirListerCache::slotUpdateEntries(KIO::Job *job, const KIO::UDSEntryList &list)
 {
     runningListJobs[static_cast<KIO::ListJob *>(job)] += list;
 }
 
 void KCoreDirListerCache::slotUpdateResult(KJob *j)
 {
     Q_ASSERT(j);
     KIO::ListJob *job = static_cast<KIO::ListJob *>(j);
 
     QUrl jobUrl(joburl(job));
     jobUrl = jobUrl.adjusted(QUrl::StripTrailingSlash); // need remove trailing slashes again, in case of redirections
 
     qCDebug(KIO_CORE_DIRLISTER) << "finished update" << jobUrl;
 
     KCoreDirListerCacheDirectoryData &dirData = directoryData[jobUrl];
     // Collect the dirlisters which were listing the URL using that ListJob
     // plus those that were already holding that URL - they all get updated.
     dirData.moveListersWithoutCachedItemsJob(jobUrl);
     const QList<KCoreDirLister *> listers = dirData.listersCurrentlyHolding + dirData.listersCurrentlyListing;
 
     // once we are updating dirs that are only in the cache this will fail!
     Q_ASSERT(!listers.isEmpty());
 
     if (job->error()) {
         for (KCoreDirLister *kdl : listers) {
             kdl->d->jobDone(job);
 
             // don't bother the user: no jobError signal emitted
 
             const bool silent = job->property("_kdlc_silent").toBool();
             if (!silent) {
                 Q_EMIT kdl->listingDirCanceled(jobUrl);
             }
             if (kdl->d->numJobs() == 0) {
                 kdl->d->complete = true;
                 if (!silent) {
                     Q_EMIT kdl->canceled();
                 }
             }
         }
 
         runningListJobs.remove(job);
 
         // TODO: if job is a parent of one or more
         // of the pending urls we should cancel them
         processPendingUpdates();
         return;
     }
 
     DirItem *dir = itemsInUse.value(jobUrl, nullptr);
     if (!dir) {
         qCWarning(KIO_CORE) << "Internal error: itemsInUse did not contain" << jobUrl;
 #ifndef NDEBUG
         printDebug();
 #endif
         Q_ASSERT(dir);
     } else {
         dir->complete = true;
     }
 
     // check if anyone wants the MIME types immediately
     bool delayedMimeTypes = true;
     for (const KCoreDirLister *kdl : listers) {
         delayedMimeTypes &= kdl->d->delayedMimeTypes;
     }
 
     typedef QHash<QString, KFileItem> FileItemHash; // fileName -> KFileItem
     FileItemHash fileItems;
 
     // Fill the hash from the old list of items. We'll remove entries as we see them
     // in the new listing, and the resulting hash entries will be the deleted items.
     for (const KFileItem &item : std::as_const(dir->lstItems)) {
         fileItems.insert(item.name(), item);
     }
 
     CacheHiddenFile *cachedHidden = nullptr;
     bool dotHiddenChecked = false;
     const KIO::UDSEntryList &buf = runningListJobs.value(job);
     KFileItemList newItems;
     for (const auto &entry : buf) {
         // Form the complete url
         KFileItem item(entry, jobUrl, delayedMimeTypes, true);
 
         const QString name = item.name();
         Q_ASSERT(!name.isEmpty()); // A KIO worker setting an empty UDS_NAME is utterly broken, fix the KIO worker!
 
         // we duplicate the check for dotdot here, to avoid iterating over
         // all items again and checking in matchesFilter() that way.
         if (name.isEmpty() || name == QLatin1String("..")) {
             continue;
         }
 
         if (name == QLatin1Char('.')) {
             // if the update was started before finishing the original listing
             // there is no root item yet
             if (dir->rootItem.isNull()) {
                 dir->rootItem = item;
 
                 for (KCoreDirLister *kdl : listers) {
                     if (kdl->d->rootFileItem.isNull() && kdl->d->url == jobUrl) {
                         kdl->d->rootFileItem = dir->rootItem;
                     }
                 }
             }
             continue;
         } else {
             // get the names of the files listed in ".hidden", if it exists and is a local file
             if (!dotHiddenChecked) {
                 const QString localPath = item.localPath();
                 if (!localPath.isEmpty()) {
                     const QString rootItemPath = QFileInfo(localPath).absolutePath();
                     cachedHidden = cachedDotHiddenForDir(rootItemPath);
                 }
                 dotHiddenChecked = true;
             }
         }
 
         // hide file if listed in ".hidden"
         if (cachedHidden && cachedHidden->listedFiles.find(name) != cachedHidden->listedFiles.cend()) {
             item.setHidden();
         }
 
         // Find this item
         FileItemHash::iterator fiit = fileItems.find(item.name());
         if (fiit != fileItems.end()) {
             const KFileItem tmp = fiit.value();
             auto pru_it = pendingRemoteUpdates.find(tmp);
             const bool inPendingRemoteUpdates = pru_it != pendingRemoteUpdates.end();
 
             // check if something changed for this file, using KFileItem::cmp()
             if (!tmp.cmp(item) || inPendingRemoteUpdates) {
                 if (inPendingRemoteUpdates) {
                     pendingRemoteUpdates.erase(pru_it);
                 }
 
                 qCDebug(KIO_CORE_DIRLISTER) << "file changed:" << tmp.name();
 
                 reinsert(item, tmp.url());
                 for (KCoreDirLister *kdl : listers) {
                     kdl->d->addRefreshItem(jobUrl, tmp, item);
                 }
             }
             // Seen, remove
             fileItems.erase(fiit);
         } else { // this is a new file
             qCDebug(KIO_CORE_DIRLISTER) << "new file:" << name;
             newItems.append(item);
         }
     }
 
     // sort by url using KFileItem::operator<
     std::sort(newItems.begin(), newItems.end());
 
     // Add the items sorted by url, needed by findByUrl
     dir->insertSortedItems(newItems);
 
     for (KCoreDirLister *kdl : listers) {
         kdl->d->addNewItems(jobUrl, newItems);
     }
 
     runningListJobs.remove(job);
 
     if (!fileItems.isEmpty()) {
         deleteUnmarkedItems(listers, dir->lstItems, fileItems);
     }
 
     for (KCoreDirLister *kdl : listers) {
         kdl->d->emitItems();
 
         kdl->d->jobDone(job);
         Q_EMIT kdl->listingDirCompleted(jobUrl);
         if (kdl->d->numJobs() == 0) {
             kdl->d->complete = true;
             Q_EMIT kdl->completed();
         }
     }
 
     // TODO: hmm, if there was an error and job is a parent of one or more
     // of the pending urls we should cancel it/them as well
     processPendingUpdates();
 
     if (job->property("need_another_update").toBool()) {
         updateDirectory(jobUrl);
     }
 }
 
 // private
 
 KIO::ListJob *KCoreDirListerCache::jobForUrl(const QUrl &url, KIO::ListJob *not_job)
 {
     for (auto it = runningListJobs.cbegin(); it != runningListJobs.cend(); ++it) {
         KIO::ListJob *job = it.key();
         const QUrl jobUrl = joburl(job).adjusted(QUrl::StripTrailingSlash);
 
         if (jobUrl == url && job != not_job) {
             return job;
         }
     }
     return nullptr;
 }
 
 const QUrl &KCoreDirListerCache::joburl(KIO::ListJob *job)
 {
     if (job->redirectionUrl().isValid()) {
         return job->redirectionUrl();
     } else {
         return job->url();
     }
 }
 
 void KCoreDirListerCache::killJob(KIO::ListJob *job)
 {
     runningListJobs.remove(job);
     job->disconnect(this);
     job->kill();
 }
 
 void KCoreDirListerCache::deleteUnmarkedItems(const QList<KCoreDirLister *> &listers,
                                               QList<KFileItem> &lstItems,
                                               const QHash<QString, KFileItem> &itemsToDelete)
 {
     // Make list of deleted items (for emitting)
     KFileItemList deletedItems;
     deletedItems.reserve(itemsToDelete.size());
     for (auto kit = itemsToDelete.cbegin(), endIt = itemsToDelete.cend(); kit != endIt; ++kit) {
         const KFileItem item = kit.value();
         deletedItems.append(item);
         qCDebug(KIO_CORE_DIRLISTER) << "deleted:" << item.name() << item;
     }
 
     // Delete all remaining items
     auto it = std::remove_if(lstItems.begin(), lstItems.end(), [&itemsToDelete](const KFileItem &item) {
         return itemsToDelete.contains(item.name());
     });
     lstItems.erase(it, lstItems.end());
 
     itemsDeleted(listers, deletedItems);
 }
 
 void KCoreDirListerCache::itemsDeleted(const QList<KCoreDirLister *> &listers, const KFileItemList &deletedItems)
 {
     for (KCoreDirLister *kdl : listers) {
         kdl->d->emitItemsDeleted(deletedItems);
     }
 
     for (const KFileItem &item : deletedItems) {
         if (item.isDir()) {
             deleteDir(item.url());
         }
     }
 }
 
 void KCoreDirListerCache::deleteDir(const QUrl &_dirUrl)
 {
     qCDebug(KIO_CORE_DIRLISTER) << _dirUrl;
     // unregister and remove the children of the deleted item.
     // Idea: tell all the KCoreDirListers that they should forget the dir
     //       and then remove it from the cache.
 
     QUrl dirUrl(_dirUrl.adjusted(QUrl::StripTrailingSlash));
 
     // Separate itemsInUse iteration and calls to forgetDirs (which modify itemsInUse)
     QList<QUrl> affectedItems;
 
     auto itu = itemsInUse.cbegin();
     const auto ituend = itemsInUse.cend();
     for (; itu != ituend; ++itu) {
         const QUrl &deletedUrl = itu.key();
         if (dirUrl == deletedUrl || dirUrl.isParentOf(deletedUrl)) {
             affectedItems.append(deletedUrl);
         }
     }
 
     for (const QUrl &deletedUrl : std::as_const(affectedItems)) {
         // stop all jobs for deletedUrlStr
         auto dit = directoryData.constFind(deletedUrl);
         if (dit != directoryData.cend()) {
             // we need a copy because stop modifies the list
             const QList<KCoreDirLister *> listers = (*dit).listersCurrentlyListing;
             for (KCoreDirLister *kdl : listers) {
                 stopListingUrl(kdl, deletedUrl);
             }
             // tell listers holding deletedUrl to forget about it
             // this will stop running updates for deletedUrl as well
 
             // we need a copy because forgetDirs modifies the list
             const QList<KCoreDirLister *> holders = (*dit).listersCurrentlyHolding;
             for (KCoreDirLister *kdl : holders) {
                 // lister's root is the deleted item
                 if (kdl->d->url == deletedUrl) {
                     // tell the view first. It might need the subdirs' items (which forgetDirs will delete)
                     if (!kdl->d->rootFileItem.isNull()) {
                         Q_EMIT kdl->itemsDeleted(KFileItemList{kdl->d->rootFileItem});
                     }
                     forgetDirs(kdl);
                     kdl->d->rootFileItem = KFileItem();
                 } else {
                     const bool treeview = kdl->d->lstDirs.count() > 1;
                     if (!treeview) {
                         Q_EMIT kdl->clear();
                         kdl->d->lstDirs.clear();
                     } else {
                         kdl->d->lstDirs.removeAll(deletedUrl);
                     }
 
                     forgetDirs(kdl, deletedUrl, treeview);
                 }
             }
         }
 
         // delete the entry for deletedUrl - should not be needed, it's in
         // items cached now
         int count = itemsInUse.remove(deletedUrl);
         Q_ASSERT(count == 0);
         Q_UNUSED(count); // keep gcc "unused variable" complaining quiet when in release mode
     }
 
     // remove the children from the cache
     removeDirFromCache(dirUrl);
 }
 
 // delayed updating of files, FAM is flooding us with events
 void KCoreDirListerCache::processPendingUpdates()
 {
     std::set<KCoreDirLister *> listers;
     QList<QUrl> removedUrls;
     for (const QString &file : pendingUpdates) { // always a local path
         qCDebug(KIO_CORE_DIRLISTER) << file;
         QUrl u = QUrl::fromLocalFile(file);
         KFileItem item = findByUrl(nullptr, u); // search all items
         if (!item.isNull()) {
             // we need to refresh the item, because e.g. the permissions can have changed.
             KFileItem oldItem = item;
             item.refresh();
 
             if (!oldItem.cmp(item)) {
                 if (!item.exists()) {
                     removedUrls.append(oldItem.url());
                 } else {
                     reinsert(item, oldItem.url());
                 }
                 listers.merge(emitRefreshItem(oldItem, item));
             }
         }
     }
     pendingUpdates.clear();
     for (KCoreDirLister *kdl : listers) {
         kdl->d->emitItems();
     }
 
     // clean orphan KFileItem, after events were emitted
     for (const auto &removedUrl : removedUrls) {
         remove(removedUrl);
     }
 
     // Directories in need of updating
     for (const QString &dir : pendingDirectoryUpdates) {
         updateDirectory(QUrl::fromLocalFile(dir));
     }
     pendingDirectoryUpdates.clear();
 }
 
 #ifndef NDEBUG
 void KCoreDirListerCache::printDebug()
 {
     qCDebug(KIO_CORE_DIRLISTER) << "Items in use:";
     auto itu = itemsInUse.constBegin();
     const auto ituend = itemsInUse.constEnd();
     for (; itu != ituend; ++itu) {
         qCDebug(KIO_CORE_DIRLISTER) << "   " << itu.key() << "URL:" << itu.value()->url
                                     << "rootItem:" << (!itu.value()->rootItem.isNull() ? itu.value()->rootItem.url() : QUrl())
                                     << "autoUpdates refcount:" << itu.value()->autoUpdates << "complete:" << itu.value()->complete
                                     << QStringLiteral("with %1 items.").arg(itu.value()->lstItems.count());
     }
 
     QList<KCoreDirLister *> listersWithoutJob;
     qCDebug(KIO_CORE_DIRLISTER) << "Directory data:";
     auto dit = directoryData.constBegin();
     for (; dit != directoryData.constEnd(); ++dit) {
         QString list;
         const QList<KCoreDirLister *> listers = (*dit).listersCurrentlyListing;
         for (KCoreDirLister *listit : listers) {
             list += QLatin1String(" 0x") + QString::number(reinterpret_cast<qlonglong>(listit), 16);
         }
         qCDebug(KIO_CORE_DIRLISTER) << "  " << dit.key() << listers.count() << "listers:" << list;
         for (KCoreDirLister *listit : listers) {
             if (!listit->d->m_cachedItemsJobs.isEmpty()) {
                 qCDebug(KIO_CORE_DIRLISTER) << "  Lister" << listit << "has CachedItemsJobs" << listit->d->m_cachedItemsJobs;
             } else if (KIO::ListJob *listJob = jobForUrl(dit.key())) {
                 qCDebug(KIO_CORE_DIRLISTER) << "  Lister" << listit << "has ListJob" << listJob;
             } else {
                 listersWithoutJob.append(listit);
             }
         }
 
         list.clear();
         const QList<KCoreDirLister *> holders = (*dit).listersCurrentlyHolding;
         for (KCoreDirLister *listit : holders) {
             list += QLatin1String(" 0x") + QString::number(reinterpret_cast<qlonglong>(listit), 16);
         }
         qCDebug(KIO_CORE_DIRLISTER) << "  " << dit.key() << holders.count() << "holders:" << list;
     }
 
     QMap<KIO::ListJob *, KIO::UDSEntryList>::Iterator jit = runningListJobs.begin();
     qCDebug(KIO_CORE_DIRLISTER) << "Jobs:";
     for (; jit != runningListJobs.end(); ++jit) {
         qCDebug(KIO_CORE_DIRLISTER) << "   " << jit.key() << "listing" << joburl(jit.key()) << ":" << (*jit).count() << "entries.";
     }
 
     qCDebug(KIO_CORE_DIRLISTER) << "Items in cache:";
     const QList<QUrl> cachedDirs = itemsCached.keys();
     for (const QUrl &cachedDir : cachedDirs) {
         DirItem *dirItem = itemsCached.object(cachedDir);
         qCDebug(KIO_CORE_DIRLISTER) << "   " << cachedDir
                                     << "rootItem:" << (!dirItem->rootItem.isNull() ? dirItem->rootItem.url().toString() : QStringLiteral("NULL")) << "with"
                                     << dirItem->lstItems.count() << "items.";
     }
 
     // Abort on listers without jobs -after- showing the full dump. Easier debugging.
     for (KCoreDirLister *listit : std::as_const(listersWithoutJob)) {
         qCWarning(KIO_CORE) << "Fatal Error: HUH? Lister" << listit << "is supposed to be listing, but has no job!";
         abort();
     }
 }
 #endif
 
 KCoreDirLister::KCoreDirLister(QObject *parent)
     : QObject(parent)
     , d(new KCoreDirListerPrivate(this))
 {
     qCDebug(KIO_CORE_DIRLISTER) << "+KCoreDirLister";
 
     d->complete = true;
 
     setAutoUpdate(true);
     setDirOnlyMode(false);
     setShowHiddenFiles(false);
 }
 
 KCoreDirLister::~KCoreDirLister()
 {
     qCDebug(KIO_CORE_DIRLISTER) << "~KCoreDirLister" << this;
 
     // Stop all running jobs, remove lister from lists
     if (!qApp->closingDown()) {
         stop();
         s_kDirListerCache.localData().forgetDirs(this);
     }
 }
 
 // TODO KF6: remove bool ret val, it's always true
 bool KCoreDirLister::openUrl(const QUrl &_url, OpenUrlFlags _flags)
 {
     // emit the current changes made to avoid an inconsistent treeview
     if (d->hasPendingChanges && (_flags & Keep)) {
         emitChanges();
     }
 
     d->hasPendingChanges = false;
 
     return s_kDirListerCache.localData().listDir(this, _url, _flags & Keep, _flags & Reload);
 }
 
 void KCoreDirLister::stop()
 {
     s_kDirListerCache.localData().stop(this);
 }
 
 void KCoreDirLister::stop(const QUrl &_url)
 {
     s_kDirListerCache.localData().stopListingUrl(this, _url);
 }
 
 void KCoreDirLister::forgetDirs(const QUrl &_url)
 {
     s_kDirListerCache.localData().forgetDirs(this, _url, true);
 }
 
 bool KCoreDirLister::autoUpdate() const
 {
     return d->autoUpdate;
 }
 
 void KCoreDirLister::setAutoUpdate(bool enable)
 {
     if (d->autoUpdate == enable) {
         return;
     }
 
     d->autoUpdate = enable;
     s_kDirListerCache.localData().setAutoUpdate(this, enable);
 }
 
 bool KCoreDirLister::showHiddenFiles() const
 {
     return d->settings.isShowingDotFiles;
 }
 
 void KCoreDirLister::setShowHiddenFiles(bool setShowHiddenFiles)
 {
     if (d->settings.isShowingDotFiles == setShowHiddenFiles) {
         return;
     }
 
     d->prepareForSettingsChange();
     d->settings.isShowingDotFiles = setShowHiddenFiles;
 }
 
 bool KCoreDirLister::dirOnlyMode() const
 {
     return d->settings.dirOnlyMode;
 }
 
 void KCoreDirLister::setDirOnlyMode(bool dirsOnly)
 {
     if (d->settings.dirOnlyMode == dirsOnly) {
         return;
     }
 
     d->prepareForSettingsChange();
     d->settings.dirOnlyMode = dirsOnly;
 }
 
 bool KCoreDirLister::requestMimeTypeWhileListing() const
 {
     return d->requestMimeTypeWhileListing;
 }
 
 void KCoreDirLister::setRequestMimeTypeWhileListing(bool request)
 {
     if (d->requestMimeTypeWhileListing == request) {
         return;
     }
 
     d->requestMimeTypeWhileListing = request;
     if (d->requestMimeTypeWhileListing) {
         // Changing from request off to on, clear any cached items associated
         // with this lister so we re-request them and get the mimetype as well.
         // If we do not, we risk caching items that have no mime type.
         s_kDirListerCache.localData().forgetDirs(this);
     }
 }
 
 QUrl KCoreDirLister::url() const
 {
     return d->url;
 }
 
 QList<QUrl> KCoreDirLister::directories() const
 {
     return d->lstDirs;
 }
 
 void KCoreDirLister::emitChanges()
 {
     d->emitChanges();
 }
 
 void KCoreDirListerPrivate::emitChanges()
 {
     if (!hasPendingChanges) {
         return;
     }
 
     // reset 'hasPendingChanges' now, in case of recursion
     // (testcase: enabling recursive scan in ktorrent, #174920)
     hasPendingChanges = false;
 
     const KCoreDirListerPrivate::FilterSettings newSettings = settings;
     settings = oldSettings; // temporarily
 
     // Fill hash with all items that are currently visible
     std::set<QString> oldVisibleItems;
     for (const QUrl &dir : std::as_const(lstDirs)) {
         const QList<KFileItem> *itemList = s_kDirListerCache.localData().itemsForDir(dir);
         if (!itemList) {
             continue;
         }
 
         for (const KFileItem &item : *itemList) {
             if (isItemVisible(item) && matchesMimeFilter(item)) {
                 oldVisibleItems.insert(item.name());
             }
         }
     }
 
     settings = newSettings;
 
     const QList<QUrl> dirs = lstDirs;
     for (const QUrl &dir : dirs) {
         KFileItemList deletedItems;
 
         const QList<KFileItem> *itemList = s_kDirListerCache.localData().itemsForDir(dir);
         if (!itemList) {
             continue;
         }
 
         for (const auto &item : *itemList) {
             const QString text = item.text();
             if (text == QLatin1Char('.') || text == QLatin1String("..")) {
                 continue;
             }
             const bool wasVisible = oldVisibleItems.find(item.name()) != oldVisibleItems.cend();
             const bool mimeFiltered = matchesMimeFilter(item);
             const bool nowVisible = isItemVisible(item) && mimeFiltered;
             if (nowVisible && !wasVisible) {
                 addNewItem(dir, item); // takes care of emitting newItem or itemsFilteredByMime
             } else if (!nowVisible && wasVisible) {
                 if (!mimeFiltered) {
                     lstMimeFilteredItems.append(item);
                 }
                 deletedItems.append(item);
             }
         }
         if (!deletedItems.isEmpty()) {
             Q_EMIT q->itemsDeleted(deletedItems);
         }
         emitItems();
     }
     oldSettings = settings;
 }
 
 void KCoreDirLister::updateDirectory(const QUrl &dirUrl)
 {
     s_kDirListerCache.localData().updateDirectory(dirUrl);
 }
 
 bool KCoreDirLister::isFinished() const
 {
     return d->complete;
 }
 
 KFileItem KCoreDirLister::rootItem() const
 {
     return d->rootFileItem;
 }
 
 KFileItem KCoreDirLister::findByUrl(const QUrl &url) const
 {
     return s_kDirListerCache.localData().findByUrl(this, url);
 }
 
 KFileItem KCoreDirLister::findByName(const QString &name) const
 {
     return s_kDirListerCache.localData().findByName(this, name);
 }
 
 // ================ public filter methods ================ //
 
 void KCoreDirLister::setNameFilter(const QString &nameFilter)
 {
     if (d->nameFilter == nameFilter) {
         return;
     }
 
     d->prepareForSettingsChange();
 
     d->settings.lstFilters.clear();
     d->nameFilter = nameFilter;
     // Split on white space
     const QStringList list = nameFilter.split(QLatin1Char(' '), Qt::SkipEmptyParts);
     for (const QString &filter : list) {
         d->settings.lstFilters.append(QRegularExpression(QRegularExpression::wildcardToRegularExpression(filter), QRegularExpression::CaseInsensitiveOption));
     }
 }
 
 QString KCoreDirLister::nameFilter() const
 {
     return d->nameFilter;
 }
 
 void KCoreDirLister::setMimeFilter(const QStringList &mimeFilter)
 {
     if (d->settings.mimeFilter == mimeFilter) {
         return;
     }
 
     d->prepareForSettingsChange();
     if (mimeFilter.contains(QLatin1String("application/octet-stream")) || mimeFilter.contains(QLatin1String("all/allfiles"))) { // all files
         d->settings.mimeFilter.clear();
     } else {
         d->settings.mimeFilter = mimeFilter;
     }
 }
 
 void KCoreDirLister::setMimeExcludeFilter(const QStringList &mimeExcludeFilter)
 {
     if (d->settings.mimeExcludeFilter == mimeExcludeFilter) {
         return;
     }
 
     d->prepareForSettingsChange();
     d->settings.mimeExcludeFilter = mimeExcludeFilter;
 }
 
 void KCoreDirLister::clearMimeFilter()
 {
     d->prepareForSettingsChange();
     d->settings.mimeFilter.clear();
     d->settings.mimeExcludeFilter.clear();
 }
 
 QStringList KCoreDirLister::mimeFilters() const
 {
     return d->settings.mimeFilter;
 }
 
 // ================ protected methods ================ //
 
 bool KCoreDirListerPrivate::matchesFilter(const KFileItem &item) const
 {
     Q_ASSERT(!item.isNull());
 
     if (item.text() == QLatin1String("..")) {
         return false;
     }
 
     if (!settings.isShowingDotFiles && item.isHidden()) {
         return false;
     }
 
     if (item.isDir() || settings.lstFilters.isEmpty()) {
         return true;
     }
 
     return std::any_of(settings.lstFilters.cbegin(), settings.lstFilters.cend(), [&item](const QRegularExpression &filter) {
         return filter.match(item.text()).hasMatch();
     });
 }
 
 bool KCoreDirListerPrivate::matchesMimeFilter(const KFileItem &item) const
 {
     Q_ASSERT(!item.isNull());
     // Don't lose time determining the MIME type if there is no filter
     if (settings.mimeFilter.isEmpty() && settings.mimeExcludeFilter.isEmpty()) {
         return true;
     }
     return doMimeFilter(item.mimetype(), settings.mimeFilter) && doMimeExcludeFilter(item.mimetype(), settings.mimeExcludeFilter);
 }
 
 bool KCoreDirListerPrivate::doMimeFilter(const QString &mime, const QStringList &filters) const
 {
     if (filters.isEmpty()) {
         return true;
     }
 
     QMimeDatabase db;
     const QMimeType mimeptr = db.mimeTypeForName(mime);
     if (!mimeptr.isValid()) {
         return false;
     }
 
     qCDebug(KIO_CORE_DIRLISTER) << "doMimeFilter: investigating:" << mimeptr.name();
     return std::any_of(filters.cbegin(), filters.cend(), [&mimeptr](const QString &filter) {
         return mimeptr.inherits(filter);
     });
 }
 
 bool KCoreDirListerPrivate::doMimeExcludeFilter(const QString &mime, const QStringList &filters) const
 {
     return !std::any_of(filters.cbegin(), filters.cend(), [&mime](const QString &filter) {
         return mime == filter;
     });
 }
 
 // ================= private methods ================= //
 
 void KCoreDirListerPrivate::addNewItem(const QUrl &directoryUrl, const KFileItem &item)
 {
     if (!isItemVisible(item)) {
         return; // No reason to continue... bailing out here prevents a MIME type scan.
     }
 
     qCDebug(KIO_CORE_DIRLISTER) << "in" << directoryUrl << "item:" << item.url();
 
     if (matchesMimeFilter(item)) {
         Q_ASSERT(!item.isNull());
         lstNewItems[directoryUrl].append(item); // items not filtered
     } else {
         Q_ASSERT(!item.isNull());
         lstMimeFilteredItems.append(item); // only filtered by MIME type
     }
 }
 
 void KCoreDirListerPrivate::addNewItems(const QUrl &directoryUrl, const QList<KFileItem> &items)
 {
     // TODO: make this faster - test if we have a filter at all first
     // DF: was this profiled? The matchesFoo() functions should be fast, w/o filters...
     // Of course if there is no filter and we can do a range-insertion instead of a loop, that might be good.
     for (const auto &item : items) {
         addNewItem(directoryUrl, item);
     }
 }
 
 void KCoreDirListerPrivate::addRefreshItem(const QUrl &directoryUrl, const KFileItem &oldItem, const KFileItem &item)
 {
     // Refreshing the root item "." of a dirlister
     if (directoryUrl == item.url()) {
         lstRefreshItems.append({oldItem, item});
         return;
     }
 
     const bool refreshItemWasFiltered = !isItemVisible(oldItem) || !matchesMimeFilter(oldItem);
     if (item.exists() && isItemVisible(item) && matchesMimeFilter(item)) {
         if (refreshItemWasFiltered) {
             Q_ASSERT(!item.isNull());
             lstNewItems[directoryUrl].append(item);
         } else {
             Q_ASSERT(!item.isNull());
             lstRefreshItems.append(qMakePair(oldItem, item));
         }
     } else if (!refreshItemWasFiltered) {
         // notify the user that the MIME type of a file changed that doesn't match
         // a filter or does match an exclude filter
         // This also happens when renaming foo to .foo and dot files are hidden (#174721)
         Q_ASSERT(!oldItem.isNull());
         lstRemoveItems.append(oldItem);
     }
 }
 
 void KCoreDirListerPrivate::emitItems()
 {
     if (!lstNewItems.empty()) {
         for (auto it = lstNewItems.cbegin(); it != lstNewItems.cend(); ++it) {
             const auto &val = it.value();
             Q_EMIT q->itemsAdded(it.key(), val);
             Q_EMIT q->newItems(val); // compat
         }
         lstNewItems.clear();
     }
 
     if (!lstMimeFilteredItems.empty()) {
         Q_EMIT q->itemsFilteredByMime(lstMimeFilteredItems);
         lstMimeFilteredItems.clear();
     }
 
     if (!lstRefreshItems.empty()) {
         Q_EMIT q->refreshItems(lstRefreshItems);
         lstRefreshItems.clear();
     }
 
     if (!lstRemoveItems.empty()) {
         Q_EMIT q->itemsDeleted(lstRemoveItems);
         lstRemoveItems.clear();
     }
 }
 
 bool KCoreDirListerPrivate::isItemVisible(const KFileItem &item) const
 {
     // Note that this doesn't include MIME type filters, because
     // of the itemsFilteredByMime signal. Filtered-by-MIME-type items are
     // considered "visible", they are just visible via a different signal...
     return (!settings.dirOnlyMode || item.isDir()) && matchesFilter(item);
 }
 
 void KCoreDirListerPrivate::emitItemsDeleted(const KFileItemList &itemsList)
 {
     KFileItemList items;
     std::copy_if(itemsList.cbegin(), itemsList.cend(), std::back_inserter(items), [this](const KFileItem &item) {
         return isItemVisible(item) || matchesMimeFilter(item);
     });
     if (!items.isEmpty()) {
         Q_EMIT q->itemsDeleted(items);
     }
 }
 
 KCoreDirListerPrivate::KCoreDirListerPrivate(KCoreDirLister *qq)
     : q(qq)
 {
 }
 
 // ================ private slots ================ //
 
 void KCoreDirListerPrivate::slotInfoMessage(KJob *, const QString &message)
 {
     Q_EMIT q->infoMessage(message);
 }
 
 void KCoreDirListerPrivate::slotPercent(KJob *job, unsigned long pcnt)
 {
     jobData[static_cast<KIO::ListJob *>(job)].percent = pcnt;
 
     int result = 0;
 
     KIO::filesize_t size = 0;
 
     for (auto dataIt = jobData.cbegin(); dataIt != jobData.cend(); ++dataIt) {
         const JobData &data = dataIt.value();
         result += data.percent * data.totalSize;
         size += data.totalSize;
     }
 
     if (size != 0) {
         result /= size;
     } else {
         result = 100;
     }
     Q_EMIT q->percent(result);
 }
 
 void KCoreDirListerPrivate::slotTotalSize(KJob *job, qulonglong size)
 {
     jobData[static_cast<KIO::ListJob *>(job)].totalSize = size;
 
     KIO::filesize_t result = 0;
     for (auto dataIt = jobData.cbegin(); dataIt != jobData.cend(); ++dataIt) {
         result += dataIt.value().totalSize;
     }
 
     Q_EMIT q->totalSize(result);
 }
 
 void KCoreDirListerPrivate::slotProcessedSize(KJob *job, qulonglong size)
 {
     jobData[static_cast<KIO::ListJob *>(job)].processedSize = size;
 
     KIO::filesize_t result = 0;
     for (auto dataIt = jobData.cbegin(); dataIt != jobData.cend(); ++dataIt) {
         result += dataIt.value().processedSize;
     }
 
     Q_EMIT q->processedSize(result);
 }
 
 void KCoreDirListerPrivate::slotSpeed(KJob *job, unsigned long spd)
 {
     jobData[static_cast<KIO::ListJob *>(job)].speed = spd;
 
     int result = 0;
     for (auto dataIt = jobData.cbegin(); dataIt != jobData.cend(); ++dataIt) {
         result += dataIt.value().speed;
     }
 
     Q_EMIT q->speed(result);
 }
 
 uint KCoreDirListerPrivate::numJobs()
 {
 #ifdef DEBUG_CACHE
     // This code helps detecting stale entries in the jobData map.
     qCDebug(KIO_CORE_DIRLISTER) << q << "numJobs:" << jobData.count();
     for (auto it = jobData.cbegin(); it != jobData.cend(); ++it) {
         qCDebug(KIO_CORE_DIRLISTER) << (void *)it.key();
         qCDebug(KIO_CORE_DIRLISTER) << it.key();
     }
 #endif
 
     return jobData.count();
 }
 
 void KCoreDirListerPrivate::jobDone(KIO::ListJob *job)
 {
     jobData.remove(job);
 }
 
 void KCoreDirLister::jobStarted(KIO::ListJob *job)
 {
     KCoreDirListerPrivate::JobData data;
     data.speed = 0;
     data.percent = 0;
     data.processedSize = 0;
     data.totalSize = 0;
 
     d->jobData.insert(job, data);
     d->complete = false;
 }
 
 void KCoreDirListerPrivate::connectJob(KIO::ListJob *job)
 {
     q->connect(job, &KJob::infoMessage, q, [this](KJob *job, const QString &plain) {
         slotInfoMessage(job, plain);
     });
 
     q->connect(job, &KJob::percentChanged, q, [this](KJob *job, ulong _percent) {
         slotPercent(job, _percent);
     });
 
     q->connect(job, &KJob::totalSize, q, [this](KJob *job, qulonglong _size) {
         slotTotalSize(job, _size);
     });
     q->connect(job, &KJob::processedSize, q, [this](KJob *job, qulonglong _psize) {
         slotProcessedSize(job, _psize);
     });
     q->connect(job, &KJob::speed, q, [this](KJob *job, qulonglong _speed) {
         slotSpeed(job, _speed);
     });
 }
 
 KFileItemList KCoreDirLister::items(WhichItems which) const
 {
     return itemsForDir(url(), which);
 }
 
 KFileItemList KCoreDirLister::itemsForDir(const QUrl &dir, WhichItems which) const
 {
     QList<KFileItem> *allItems = s_kDirListerCache.localData().itemsForDir(dir);
     KFileItemList result;
     if (!allItems) {
         return result;
     }
 
     if (which == AllItems) {
         return KFileItemList(*allItems);
     } else { // only items passing the filters
         std::copy_if(allItems->cbegin(), allItems->cend(), std::back_inserter(result), [this](const KFileItem &item) {
             return d->isItemVisible(item) && d->matchesMimeFilter(item);
         });
     }
     return result;
 }
 
 bool KCoreDirLister::delayedMimeTypes() const
 {
     return d->delayedMimeTypes;
 }
 
 void KCoreDirLister::setDelayedMimeTypes(bool delayedMimeTypes)
 {
     d->delayedMimeTypes = delayedMimeTypes;
 }
 
 // called by KCoreDirListerCache::slotRedirection
 void KCoreDirListerPrivate::redirect(const QUrl &oldUrl, const QUrl &newUrl, bool keepItems)
 {
     if (url.matches(oldUrl, QUrl::StripTrailingSlash)) {
         if (!keepItems) {
             rootFileItem = KFileItem();
         } else {
             rootFileItem.setUrl(newUrl);
         }
         url = newUrl;
     }
 
     const int idx = lstDirs.indexOf(oldUrl);
     if (idx == -1) {
         qCWarning(KIO_CORE) << "Unexpected redirection from" << oldUrl << "to" << newUrl << "but this dirlister is currently listing/holding" << lstDirs;
     } else {
         lstDirs[idx] = newUrl;
     }
 
     if (lstDirs.count() == 1) {
         if (!keepItems) {
             Q_EMIT q->clear();
         }
     } else {
         if (!keepItems) {
             Q_EMIT q->clearDir(oldUrl);
         }
     }
     Q_EMIT q->redirection(oldUrl, newUrl);
 }
 
 void KCoreDirListerCacheDirectoryData::moveListersWithoutCachedItemsJob(const QUrl &url)
 {
     // Move dirlisters from listersCurrentlyListing to listersCurrentlyHolding,
     // but not those that are still waiting on a CachedItemsJob...
     // Unit-testing note:
     // Run kdirmodeltest in valgrind to hit the case where an update
     // is triggered while a lister has a CachedItemsJob (different timing...)
     QMutableListIterator<KCoreDirLister *> lister_it(listersCurrentlyListing);
     while (lister_it.hasNext()) {
         KCoreDirLister *kdl = lister_it.next();
         if (!kdl->d->cachedItemsJobForUrl(url)) {
             // OK, move this lister from "currently listing" to "currently holding".
 
             // Huh? The KCoreDirLister was present twice in listersCurrentlyListing, or was in both lists?
             Q_ASSERT(!listersCurrentlyHolding.contains(kdl));
             if (!listersCurrentlyHolding.contains(kdl)) {
                 listersCurrentlyHolding.append(kdl);
             }
             lister_it.remove();
         } else {
             qCDebug(KIO_CORE_DIRLISTER) << "Not moving" << kdl << "to listersCurrentlyHolding because it still has job" << kdl->d->m_cachedItemsJobs;
         }
     }
 }
 
 KFileItem KCoreDirLister::cachedItemForUrl(const QUrl &url)
 {
     if (s_kDirListerCache.hasLocalData()) {
         return s_kDirListerCache.localData().itemForUrl(url);
     } else {
         return {};
     }
 }
 
 bool KCoreDirLister::autoErrorHandlingEnabled() const
 {
     return d->m_autoErrorHandling;
 }
 
 void KCoreDirLister::setAutoErrorHandlingEnabled(bool enable)
 {
     d->m_autoErrorHandling = enable;
 }
 
 KCoreDirListerCache::CacheHiddenFile *KCoreDirListerCache::cachedDotHiddenForDir(const QString &dir)
 {
     const QString path = dir + QLatin1String("/.hidden");
     QFile dotHiddenFile(path);
 
     if (dotHiddenFile.exists()) {
         const QDateTime mtime = QFileInfo(dotHiddenFile).lastModified();
         CacheHiddenFile *cachedDotHiddenFile = m_cacheHiddenFiles.object(path);
 
         if (cachedDotHiddenFile && mtime <= cachedDotHiddenFile->mtime) {
             // ".hidden" is in cache and still valid (the file was not modified since then),
             // so return it
             return cachedDotHiddenFile;
         } else {
             // read the ".hidden" file, then cache it and return it
             if (dotHiddenFile.open(QIODevice::ReadOnly | QIODevice::Text)) {
                 std::set<QString> filesToHide;
                 QTextStream stream(&dotHiddenFile);
                 while (!stream.atEnd()) {
                     QString name = stream.readLine();
                     if (!name.isEmpty()) {
                         filesToHide.insert(name);
                     }
                 }
 
                 m_cacheHiddenFiles.insert(path, new CacheHiddenFile(mtime, std::move(filesToHide)));
 
                 return m_cacheHiddenFiles.object(path);
             }
         }
     }
 
     return {};
 }
 
 #include "moc_kcoredirlister.cpp"
 #include "moc_kcoredirlister_p.cpp"