Expose resource cache count props

libraries/networking/src/ResourceCache.cpp

@@ -114,6 +114,7 @@ QSharedPointer<Resource> ResourceCache::getResource(const QUrl& url, const QUrl&
 void ResourceCache::setUnusedResourceCacheSize(qint64 unusedResourcesMaxSize) {
     _unusedResourcesMaxSize = clamp(unusedResourcesMaxSize, MIN_UNUSED_MAX_SIZE, MAX_UNUSED_MAX_SIZE);
     reserveUnusedResource(0);
+    emit dirty();
 }
 
 void ResourceCache::addUnusedResource(const QSharedPointer<Resource>& resource) {
@@ -127,6 +128,7 @@ void ResourceCache::addUnusedResource(const QSharedPointer<Resource>& resource)
     resource->setLRUKey(++_lastLRUKey);
     _unusedResources.insert(resource->getLRUKey(), resource);
     _unusedResourcesSize += resource->getBytes();
+    emit dirty();
 }
 
 void ResourceCache::removeUnusedResource(const QSharedPointer<Resource>& resource) {
@@ -134,6 +136,7 @@ void ResourceCache::removeUnusedResource(const QSharedPointer<Resource>& resourc
         _unusedResources.remove(resource->getLRUKey());
         _unusedResourcesSize -= resource->getBytes();
     }
+    emit dirty();
 }
 
 void ResourceCache::reserveUnusedResource(qint64 resourceSize) {
@@ -142,9 +145,13 @@ void ResourceCache::reserveUnusedResource(qint64 resourceSize) {
         // unload the oldest resource
         QMap<int, QSharedPointer<Resource> >::iterator it = _unusedResources.begin();
         
-        _resources.remove(it.value()->getURL());
         it.value()->setCache(nullptr);
-        _unusedResourcesSize -= it.value()->getBytes();
+        auto size = it.value()->getBytes();
+
+        _totalResourcesSize -= size;
+        _resources.remove(it.value()->getURL());
+
+        _unusedResourcesSize -= size;
         _unusedResources.erase(it);
     }
 }
@@ -160,6 +167,11 @@ void ResourceCache::clearUnusedResource() {
     }
 }
 
+void ResourceCache::updateTotalSize(const qint64& oldSize, const qint64& newSize) {
+    _totalResourcesSize += (newSize - oldSize);
+    emit dirty();
+}
+
 void ResourceCacheSharedItems::appendActiveRequest(Resource* resource) {
     Lock lock(_mutex);
     _loadingRequests.append(resource);
@@ -378,6 +390,11 @@ void Resource::finishedLoading(bool success) {
     emit finished(success);
 }
 
+void Resource::setBytes(const qint64& bytes) {
+    QMetaObject::invokeMethod(_cache.data(), "updateTotalSize", Q_ARG(qint64, _bytes), Q_ARG(qint64, bytes));
+    _bytes = bytes;
+}
+
 void Resource::reinsert() {
     _cache->_resources.insert(_url, _self);
 }
@@ -413,7 +430,7 @@ void Resource::handleDownloadProgress(uint64_t bytesReceived, uint64_t bytesTota
 void Resource::handleReplyFinished() {
     Q_ASSERT_X(_request, "Resource::handleReplyFinished", "Request should not be null while in handleReplyFinished");
 
-    _bytes = _bytesTotal;
+    setBytes(_bytesTotal);
 
     if (!_request || _request != sender()) {
         // This can happen in the edge case that a request is timed out, but a `finished` signal is emitted before it is deleted.

libraries/networking/src/ResourceCache.h

@@ -79,8 +79,18 @@ private:
 /// Base class for resource caches.
 class ResourceCache : public QObject {
     Q_OBJECT
+    Q_PROPERTY(int numTotal READ getNumTotalResources NOTIFY dirty)
+    Q_PROPERTY(int numCached READ getNumCachedResources NOTIFY dirty)
+    Q_PROPERTY(qint64 sizeTotal READ getSizeTotalResources NOTIFY dirty)
+    Q_PROPERTY(qint64 sizeCached READ getSizeCachedResources NOTIFY dirty)
     
 public:
+    int getNumTotalResources() const { return _resources.size(); }
+    qint64 getSizeTotalResources() const { return _totalResourcesSize; }
+
+    int getNumCachedResources() const { return _unusedResources.size(); }
+    qint64 getSizeCachedResources() const { return _unusedResourcesSize; }
+
     static void setRequestLimit(int limit);
     static int getRequestLimit() { return _requestLimit; }
 
@@ -101,9 +111,15 @@ public:
     void refreshAll();
     void refresh(const QUrl& url);
 
+signals:
+    void dirty();
+
 public slots:
     void checkAsynchronousGets();
 
+protected slots:
+    void updateTotalSize(const qint64& oldSize, const qint64& newSize);
+
 protected:
     /// Loads a resource from the specified URL.
     /// \param fallback a fallback URL to load if the desired one is unavailable
@@ -118,8 +134,6 @@ protected:
     
     void addUnusedResource(const QSharedPointer<Resource>& resource);
     void removeUnusedResource(const QSharedPointer<Resource>& resource);
-    void reserveUnusedResource(qint64 resourceSize);
-    void clearUnusedResource();
     
     /// Attempt to load a resource if requests are below the limit, otherwise queue the resource for loading
     /// \return true if the resource began loading, otherwise false if the resource is in the pending queue
@@ -130,6 +144,9 @@ protected:
 private:
     friend class Resource;
 
+    void reserveUnusedResource(qint64 resourceSize);
+    void clearUnusedResource();
+
     QHash<QUrl, QWeakPointer<Resource>> _resources;
     int _lastLRUKey = 0;
     
@@ -140,8 +157,10 @@ private:
     QReadWriteLock _resourcesToBeGottenLock;
     QQueue<QUrl> _resourcesToBeGotten;
     
+    qint64 _totalResourcesSize { 0 };
+    qint64 _unusedResourcesSize { 0 };
+
     qint64 _unusedResourcesMaxSize = DEFAULT_UNUSED_MAX_SIZE;
-    qint64 _unusedResourcesSize = 0;
     QMap<int, QSharedPointer<Resource>> _unusedResources;
 };
 
@@ -226,7 +245,7 @@ protected:
     virtual void downloadFinished(const QByteArray& data) { finishedLoading(true); }
 
     /// Called when the download is finished and processed, sets the number of actual bytes.
-    void setBytes(qint64 bytes) { _bytes = bytes; }
+    void setBytes(const qint64& bytes);
 
     /// Called when the download is finished and processed.
     /// This should be called by subclasses that override downloadFinished to mark the end of processing.