4 files changed, 25 insertions, 25 deletions
diff --git a/platform/default/http_file_source.cpp b/platform/default/http_file_source.cpp
index 9166d92fb7..213b53de98 100644
--- a/platform/default/http_file_source.cpp
+++ b/platform/default/http_file_source.cpp
@@ -492,8 +492,4 @@ std::unique_ptr<AsyncRequest> HTTPFileSource::request(const Resource& resource,
     return std::make_unique<HTTPRequest>(impl.get(), resource, callback);
 }
 
-uint32_t HTTPFileSource::maximumConcurrentRequests() {
-    return 20;
-}
-
 } // namespace mbgl
diff --git a/platform/default/mbgl/storage/offline_download.cpp b/platform/default/mbgl/storage/offline_download.cpp
index 6524697546..c97797a5a2 100644
--- a/platform/default/mbgl/storage/offline_download.cpp
+++ b/platform/default/mbgl/storage/offline_download.cpp
@@ -1,4 +1,4 @@
-#include <mbgl/storage/file_source.hpp>
+#include <mbgl/storage/online_file_source.hpp>
 #include <mbgl/storage/offline_database.hpp>
 #include <mbgl/storage/offline_download.hpp>
 #include <mbgl/storage/resource.hpp>
@@ -84,7 +84,7 @@ uint64_t tileCount(const OfflineRegionDefinition& definition, style::SourceType
 OfflineDownload::OfflineDownload(int64_t id_,
                                  OfflineRegionDefinition&& definition_,
                                  OfflineDatabase& offlineDatabase_,
-                                 FileSource& onlineFileSource_)
+                                 OnlineFileSource& onlineFileSource_)
     : id(id_),
       definition(definition_),
       offlineDatabase(offlineDatabase_),
@@ -340,7 +340,7 @@ void OfflineDownload::continueDownload() {
         return;
     }
 
-    while (!resourcesRemaining.empty() && requests.size() < HTTPFileSource::maximumConcurrentRequests()) {
+    while (!resourcesRemaining.empty() && requests.size() < onlineFileSource.getMaximumConcurrentRequests()) {
         ensureResource(resourcesRemaining.front());
         resourcesRemaining.pop_front();
     }
diff --git a/platform/default/mbgl/storage/offline_download.hpp b/platform/default/mbgl/storage/offline_download.hpp
index cffac1665b..1e77ff1d35 100644
--- a/platform/default/mbgl/storage/offline_download.hpp
+++ b/platform/default/mbgl/storage/offline_download.hpp
@@ -2,6 +2,7 @@
 
 #include <mbgl/storage/offline.hpp>
 #include <mbgl/storage/resource.hpp>
+#include <mbgl/storage/online_file_source.hpp>
 
 #include <list>
 #include <unordered_set>
@@ -27,7 +28,7 @@ class Parser;
  */
 class OfflineDownload {
 public:
-    OfflineDownload(int64_t id, OfflineRegionDefinition&&, OfflineDatabase& offline, FileSource& online);
+    OfflineDownload(int64_t id, OfflineRegionDefinition&&, OfflineDatabase& offline, OnlineFileSource& online);
     ~OfflineDownload();
 
     void setObserver(std::unique_ptr<OfflineRegionObserver>);
@@ -52,7 +53,7 @@ private:
     int64_t id;
     OfflineRegionDefinition definition;
     OfflineDatabase& offlineDatabase;
-    FileSource& onlineFileSource;
+    OnlineFileSource& onlineFileSource;
     OfflineRegionStatus status;
     std::unique_ptr<OfflineRegionObserver> observer;
 
diff --git a/platform/default/online_file_source.cpp b/platform/default/online_file_source.cpp
index 6c930b3fec..fce1c3e2b6 100644
--- a/platform/default/online_file_source.cpp
+++ b/platform/default/online_file_source.cpp
@@ -25,6 +25,8 @@
 
 namespace mbgl {
 
+static uint32_t DEFAULT_MAXIMUM_CONCURRENT_REQUESTS = 20;
+
 class OnlineFileRequest : public AsyncRequest {
 public:
     using Callback = std::function<void (Response)>;
@@ -64,6 +66,7 @@ class OnlineFileSource::Impl {
 public:
     Impl() {
         NetworkStatus::Subscribe(&reachability);
+        setMaximumConcurrentRequests(DEFAULT_MAXIMUM_CONCURRENT_REQUESTS);
     }
 
     ~Impl() {
@@ -156,21 +159,16 @@ public:
         networkIsReachableAgain();
     }
 
-    void setMaximumConcurrentRequestsOverride(const uint32_t maximumConcurrentRequestsOverride_) {
-        maximumConcurrentRequestsOverride = maximumConcurrentRequestsOverride_;
+    uint32_t getMaximumConcurrentRequests() const {
+        return maximumConcurrentRequests;
     }
 
-private:
-
-    uint32_t getMaximumConcurrentRequests() const {
-        if (maximumConcurrentRequestsOverride > 0) {
-            return maximumConcurrentRequestsOverride;
-        }
-        else {
-            return HTTPFileSource::maximumConcurrentRequests();
-        }
+    void setMaximumConcurrentRequests(uint32_t maximumConcurrentRequests_) {
+        maximumConcurrentRequests = maximumConcurrentRequests_;
     }
 
+private:
+
     void networkIsReachableAgain() {
         for (auto& request : allRequests) {
             request->networkIsReachableAgain();
@@ -260,7 +258,7 @@ private:
     std::unordered_set<OnlineFileRequest*> activeRequests;
 
     bool online = true;
-    uint32_t maximumConcurrentRequestsOverride = 0;
+    uint32_t maximumConcurrentRequests;
     HTTPFileSource httpFileSource;
     util::AsyncTask reachability { std::bind(&Impl::networkIsReachableAgain, this) };
 };
@@ -472,14 +470,19 @@ ActorRef<OnlineFileRequest> OnlineFileRequest::actor() {
     return ActorRef<OnlineFileRequest>(*this, mailbox);
 }
 
+void OnlineFileSource::setMaximumConcurrentRequests(uint32_t maximumConcurrentRequests_) {
+    impl->setMaximumConcurrentRequests(maximumConcurrentRequests_);
+}
+
+uint32_t OnlineFileSource::getMaximumConcurrentRequests() const {
+    return impl->getMaximumConcurrentRequests();
+}
+
+
 // For testing only:
 
 void OnlineFileSource::setOnlineStatus(const bool status) {
     impl->setOnlineStatus(status);
 }
 
-void OnlineFileSource::setMaximumConcurrentRequestsOverride(const uint32_t maximumConcurrentRequestsOverride) {
-    impl->setMaximumConcurrentRequestsOverride(maximumConcurrentRequestsOverride);
-}
-
 } // namespace mbgl