[core] Removed dependency on uv_loop from the file source

5 files changed, 18 insertions, 24 deletions

diff --git a/src/mbgl/storage/asset_context_base.hpp b/src/mbgl/storage/asset_context_base.hpp
index cd7d9ff4a1..4a6ca0b6f9 100644
--- a/src/mbgl/storage/asset_context_base.hpp
+++ b/src/mbgl/storage/asset_context_base.hpp
@@ -3,18 +3,15 @@
 
 #include <mbgl/storage/request_base.hpp>
 
-typedef struct uv_loop_s uv_loop_t;
-
 namespace mbgl {
 
 class AssetContextBase {
 public:
-    static std::unique_ptr<AssetContextBase> createContext(uv_loop_t*);
+    static std::unique_ptr<AssetContextBase> createContext();
 
     virtual ~AssetContextBase() = default;
     virtual RequestBase* createRequest(const Resource&,
                                        RequestBase::Callback,
-                                       uv_loop_t*,
                                        const std::string& assetRoot) = 0;
 };
 
diff --git a/src/mbgl/storage/default_file_source.cpp b/src/mbgl/storage/default_file_source.cpp
index 439acd8888..63a0e329fb 100644
--- a/src/mbgl/storage/default_file_source.cpp
+++ b/src/mbgl/storage/default_file_source.cpp
@@ -78,21 +78,20 @@ void DefaultFileSource::cancel(const Resource& res, FileRequest* req) {
 // ----- Impl -----
 
 DefaultFileSource::Impl::Impl(FileCache* cache_, const std::string& root)
-    : loop(reinterpret_cast<uv_loop_t*>(util::RunLoop::getLoopHandle())),
-      cache(cache_),
+    : cache(cache_),
       assetRoot(root.empty() ? platform::assetRoot() : root),
-      assetContext(AssetContextBase::createContext(loop)),
-      httpContext(HTTPContextBase::createContext(loop)),
-      reachability(std::make_unique<uv::async>(loop, std::bind(&Impl::networkIsReachableAgain, this))) {
+      assetContext(AssetContextBase::createContext()),
+      httpContext(HTTPContextBase::createContext()),
+      reachability(std::bind(&Impl::networkIsReachableAgain, this)) {
     // Subscribe to network status changes, but make sure that this async handle doesn't keep the
     // loop alive; otherwise our app wouldn't terminate. After all, we only need status change
     // notifications when our app is still running.
-    NetworkStatus::Subscribe(reachability->get());
-    reachability->unref();
+    NetworkStatus::Subscribe(&reachability);
+    reachability.unref();
 }
 
 DefaultFileSource::Impl::~Impl() {
-    NetworkStatus::Unsubscribe(reachability->get());
+    NetworkStatus::Unsubscribe(&reachability);
 }
 
 void DefaultFileSource::Impl::networkIsReachableAgain() {
@@ -202,10 +201,10 @@ void DefaultFileSource::Impl::startRealRequest(DefaultFileRequestImpl& request)
 
     if (algo::starts_with(request.resource.url, "asset://")) {
         request.realRequest =
-            assetContext->createRequest(request.resource, callback, loop, assetRoot);
+            assetContext->createRequest(request.resource, callback, assetRoot);
     } else {
         request.realRequest =
-            httpContext->createRequest(request.resource, callback, loop, request.getResponse());
+            httpContext->createRequest(request.resource, callback, request.getResponse());
     }
 }
 
diff --git a/src/mbgl/storage/default_file_source_impl.hpp b/src/mbgl/storage/default_file_source_impl.hpp
index 771274b7ad..9580d4e783 100644
--- a/src/mbgl/storage/default_file_source_impl.hpp
+++ b/src/mbgl/storage/default_file_source_impl.hpp
@@ -4,6 +4,7 @@
 #include <mbgl/storage/default_file_source.hpp>
 #include <mbgl/storage/asset_context_base.hpp>
 #include <mbgl/storage/http_context_base.hpp>
+#include <mbgl/util/async_task.hpp>
 #include <mbgl/util/noncopyable.hpp>
 #include <mbgl/util/chrono.hpp>
 
@@ -101,12 +102,11 @@ private:
     void reschedule(DefaultFileRequestImpl&);
 
     std::unordered_map<Resource, std::unique_ptr<DefaultFileRequestImpl>, Resource::Hash> pending;
-    uv_loop_t* const loop;
     FileCache* const cache;
     const std::string assetRoot;
     const std::unique_ptr<AssetContextBase> assetContext;
     const std::unique_ptr<HTTPContextBase> httpContext;
-    const std::unique_ptr<uv::async> reachability;
+    util::AsyncTask reachability;
 };
 
 }
diff --git a/src/mbgl/storage/http_context_base.hpp b/src/mbgl/storage/http_context_base.hpp
index fd6e444ee3..7fbef719f6 100644
--- a/src/mbgl/storage/http_context_base.hpp
+++ b/src/mbgl/storage/http_context_base.hpp
@@ -4,7 +4,6 @@
 #include <mbgl/storage/request_base.hpp>
 #include <mbgl/storage/http_request_base.hpp>
 #include <mbgl/storage/network_status.hpp>
-#include <mbgl/util/uv_detail.hpp>
 
 #include <set>
 
@@ -12,12 +11,11 @@ namespace mbgl {
 
 class HTTPContextBase {
 public:
-    static std::unique_ptr<HTTPContextBase> createContext(uv_loop_t*);
+    static std::unique_ptr<HTTPContextBase> createContext();
 
     virtual ~HTTPContextBase() = default;
     virtual HTTPRequestBase* createRequest(const Resource&,
                                        RequestBase::Callback,
-                                       uv_loop_t*,
                                        std::shared_ptr<const Response>) = 0;
 };
 
diff --git a/src/mbgl/storage/network_status.cpp b/src/mbgl/storage/network_status.cpp
index 04b6937d94..11f89f073f 100644
--- a/src/mbgl/storage/network_status.cpp
+++ b/src/mbgl/storage/network_status.cpp
@@ -1,6 +1,6 @@
 #include <mbgl/storage/network_status.hpp>
 
-#include <uv.h>
+#include <mbgl/util/async_task.hpp>
 
 // Example: Allocate a reachability object
 // Reachability* reach = [Reachability reachabilityForInternetConnection];
@@ -10,14 +10,14 @@
 namespace mbgl {
 
 std::mutex NetworkStatus::mtx;
-std::set<uv_async_t *> NetworkStatus::observers;
+std::set<util::AsyncTask *> NetworkStatus::observers;
 
-void NetworkStatus::Subscribe(uv_async_t *async) {
+void NetworkStatus::Subscribe(util::AsyncTask *async) {
     std::lock_guard<std::mutex> lock(NetworkStatus::mtx);
     observers.insert(async);
 }
 
-void NetworkStatus::Unsubscribe(uv_async_t *async) {
+void NetworkStatus::Unsubscribe(util::AsyncTask *async) {
     std::lock_guard<std::mutex> lock(NetworkStatus::mtx);
     observers.erase(async);
 }
@@ -25,7 +25,7 @@ void NetworkStatus::Unsubscribe(uv_async_t *async) {
 void NetworkStatus::Reachable() {
     std::lock_guard<std::mutex> lock(NetworkStatus::mtx);
     for (auto async : observers) {
-        uv_async_send(async);
+        async->send();
     }
 }