[core] Modularize FileSource codebase (#15768)

* [core] Introduce FileSourceManager and use it for default platform impl

  - Add `FileSourceManager` interface that provides access to `FileSource`
    instances and means of registering / unregistering `FileSource` factories
  - Split `DefaultFileSource` into smaller parts
  - Add `DatabaseFileSource` interface and it's default implementation
  - Remove inter-dependencies between concrete `FileSource` classes

* [build] Add files to next build system

* [core] Add generic property setters / getters

* [core] Remove setOnlineStatus from OnlineFileSource interface

* [core] Hide threading implementation details from DatabaseFileSource interface

* [core] Make DB file source methods virtual

* [core] Add documentation for DatabaseFileSource and rename one method

* [core] Use simple callback instead of ActorRef

* [core] Remove ActorRef from OnlineFileSource public header

* [core] Add callback to FileSource::forward async API

* [core] Pass OfflineRegionDefinition by value

* [core] Update tests to use modular file sources

* [core] Update unit tests

* [core] Update unit tests after rebase

* [core] Backport low prio fix for cached requests

* [core] Backport pack database

* [core] Return removed factory from unRegisterFileSourceFactory

* [core] Rename shadowed args in onlinefilesource

* [core] Remove simple std::function callback aliases

* [core] Expose online file source property keys in public header file

* [test-runner] Add proxy file source test runner

* [cache] Update mbgl-cache utility to use new file source

* [metrics] Rebaseline binary size metrics

* [offline] Update offline utility

* [core] Update changelog

22 files changed, 208 insertions, 108 deletions

diff --git a/src/core-files.json b/src/core-files.json
index 58efba1ee6..fcc508fb3a 100644
--- a/src/core-files.json
+++ b/src/core-files.json
@@ -153,7 +153,7 @@
         "src/mbgl/sprite/sprite_loader.cpp",
         "src/mbgl/sprite/sprite_loader_worker.cpp",
         "src/mbgl/sprite/sprite_parser.cpp",
-        "src/mbgl/storage/file_source.cpp",
+        "src/mbgl/storage/file_source_manager.cpp",
         "src/mbgl/storage/network_status.cpp",
         "src/mbgl/storage/resource.cpp",
         "src/mbgl/storage/resource_options.cpp",
@@ -374,8 +374,9 @@
         "mbgl/renderer/renderer_frontend.hpp": "include/mbgl/renderer/renderer_frontend.hpp",
         "mbgl/renderer/renderer_observer.hpp": "include/mbgl/renderer/renderer_observer.hpp",
         "mbgl/renderer/renderer_state.hpp": "include/mbgl/renderer/renderer_state.hpp",
-        "mbgl/storage/default_file_source.hpp": "include/mbgl/storage/default_file_source.hpp",
+        "mbgl/storage/database_file_source.hpp": "include/mbgl/storage/database_file_source.hpp",
         "mbgl/storage/file_source.hpp": "include/mbgl/storage/file_source.hpp",
+        "mbgl/storage/file_source_manager.hpp": "include/mbgl/storage/file_source_manager.hpp",
         "mbgl/storage/network_status.hpp": "include/mbgl/storage/network_status.hpp",
         "mbgl/storage/offline.hpp": "include/mbgl/storage/offline.hpp",
         "mbgl/storage/online_file_source.hpp": "include/mbgl/storage/online_file_source.hpp",
@@ -695,6 +696,7 @@
         "mbgl/storage/asset_file_source.hpp": "src/mbgl/storage/asset_file_source.hpp",
         "mbgl/storage/http_file_source.hpp": "src/mbgl/storage/http_file_source.hpp",
         "mbgl/storage/local_file_source.hpp": "src/mbgl/storage/local_file_source.hpp",
+        "mbgl/storage/main_resource_loader.hpp": "src/mbgl/storage/main_resource_loader.hpp",
         "mbgl/style/collection.hpp": "src/mbgl/style/collection.hpp",
         "mbgl/style/conversion/json.hpp": "src/mbgl/style/conversion/json.hpp",
         "mbgl/style/conversion/stringify.hpp": "src/mbgl/style/conversion/stringify.hpp",
diff --git a/src/mbgl/map/map.cpp b/src/mbgl/map/map.cpp
index a994af305f..061669f560 100644
--- a/src/mbgl/map/map.cpp
+++ b/src/mbgl/map/map.cpp
@@ -1,24 +1,24 @@
+#include <mbgl/annotation/annotation_manager.hpp>
+#include <mbgl/layermanager/layer_manager.hpp>
+#include <mbgl/map/camera.hpp>
 #include <mbgl/map/map.hpp>
 #include <mbgl/map/map_impl.hpp>
-#include <mbgl/map/camera.hpp>
 #include <mbgl/map/transform.hpp>
-#include <mbgl/annotation/annotation_manager.hpp>
-#include <mbgl/layermanager/layer_manager.hpp>
-#include <mbgl/style/style_impl.hpp>
-#include <mbgl/style/observer.hpp>
-#include <mbgl/renderer/update_parameters.hpp>
+#include <mbgl/math/log2.hpp>
 #include <mbgl/renderer/renderer_frontend.hpp>
 #include <mbgl/renderer/renderer_observer.hpp>
-#include <mbgl/storage/file_source.hpp>
+#include <mbgl/renderer/update_parameters.hpp>
+#include <mbgl/storage/file_source_manager.hpp>
 #include <mbgl/storage/resource.hpp>
 #include <mbgl/storage/response.hpp>
+#include <mbgl/style/observer.hpp>
+#include <mbgl/style/style_impl.hpp>
 #include <mbgl/util/constants.hpp>
-#include <mbgl/util/math.hpp>
 #include <mbgl/util/exception.hpp>
+#include <mbgl/util/logging.hpp>
 #include <mbgl/util/mapbox.hpp>
+#include <mbgl/util/math.hpp>
 #include <mbgl/util/tile_coordinate.hpp>
-#include <mbgl/util/logging.hpp>
-#include <mbgl/math/log2.hpp>
 
 #include <utility>
 
@@ -30,9 +30,11 @@ Map::Map(RendererFrontend& frontend,
          MapObserver& observer,
          const MapOptions& mapOptions,
          const ResourceOptions& resourceOptions)
-    : impl(std::make_unique<Impl>(frontend, observer,
-                                  FileSource::getSharedFileSource(resourceOptions),
-                                  mapOptions)) {}
+    : impl(std::make_unique<Impl>(
+          frontend,
+          observer,
+          FileSourceManager::get() ? FileSourceManager::get()->getFileSource(ResourceLoader, resourceOptions) : nullptr,
+          mapOptions)) {}
 
 Map::Map(std::unique_ptr<Impl> impl_) : impl(std::move(impl_)) {}
 
diff --git a/src/mbgl/map/map_impl.cpp b/src/mbgl/map/map_impl.cpp
index 69c3de9783..bc2a37fe07 100644
--- a/src/mbgl/map/map_impl.cpp
+++ b/src/mbgl/map/map_impl.cpp
@@ -11,15 +11,15 @@ Map::Impl::Impl(RendererFrontend& frontend_,
                 MapObserver& observer_,
                 std::shared_ptr<FileSource> fileSource_,
                 const MapOptions& mapOptions)
-        : observer(observer_),
-          rendererFrontend(frontend_),
-          transform(observer, mapOptions.constrainMode(), mapOptions.viewportMode()),
-          mode(mapOptions.mapMode()),
-          pixelRatio(mapOptions.pixelRatio()),
-          crossSourceCollisions(mapOptions.crossSourceCollisions()),
-          fileSource(std::move(fileSource_)),
-          style(std::make_unique<style::Style>(*fileSource, pixelRatio)),
-          annotationManager(*style) {
+    : observer(observer_),
+      rendererFrontend(frontend_),
+      transform(observer, mapOptions.constrainMode(), mapOptions.viewportMode()),
+      mode(mapOptions.mapMode()),
+      pixelRatio(mapOptions.pixelRatio()),
+      crossSourceCollisions(mapOptions.crossSourceCollisions()),
+      fileSource(std::move(fileSource_)),
+      style(std::make_unique<style::Style>(fileSource, pixelRatio)),
+      annotationManager(*style) {
     transform.setNorthOrientation(mapOptions.northOrientation());
     style->impl->setObserver(this);
     rendererFrontend.setObserver(*this);
diff --git a/src/mbgl/sprite/sprite_loader.cpp b/src/mbgl/sprite/sprite_loader.cpp
index bfb0c570d6..d4b1cade13 100644
--- a/src/mbgl/sprite/sprite_loader.cpp
+++ b/src/mbgl/sprite/sprite_loader.cpp
@@ -1,17 +1,18 @@
+#include <mbgl/actor/actor.hpp>
+#include <mbgl/actor/scheduler.hpp>
 #include <mbgl/sprite/sprite_loader.hpp>
-#include <mbgl/sprite/sprite_loader_worker.hpp>
 #include <mbgl/sprite/sprite_loader_observer.hpp>
+#include <mbgl/sprite/sprite_loader_worker.hpp>
 #include <mbgl/sprite/sprite_parser.hpp>
-#include <mbgl/util/logging.hpp>
-#include <mbgl/util/platform.hpp>
-#include <mbgl/util/std.hpp>
-#include <mbgl/util/constants.hpp>
-#include <mbgl/util/exception.hpp>
 #include <mbgl/storage/file_source.hpp>
 #include <mbgl/storage/resource.hpp>
 #include <mbgl/storage/response.hpp>
-#include <mbgl/actor/actor.hpp>
-#include <mbgl/actor/scheduler.hpp>
+#include <mbgl/util/async_request.hpp>
+#include <mbgl/util/constants.hpp>
+#include <mbgl/util/exception.hpp>
+#include <mbgl/util/logging.hpp>
+#include <mbgl/util/platform.hpp>
+#include <mbgl/util/std.hpp>
 
 #include <cassert>
 
diff --git a/src/mbgl/storage/asset_file_source.hpp b/src/mbgl/storage/asset_file_source.hpp
index cc15dbb60b..6dfd3ce4ad 100644
--- a/src/mbgl/storage/asset_file_source.hpp
+++ b/src/mbgl/storage/asset_file_source.hpp
@@ -14,8 +14,9 @@ public:
     ~AssetFileSource() override;
 
     std::unique_ptr<AsyncRequest> request(const Resource&, Callback) override;
-
-    static bool acceptsURL(const std::string& url);
+    bool canRequest(const Resource&) const override;
+    void pause() override;
+    void resume() override;
 
 private:
     class Impl;
diff --git a/src/mbgl/storage/file_source.cpp b/src/mbgl/storage/file_source.cpp
deleted file mode 100644
index 5f60a05278..0000000000
--- a/src/mbgl/storage/file_source.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-#include <mbgl/storage/file_source.hpp>
-#include <mbgl/storage/resource_options.hpp>
-#include <mbgl/util/string.hpp>
-
-#include <mutex>
-#include <map>
-
-namespace mbgl {
-
-std::shared_ptr<FileSource> FileSource::getSharedFileSource(const ResourceOptions& options) {
-    static std::mutex mutex;
-    static std::map<std::string, std::weak_ptr<mbgl::FileSource>> fileSources;
-
-    std::lock_guard<std::mutex> lock(mutex);
-
-    // Purge entries no longer in use.
-    for (auto it = fileSources.begin(); it != fileSources.end();) {
-        it = it->second.expired() ? fileSources.erase(it) : ++it;
-    }
-
-    const auto context = reinterpret_cast<uint64_t>(options.platformContext());
-    const std::string key = options.baseURL() + '|' + options.accessToken() + '|' + options.cachePath() + '|' + util::toString(context);
-
-    std::shared_ptr<mbgl::FileSource> fileSource;
-    auto tuple = fileSources.find(key);
-    if (tuple != fileSources.end()) {
-        fileSource = tuple->second.lock();
-    }
-
-    if (!fileSource) {
-        fileSources[key] = fileSource = createPlatformFileSource(options);
-    }
-
-    return fileSource;
-}
-
-} // namespace mbgl
diff --git a/src/mbgl/storage/file_source_manager.cpp b/src/mbgl/storage/file_source_manager.cpp
new file mode 100644
index 0000000000..6817717f1a
--- /dev/null
+++ b/src/mbgl/storage/file_source_manager.cpp
@@ -0,0 +1,71 @@
+#include <mbgl/storage/file_source_manager.hpp>
+#include <mbgl/storage/resource_options.hpp>
+#include <mbgl/util/string.hpp>
+
+#include <map>
+#include <mutex>
+#include <tuple>
+
+namespace mbgl {
+
+class FileSourceManager::Impl {
+public:
+    using Key = std::tuple<FileSourceType, std::string>;
+    std::map<Key, std::weak_ptr<FileSource>> fileSources;
+    std::map<FileSourceType, FileSourceFactory> fileSourceFactories;
+    std::recursive_mutex mutex;
+};
+
+FileSourceManager::FileSourceManager() : impl(std::make_unique<Impl>()) {}
+
+FileSourceManager::~FileSourceManager() = default;
+
+std::shared_ptr<FileSource> FileSourceManager::getFileSource(FileSourceType type,
+                                                             const ResourceOptions& options) noexcept {
+    std::lock_guard<std::recursive_mutex> lock(impl->mutex);
+
+    // Remove released file sources.
+    for (auto it = impl->fileSources.begin(); it != impl->fileSources.end();) {
+        it = it->second.expired() ? impl->fileSources.erase(it) : ++it;
+    }
+
+    const auto context = reinterpret_cast<uint64_t>(options.platformContext());
+    const std::string optionsKey =
+        options.baseURL() + '|' + options.accessToken() + '|' + options.cachePath() + '|' + util::toString(context);
+    const auto key = std::tie(type, optionsKey);
+
+    std::shared_ptr<FileSource> fileSource;
+    auto tuple = impl->fileSources.find(key);
+    if (tuple != impl->fileSources.end()) {
+        fileSource = tuple->second.lock();
+    }
+
+    if (!fileSource) {
+        auto it = impl->fileSourceFactories.find(type);
+        if (it != impl->fileSourceFactories.end()) {
+            assert(it->second);
+            impl->fileSources[key] = fileSource = it->second(options);
+        }
+    }
+
+    return fileSource;
+}
+
+void FileSourceManager::registerFileSourceFactory(FileSourceType type, FileSourceFactory&& factory) noexcept {
+    assert(factory);
+    std::lock_guard<std::recursive_mutex> lock(impl->mutex);
+    impl->fileSourceFactories[type] = std::move(factory);
+}
+
+FileSourceManager::FileSourceFactory FileSourceManager::unRegisterFileSourceFactory(FileSourceType type) noexcept {
+    std::lock_guard<std::recursive_mutex> lock(impl->mutex);
+    auto it = impl->fileSourceFactories.find(type);
+    FileSourceFactory factory;
+    if (it != impl->fileSourceFactories.end()) {
+        factory = std::move(it->second);
+        impl->fileSourceFactories.erase(it);
+    }
+    return factory;
+}
+
+} // namespace mbgl
diff --git a/src/mbgl/storage/http_file_source.hpp b/src/mbgl/storage/http_file_source.hpp
index 09834aa4dc..693ea3414d 100644
--- a/src/mbgl/storage/http_file_source.hpp
+++ b/src/mbgl/storage/http_file_source.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <mbgl/storage/file_source.hpp>
+#include <mbgl/storage/resource.hpp>
 
 namespace mbgl {
 
@@ -10,6 +11,9 @@ public:
     ~HTTPFileSource() override;
 
     std::unique_ptr<AsyncRequest> request(const Resource&, Callback) override;
+    bool canRequest(const Resource& resource) const override {
+        return resource.hasLoadingMethod(Resource::LoadingMethod::Network);
+    }
 
     class Impl;
 
diff --git a/src/mbgl/storage/local_file_source.hpp b/src/mbgl/storage/local_file_source.hpp
index 0f065e0b5f..39ebc8c4bd 100644
--- a/src/mbgl/storage/local_file_source.hpp
+++ b/src/mbgl/storage/local_file_source.hpp
@@ -14,12 +14,12 @@ public:
     ~LocalFileSource() override;
 
     std::unique_ptr<AsyncRequest> request(const Resource&, Callback) override;
-
-    static bool acceptsURL(const std::string& url);
+    bool canRequest(const Resource&) const override;
+    void pause() override;
+    void resume() override;
 
 private:
     class Impl;
-
     std::unique_ptr<util::Thread<Impl>> impl;
 };
 
diff --git a/src/mbgl/storage/main_resource_loader.hpp b/src/mbgl/storage/main_resource_loader.hpp
new file mode 100644
index 0000000000..f78ff9af2e
--- /dev/null
+++ b/src/mbgl/storage/main_resource_loader.hpp
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <mbgl/storage/file_source.hpp>
+
+namespace mbgl {
+
+class ResourceTransform;
+class ResourceOptions;
+
+class MainResourceLoader final : public FileSource {
+public:
+    explicit MainResourceLoader(const ResourceOptions& options);
+    ~MainResourceLoader() override;
+
+    bool supportsCacheOnlyRequests() const override;
+    std::unique_ptr<AsyncRequest> request(const Resource&, Callback) override;
+    bool canRequest(const Resource&) const override;
+    void pause() override;
+    void resume() override;
+
+private:
+    friend class ResourceLoaderRequestor;
+    class Impl;
+    const std::unique_ptr<Impl> impl;
+};
+
+} // namespace mbgl
diff --git a/src/mbgl/storage/resource_options.cpp b/src/mbgl/storage/resource_options.cpp
index 21ecca979a..c56a22540b 100644
--- a/src/mbgl/storage/resource_options.cpp
+++ b/src/mbgl/storage/resource_options.cpp
@@ -10,7 +10,6 @@ public:
     std::string cachePath = ":memory:";
     std::string assetPath = ".";
     uint64_t maximumSize = mbgl::util::DEFAULT_MAX_CACHE_SIZE;
-    bool supportCacheOnlyRequests = true;
     void* platformContext = nullptr;
 };
 
@@ -69,15 +68,6 @@ uint64_t ResourceOptions::maximumCacheSize() const {
     return impl_->maximumSize;
 }
 
-ResourceOptions& ResourceOptions::withCacheOnlyRequestsSupport(bool supportCacheOnlyRequests) {
-    impl_->supportCacheOnlyRequests = supportCacheOnlyRequests;
-    return *this;
-}
-
-bool ResourceOptions::supportsCacheOnlyRequests() const {
-    return impl_->supportCacheOnlyRequests;
-}
-
 ResourceOptions& ResourceOptions::withPlatformContext(void* context) {
     impl_->platformContext = context;
     return *this;
diff --git a/src/mbgl/storage/resource_transform.cpp b/src/mbgl/storage/resource_transform.cpp
index 6596551e60..eaf10c93fd 100644
--- a/src/mbgl/storage/resource_transform.cpp
+++ b/src/mbgl/storage/resource_transform.cpp
@@ -2,12 +2,12 @@
 
 namespace mbgl {
 
-ResourceTransform::ResourceTransform(ActorRef<ResourceTransform>, TransformCallback&& callback)
-    : transformCallback(std::move(callback)) {
-}
+ResourceTransform::ResourceTransform(TransformCallback callback) : transformCallback(std::move(callback)) {}
 
-void ResourceTransform::transform(Resource::Kind kind, const std::string& url, FinishedCallback&& finished) {
-    finished(transformCallback(kind, url));
+void ResourceTransform::transform(Resource::Kind kind, const std::string& url, FinishedCallback finished) {
+    assert(finished);
+    assert(transformCallback);
+    transformCallback(kind, url, std::move(finished));
 }
 
 } // namespace mbgl
diff --git a/src/mbgl/style/sources/geojson_source.cpp b/src/mbgl/style/sources/geojson_source.cpp
index 7767859b38..d8414c1f84 100644
--- a/src/mbgl/style/sources/geojson_source.cpp
+++ b/src/mbgl/style/sources/geojson_source.cpp
@@ -6,6 +6,7 @@
 #include <mbgl/style/sources/geojson_source.hpp>
 #include <mbgl/style/sources/geojson_source_impl.hpp>
 #include <mbgl/tile/tile.hpp>
+#include <mbgl/util/async_request.hpp>
 #include <mbgl/util/logging.hpp>
 #include <mbgl/util/thread_pool.hpp>
 
diff --git a/src/mbgl/style/sources/image_source.cpp b/src/mbgl/style/sources/image_source.cpp
index 4c18ae5818..d55f7c9f09 100644
--- a/src/mbgl/style/sources/image_source.cpp
+++ b/src/mbgl/style/sources/image_source.cpp
@@ -4,6 +4,7 @@
 #include <mbgl/style/sources/image_source.hpp>
 #include <mbgl/style/sources/image_source_impl.hpp>
 #include <mbgl/tile/tile.hpp>
+#include <mbgl/util/async_request.hpp>
 #include <mbgl/util/geo.hpp>
 #include <mbgl/util/premultiply.hpp>
 
diff --git a/src/mbgl/style/sources/raster_source.cpp b/src/mbgl/style/sources/raster_source.cpp
index 851f32573e..f90306945e 100644
--- a/src/mbgl/style/sources/raster_source.cpp
+++ b/src/mbgl/style/sources/raster_source.cpp
@@ -6,6 +6,7 @@
 #include <mbgl/style/sources/raster_source.hpp>
 #include <mbgl/style/sources/raster_source_impl.hpp>
 #include <mbgl/tile/tile.hpp>
+#include <mbgl/util/async_request.hpp>
 #include <mbgl/util/exception.hpp>
 #include <mbgl/util/mapbox.hpp>
 
diff --git a/src/mbgl/style/sources/vector_source.cpp b/src/mbgl/style/sources/vector_source.cpp
index dc1a45fdff..510106adb9 100644
--- a/src/mbgl/style/sources/vector_source.cpp
+++ b/src/mbgl/style/sources/vector_source.cpp
@@ -6,6 +6,7 @@
 #include <mbgl/style/sources/vector_source.hpp>
 #include <mbgl/style/sources/vector_source_impl.hpp>
 #include <mbgl/tile/tile.hpp>
+#include <mbgl/util/async_request.hpp>
 #include <mbgl/util/constants.hpp>
 #include <mbgl/util/exception.hpp>
 #include <mbgl/util/mapbox.hpp>
diff --git a/src/mbgl/style/style.cpp b/src/mbgl/style/style.cpp
index 783c850097..8a821e5a5e 100644
--- a/src/mbgl/style/style.cpp
+++ b/src/mbgl/style/style.cpp
@@ -8,9 +8,8 @@
 namespace mbgl {
 namespace style {
 
-Style::Style(FileSource& fileSource, float pixelRatio)
-    : impl(std::make_unique<Impl>(fileSource, pixelRatio)) {
-}
+Style::Style(std::shared_ptr<FileSource> fileSource, float pixelRatio)
+    : impl(std::make_unique<Impl>(std::move(fileSource), pixelRatio)) {}
 
 Style::~Style() = default;
 
diff --git a/src/mbgl/style/style_impl.cpp b/src/mbgl/style/style_impl.cpp
index ef1f8436fc..d5961b5901 100644
--- a/src/mbgl/style/style_impl.cpp
+++ b/src/mbgl/style/style_impl.cpp
@@ -19,6 +19,7 @@
 #include <mbgl/style/source_impl.hpp>
 #include <mbgl/style/style_impl.hpp>
 #include <mbgl/style/transition_options.hpp>
+#include <mbgl/util/async_request.hpp>
 #include <mbgl/util/exception.hpp>
 #include <mbgl/util/logging.hpp>
 #include <mbgl/util/string.hpp>
@@ -29,8 +30,8 @@ namespace style {
 
 static Observer nullObserver;
 
-Style::Impl::Impl(FileSource& fileSource_, float pixelRatio)
-    : fileSource(fileSource_),
+Style::Impl::Impl(std::shared_ptr<FileSource> fileSource_, float pixelRatio)
+    : fileSource(std::move(fileSource_)),
       spriteLoader(std::make_unique<SpriteLoader>(pixelRatio)),
       light(std::make_unique<Light>()),
       observer(&nullObserver) {
@@ -49,13 +50,19 @@ void Style::Impl::loadJSON(const std::string& json_) {
 }
 
 void Style::Impl::loadURL(const std::string& url_) {
+    if (!fileSource) {
+        observer->onStyleError(
+            std::make_exception_ptr(util::StyleLoadException("Unable to find resource provider for style url.")));
+        return;
+    }
+
     lastError = nullptr;
     observer->onStyleLoading();
 
     loaded = false;
     url = url_;
 
-    styleRequest = fileSource.request(Resource::style(url), [this](Response res) {
+    styleRequest = fileSource->request(Resource::style(url), [this](Response res) {
         // Don't allow a loaded, mutated style to be overwritten with a new version.
         if (mutated && loaded) {
             return;
@@ -112,7 +119,11 @@ void Style::Impl::parse(const std::string& json_) {
     setLight(std::make_unique<Light>(parser.light));
 
     spriteLoaded = false;
-    spriteLoader->load(parser.spriteURL, fileSource);
+    if (fileSource) {
+        spriteLoader->load(parser.spriteURL, *fileSource);
+    } else {
+        onSpriteError(std::make_exception_ptr(std::runtime_error("Unable to find resource provider for sprite url.")));
+    }
     glyphURL = parser.glyphURL;
 
     loaded = true;
@@ -143,7 +154,9 @@ void Style::Impl::addSource(std::unique_ptr<Source> source) {
 
     source->setObserver(this);
     auto item = sources.add(std::move(source));
-    item->loadDescription(fileSource);
+    if (fileSource) {
+        item->loadDescription(*fileSource);
+    }
 }
 
 std::unique_ptr<Source> Style::Impl::removeSource(const std::string& id) {
@@ -301,8 +314,8 @@ void Style::Impl::onSourceError(Source& source, std::exception_ptr error) {
 void Style::Impl::onSourceDescriptionChanged(Source& source) {
     sources.update(source);
     observer->onSourceDescriptionChanged(source);
-    if (!source.loaded) {
-        source.loadDescription(fileSource);
+    if (!source.loaded && fileSource) {
+        source.loadDescription(*fileSource);
     }
 }
 
diff --git a/src/mbgl/style/style_impl.hpp b/src/mbgl/style/style_impl.hpp
index c4c0a9a412..ca165e24f0 100644
--- a/src/mbgl/style/style_impl.hpp
+++ b/src/mbgl/style/style_impl.hpp
@@ -37,7 +37,7 @@ class Style::Impl : public SpriteLoaderObserver,
                     public LightObserver,
                     public util::noncopyable {
 public:
-    Impl(FileSource&, float pixelRatio);
+    Impl(std::shared_ptr<FileSource>, float pixelRatio);
     ~Impl() override;
 
     void loadJSON(const std::string&);
@@ -97,7 +97,7 @@ public:
 private:
     void parse(const std::string&);
 
-    FileSource& fileSource;
+    std::shared_ptr<FileSource> fileSource;
 
     std::string url;
     std::string json;
diff --git a/src/mbgl/text/glyph_manager.cpp b/src/mbgl/text/glyph_manager.cpp
index 35ea1031d5..8caac1be31 100644
--- a/src/mbgl/text/glyph_manager.cpp
+++ b/src/mbgl/text/glyph_manager.cpp
@@ -1,11 +1,12 @@
-#include <mbgl/text/glyph_manager.hpp>
-#include <mbgl/text/glyph_manager_observer.hpp>
-#include <mbgl/text/glyph_pbf.hpp>
 #include <mbgl/storage/file_source.hpp>
 #include <mbgl/storage/resource.hpp>
 #include <mbgl/storage/response.hpp>
-#include <mbgl/util/tiny_sdf.hpp>
+#include <mbgl/text/glyph_manager.hpp>
+#include <mbgl/text/glyph_manager_observer.hpp>
+#include <mbgl/text/glyph_pbf.hpp>
+#include <mbgl/util/async_request.hpp>
 #include <mbgl/util/std.hpp>
+#include <mbgl/util/tiny_sdf.hpp>
 
 namespace mbgl {
 
diff --git a/src/mbgl/tile/geometry_tile.cpp b/src/mbgl/tile/geometry_tile.cpp
index 7df81fa30f..67e4459104 100644
--- a/src/mbgl/tile/geometry_tile.cpp
+++ b/src/mbgl/tile/geometry_tile.cpp
@@ -262,7 +262,9 @@ void GeometryTile::onGlyphsAvailable(GlyphMap glyphs) {
 }
 
 void GeometryTile::getGlyphs(GlyphDependencies glyphDependencies) {
-    glyphManager.getGlyphs(*this, std::move(glyphDependencies), *fileSource);
+    if (fileSource) {
+        glyphManager.getGlyphs(*this, std::move(glyphDependencies), *fileSource);
+    }
 }
 
 void GeometryTile::onImagesAvailable(ImageMap images, ImageMap patterns, ImageVersionMap versionMap, uint64_t imageCorrelationID) {
diff --git a/src/mbgl/tile/tile_loader_impl.hpp b/src/mbgl/tile/tile_loader_impl.hpp
index 7c02021083..51efbb99e9 100644
--- a/src/mbgl/tile/tile_loader_impl.hpp
+++ b/src/mbgl/tile/tile_loader_impl.hpp
@@ -1,12 +1,19 @@
 #pragma once
 
-#include <mbgl/tile/tile_loader.hpp>
-#include <mbgl/storage/file_source.hpp>
 #include <mbgl/renderer/tile_parameters.hpp>
+#include <mbgl/storage/file_source.hpp>
+#include <mbgl/tile/tile_loader.hpp>
+#include <mbgl/util/async_request.hpp>
 #include <mbgl/util/tileset.hpp>
 
 #include <cassert>
 
+namespace {
+inline std::exception_ptr getCantLoadTileError() {
+    return std::make_exception_ptr(std::runtime_error("Can't load tile."));
+}
+} // namespace
+
 namespace mbgl {
 
 template <typename T>
@@ -26,6 +33,11 @@ TileLoader<T>::TileLoader(T& tile_,
         Resource::LoadingMethod::CacheOnly)),
       fileSource(parameters.fileSource) {
     assert(!request);
+    if (!fileSource) {
+        tile.setError(getCantLoadTileError());
+        return;
+    }
+
     if (fileSource->supportsCacheOnlyRequests()) {
         // When supported, the first request is always optional, even if the TileLoader
         // is marked as required. That way, we can let the first optional request continue
@@ -49,6 +61,10 @@ TileLoader<T>::~TileLoader() = default;
 template <typename T>
 void TileLoader<T>::loadFromCache() {
     assert(!request);
+    if (!fileSource) {
+        tile.setError(getCantLoadTileError());
+        return;
+    }
 
     resource.loadingMethod = Resource::LoadingMethod::CacheOnly;
     request = fileSource->request(resource, [this](Response res) {
@@ -113,6 +129,10 @@ void TileLoader<T>::loadedData(const Response& res) {
 template <typename T>
 void TileLoader<T>::loadFromNetwork() {
     assert(!request);
+    if (!fileSource) {
+        tile.setError(getCantLoadTileError());
+        return;
+    }
 
     // Instead of using Resource::LoadingMethod::All, we're first doing a CacheOnly, and then a
     // NetworkOnly request.