[core] Move resource loader to dedicated thread with scheduler

2 files changed, 48 insertions, 76 deletions

diff --git a/platform/default/src/mbgl/storage/main_resource_loader.cpp b/platform/default/src/mbgl/storage/main_resource_loader.cpp
index e39ca8ef47..91ae0a1d71 100644
--- a/platform/default/src/mbgl/storage/main_resource_loader.cpp
+++ b/platform/default/src/mbgl/storage/main_resource_loader.cpp
@@ -6,59 +6,23 @@
 #include <mbgl/storage/resource.hpp>
 #include <mbgl/storage/resource_options.hpp>
 #include <mbgl/util/stopwatch.hpp>
+#include <mbgl/util/thread.hpp>
 
 #include <cassert>
 
 namespace mbgl {
 
-class ResourceLoaderRequestor {
+class MainResourceLoaderThread {
 public:
-    explicit ResourceLoaderRequestor(MainResourceLoader::Impl& impl_);
-    void request(AsyncRequest*, Resource, ActorRef<FileSourceRequest>);
-    void cancel(AsyncRequest*);
-    void pause();
-    void resume();
-
-private:
-    MainResourceLoader::Impl& impl;
-};
-
-class MainResourceLoader::Impl {
-public:
-    Impl(std::shared_ptr<FileSource> assetFileSource_,
-         std::shared_ptr<FileSource> databaseFileSource_,
-         std::shared_ptr<FileSource> localFileSource_,
-         std::shared_ptr<FileSource> onlineFileSource_)
+    MainResourceLoaderThread(std::shared_ptr<FileSource> assetFileSource_,
+                             std::shared_ptr<FileSource> databaseFileSource_,
+                             std::shared_ptr<FileSource> localFileSource_,
+                             std::shared_ptr<FileSource> onlineFileSource_)
         : assetFileSource(std::move(assetFileSource_)),
           databaseFileSource(std::move(databaseFileSource_)),
           localFileSource(std::move(localFileSource_)),
-          onlineFileSource(std::move(onlineFileSource_)),
-          supportsCacheOnlyRequests_(bool(databaseFileSource)),
-          requestor(std::make_unique<Actor<ResourceLoaderRequestor>>(*Scheduler::GetCurrent(), *this)) {}
-
-    std::unique_ptr<AsyncRequest> request(const Resource& resource, Callback callback) {
-        auto req = std::make_unique<FileSourceRequest>(std::move(callback));
-        req->onCancel([actorRef = requestor->self(), req = req.get()]() {
-            actorRef.invoke(&ResourceLoaderRequestor::cancel, req);
-        });
-        requestor->self().invoke(&ResourceLoaderRequestor::request, req.get(), resource, req->actor());
-        return std::move(req);
-    }
+          onlineFileSource(std::move(onlineFileSource_)) {}
 
-    bool canRequest(const Resource& resource) const {
-        return (assetFileSource && assetFileSource->canRequest(resource)) ||
-               (localFileSource && localFileSource->canRequest(resource)) ||
-               (databaseFileSource && databaseFileSource->canRequest(resource)) ||
-               (onlineFileSource && onlineFileSource->canRequest(resource));
-    }
-
-    bool supportsCacheOnlyRequests() const { return supportsCacheOnlyRequests_; }
-
-    void pause() { requestor->self().invoke(&ResourceLoaderRequestor::pause); }
-
-    void resume() { requestor->self().invoke(&ResourceLoaderRequestor::resume); }
-
-private:
     void request(AsyncRequest* req, Resource resource, ActorRef<FileSourceRequest> ref) {
         auto callback = [ref](const Response& res) { ref.invoke(&FileSourceRequest::setResponse, res); };
 
@@ -142,55 +106,64 @@ private:
         }
     }
 
-    void pauseInternal() {
-        if (assetFileSource) assetFileSource->pause();
-        if (databaseFileSource) databaseFileSource->pause();
-        if (localFileSource) localFileSource->pause();
-        if (onlineFileSource) onlineFileSource->pause();
-    }
-
-    void resumeInternal() {
-        if (assetFileSource) assetFileSource->resume();
-        if (databaseFileSource) databaseFileSource->resume();
-        if (localFileSource) localFileSource->resume();
-        if (onlineFileSource) onlineFileSource->resume();
-    }
-
     void cancel(AsyncRequest* req) {
         assert(req);
         tasks.erase(req);
     }
 
 private:
-    friend class ResourceLoaderRequestor;
     const std::shared_ptr<FileSource> assetFileSource;
     const std::shared_ptr<FileSource> databaseFileSource;
     const std::shared_ptr<FileSource> localFileSource;
     const std::shared_ptr<FileSource> onlineFileSource;
-    const bool supportsCacheOnlyRequests_;
-    std::unique_ptr<Actor<ResourceLoaderRequestor>> requestor;
     std::unordered_map<AsyncRequest*, std::unique_ptr<AsyncRequest>> tasks;
 };
 
-ResourceLoaderRequestor::ResourceLoaderRequestor(MainResourceLoader::Impl& impl_) : impl(impl_) {}
+class MainResourceLoader::Impl {
+public:
+    Impl(std::shared_ptr<FileSource> assetFileSource_,
+         std::shared_ptr<FileSource> databaseFileSource_,
+         std::shared_ptr<FileSource> localFileSource_,
+         std::shared_ptr<FileSource> onlineFileSource_)
+        : assetFileSource(std::move(assetFileSource_)),
+          databaseFileSource(std::move(databaseFileSource_)),
+          localFileSource(std::move(localFileSource_)),
+          onlineFileSource(std::move(onlineFileSource_)),
+          supportsCacheOnlyRequests_(bool(databaseFileSource)),
+          thread(std::make_unique<util::Thread<MainResourceLoaderThread>>(
+              "ResourceLoaderThread", assetFileSource, databaseFileSource, localFileSource, onlineFileSource)) {}
+
+    std::unique_ptr<AsyncRequest> request(const Resource& resource, Callback callback) {
+        auto req = std::make_unique<FileSourceRequest>(std::move(callback));
 
-void ResourceLoaderRequestor::request(AsyncRequest* req, Resource resource, ActorRef<FileSourceRequest> ref) {
-    assert(req);
-    impl.request(req, std::move(resource), std::move(ref));
-}
+        req->onCancel([actorRef = thread->actor(), req = req.get()]() {
+            actorRef.invoke(&MainResourceLoaderThread::cancel, req);
+        });
+        thread->actor().invoke(&MainResourceLoaderThread::request, req.get(), resource, req->actor());
+        return std::move(req);
+    }
 
-void ResourceLoaderRequestor::cancel(AsyncRequest* req) {
-    assert(req);
-    impl.cancel(req);
-}
+    bool canRequest(const Resource& resource) const {
+        return (assetFileSource && assetFileSource->canRequest(resource)) ||
+               (localFileSource && localFileSource->canRequest(resource)) ||
+               (databaseFileSource && databaseFileSource->canRequest(resource)) ||
+               (onlineFileSource && onlineFileSource->canRequest(resource));
+    }
 
-void ResourceLoaderRequestor::pause() {
-    impl.pauseInternal();
-}
+    bool supportsCacheOnlyRequests() const { return supportsCacheOnlyRequests_; }
 
-void ResourceLoaderRequestor::resume() {
-    impl.resumeInternal();
-}
+    void pause() { thread->pause(); }
+
+    void resume() { thread->resume(); }
+
+private:
+    const std::shared_ptr<FileSource> assetFileSource;
+    const std::shared_ptr<FileSource> databaseFileSource;
+    const std::shared_ptr<FileSource> localFileSource;
+    const std::shared_ptr<FileSource> onlineFileSource;
+    const bool supportsCacheOnlyRequests_;
+    const std::unique_ptr<util::Thread<MainResourceLoaderThread>> thread;
+};
 
 MainResourceLoader::MainResourceLoader(const ResourceOptions& options)
     : impl(std::make_unique<Impl>(FileSourceManager::get()->getFileSource(FileSourceType::Asset, options),
diff --git a/src/mbgl/storage/main_resource_loader.hpp b/src/mbgl/storage/main_resource_loader.hpp
index f78ff9af2e..f5603d7fe4 100644
--- a/src/mbgl/storage/main_resource_loader.hpp
+++ b/src/mbgl/storage/main_resource_loader.hpp
@@ -19,7 +19,6 @@ public:
     void resume() override;
 
 private:
-    friend class ResourceLoaderRequestor;
     class Impl;
     const std::unique_ptr<Impl> impl;
 };