[core] Implement platform::Factory::sharedFileSource()upstream/map-refactor

69 files changed, 690 insertions, 424 deletions

diff --git a/benchmark/api/query.benchmark.cpp b/benchmark/api/query.benchmark.cpp
index ab2adbacee..21f57acbc9 100644
--- a/benchmark/api/query.benchmark.cpp
+++ b/benchmark/api/query.benchmark.cpp
@@ -6,7 +6,7 @@
 #include <mbgl/renderer/renderer.hpp>
 #include <mbgl/style/style.hpp>
 #include <mbgl/style/image.hpp>
-#include <mbgl/storage/default_file_source.hpp>
+#include <mbgl/storage/file_source_options.hpp>
 #include <mbgl/storage/network_status.hpp>
 #include <mbgl/util/image.hpp>
 #include <mbgl/util/io.hpp>
@@ -20,7 +20,6 @@ class QueryBenchmark {
 public:
     QueryBenchmark() {
         NetworkStatus::Set(NetworkStatus::Status::Offline);
-        fileSource.setAccessToken("foobar");
 
         map.getStyle().loadJSON(util::read_file("benchmark/fixtures/api/style.json"));
         map.jumpTo(CameraOptions().withCenter(LatLng { 40.726989, -73.992857 }).withZoom(15.0)); // Manhattan
@@ -30,11 +29,12 @@ public:
         frontend.render(map);
     }
 
+    FileSourceOptions fileSourceOptions = FileSourceOptions().withCachePath("benchmark/fixtures/api/cache.db").withAccessToken("foobar");
+
     util::RunLoop loop;
-    DefaultFileSource fileSource{ "benchmark/fixtures/api/cache.db", "." };
-    HeadlessFrontend frontend { { 1000, 1000 }, 1, fileSource };
+    HeadlessFrontend frontend { { 1000, 1000 }, 1.0, fileSourceOptions };
     Map map { frontend, MapObserver::nullObserver(), frontend.getSize(), 1,
-              fileSource, MapOptions().withMapMode(MapMode::Static) };
+              MapOptions().withMapMode(MapMode::Static), fileSourceOptions };
     ScreenBox box{{ 0, 0 }, { 1000, 1000 }};
 };
 
diff --git a/benchmark/api/render.benchmark.cpp b/benchmark/api/render.benchmark.cpp
index d2827ed902..29fa122e55 100644
--- a/benchmark/api/render.benchmark.cpp
+++ b/benchmark/api/render.benchmark.cpp
@@ -7,7 +7,7 @@
 #include <mbgl/renderer/renderer.hpp>
 #include <mbgl/style/style.hpp>
 #include <mbgl/style/image.hpp>
-#include <mbgl/storage/default_file_source.hpp>
+#include <mbgl/storage/file_source_options.hpp>
 #include <mbgl/storage/network_status.hpp>
 #include <mbgl/util/image.hpp>
 #include <mbgl/util/io.hpp>
@@ -21,11 +21,9 @@ class RenderBenchmark {
 public:
     RenderBenchmark() {
         NetworkStatus::Set(NetworkStatus::Status::Offline);
-        fileSource.setAccessToken("foobar");
     }
 
     util::RunLoop loop;
-    DefaultFileSource fileSource { "benchmark/fixtures/api/cache.db", "." };
 };
     
 static void prepare(Map& map, optional<std::string> json = {}) {
@@ -39,9 +37,10 @@ static void prepare(Map& map, optional<std::string> json = {}) {
 
 static void API_renderStill_reuse_map(::benchmark::State& state) {
     RenderBenchmark bench;
-    HeadlessFrontend frontend { { 1000, 1000 }, 1, bench.fileSource };
+    auto fileSourceOptions = FileSourceOptions().withCachePath("benchmark/fixtures/api/cache.db").withAccessToken("foobar");
+    HeadlessFrontend frontend { { 1000, 1000 }, 1, fileSourceOptions };
     Map map { frontend, MapObserver::nullObserver(), frontend.getSize(), 1,
-              bench.fileSource, MapOptions().withMapMode(MapMode::Static) };
+              MapOptions().withMapMode(MapMode::Static), fileSourceOptions };
     prepare(map);
 
     while (state.KeepRunning()) {
@@ -51,10 +50,11 @@ static void API_renderStill_reuse_map(::benchmark::State& state) {
 
 static void API_renderStill_reuse_map_switch_styles(::benchmark::State& state) {
     RenderBenchmark bench;
-    HeadlessFrontend frontend { { 1000, 1000 }, 1, bench.fileSource };
+    auto fileSourceOptions = FileSourceOptions().withCachePath("benchmark/fixtures/api/cache.db").withAccessToken("foobar");
+    HeadlessFrontend frontend { { 1000, 1000 }, 1, fileSourceOptions};
     Map map { frontend, MapObserver::nullObserver(), frontend.getSize(), 1,
-              bench.fileSource, MapOptions().withMapMode(MapMode::Static) };
-    
+              MapOptions().withMapMode(MapMode::Static), fileSourceOptions };
+
     while (state.KeepRunning()) {
         prepare(map, { "{}" });
         frontend.render(map);
@@ -65,11 +65,12 @@ static void API_renderStill_reuse_map_switch_styles(::benchmark::State& state) {
 
 static void API_renderStill_recreate_map(::benchmark::State& state) {
     RenderBenchmark bench;
-    
+    auto fileSourceOptions = FileSourceOptions().withCachePath("benchmark/fixtures/api/cache.db").withAccessToken("foobar");
+
     while (state.KeepRunning()) {
-        HeadlessFrontend frontend { { 1000, 1000 }, 1, bench.fileSource };
+        HeadlessFrontend frontend { { 1000, 1000 }, 1, fileSourceOptions };
         Map map { frontend, MapObserver::nullObserver(), frontend.getSize(), 1,
-                  bench.fileSource, MapOptions().withMapMode(MapMode::Static) };
+                  MapOptions().withMapMode(MapMode::Static), fileSourceOptions };
         prepare(map);
         frontend.render(map);
     }
diff --git a/bin/render.cpp b/bin/render.cpp
index 42b6dac10b..b558fa61ec 100644
--- a/bin/render.cpp
+++ b/bin/render.cpp
@@ -5,7 +5,7 @@
 #include <mbgl/util/default_styles.hpp>
 
 #include <mbgl/gl/headless_frontend.hpp>
-#include <mbgl/storage/default_file_source.hpp>
+#include <mbgl/storage/file_source_options.hpp>
 #include <mbgl/style/style.hpp>
 
 #include <args/args.hxx>
@@ -75,16 +75,12 @@ int main(int argc, char *argv[]) {
     using namespace mbgl;
 
     util::RunLoop loop;
-    DefaultFileSource fileSource(cache_file, asset_root);
 
-    // Set access token if present
-    if (token.size()) {
-        fileSource.setAccessToken(std::string(token));
-    }
+    auto fileSourceOptions = FileSourceOptions().withCachePath(cache_file).withAssetRoot(asset_root).withAccessToken(std::string(token));
 
-    HeadlessFrontend frontend({ width, height }, pixelRatio, fileSource);
+    HeadlessFrontend frontend({ width, height }, pixelRatio, fileSourceOptions);
     Map map(frontend, MapObserver::nullObserver(), frontend.getSize(), pixelRatio,
-            fileSource, MapOptions().withMapMode(MapMode::Static));
+            MapOptions().withMapMode(MapMode::Static), fileSourceOptions);
 
     if (style.find("://") == std::string::npos) {
         style = std::string("file://") + style;
diff --git a/include/mbgl/map/map.hpp b/include/mbgl/map/map.hpp
index 56aaffbcb7..ea76240d74 100644
--- a/include/mbgl/map/map.hpp
+++ b/include/mbgl/map/map.hpp
@@ -11,6 +11,7 @@
 #include <mbgl/map/camera.hpp>
 #include <mbgl/util/geometry.hpp>
 #include <mbgl/map/projection_mode.hpp>
+#include <mbgl/storage/file_source_options.hpp>
 
 #include <cstdint>
 #include <string>
@@ -20,7 +21,6 @@
 
 namespace mbgl {
 
-class FileSource;
 class RendererFrontend;
 
 namespace style {
@@ -34,8 +34,8 @@ public:
                  MapObserver&,
                  Size size,
                  float pixelRatio,
-                 FileSource&,
-                 const MapOptions&);
+                 const MapOptions&,
+                 const FileSourceOptions&);
     ~Map();
 
     // Register a callback that will get called (on the render thread) when all resources have
diff --git a/include/mbgl/map/map_options.hpp b/include/mbgl/map/map_options.hpp
index 1a72837c4c..a7507a8a2d 100644
--- a/include/mbgl/map/map_options.hpp
+++ b/include/mbgl/map/map_options.hpp
@@ -52,52 +52,6 @@ public:
     ViewportMode viewportMode() const;
 
     /**
-     * @brief Sets the cache path.
-     *
-     * @param path Cache path.
-     * @return reference to MapOptions for chaining options together.
-     */
-    MapOptions& withCachePath(std::string path);
-
-    /**
-     * @brief Gets the previously set (or default) cache path.
-     *
-     * @return cache path
-     */
-    const std::string& cachePath() const;
-
-    /**
-     * @brief Sets the asset path, which is the root directory from where
-     * the asset:// scheme gets resolved in a style.
-     *
-     * @param path Asset path.
-     * @return reference to MapOptions for chaining options together.
-     */
-    MapOptions& withAssetRoot(std::string path);
-
-    /**
-     * @brief Gets the previously set (or default) asset path.
-     *
-     * @return asset path
-     */
-    const std::string& assetRoot() const;
-
-    /**
-     * @brief Sets the maximum cache size.
-     *
-     * @param size Cache maximum size in bytes.
-     * @return reference to MapOptions for chaining options together.
-     */
-    MapOptions& withMaximumCacheSize(uint64_t size);
-
-    /**
-     * @brief Gets the previously set (or default) maximum allowed cache size.
-     *
-     * @return maximum allowed cache database size in bytes.
-     */
-    uint64_t maximumCacheSize() const;
-
-    /**
      * @brief Specify whether to enable cross-source symbol collision detection
      * or not. By default, it is set to true.
      *
diff --git a/include/mbgl/platform/factory.hpp b/include/mbgl/platform/factory.hpp
new file mode 100644
index 0000000000..c4b6dcfce6
--- /dev/null
+++ b/include/mbgl/platform/factory.hpp
@@ -0,0 +1,21 @@
+#pragma once
+
+#include <mbgl/storage/file_source_options.hpp>
+
+#include <memory>
+
+namespace mbgl {
+
+class FileSource;
+
+namespace platform {
+
+class Factory {
+public:
+    // This is also a singleton: it stores a weak reference to the managed object once it has been created upon first
+    // call of this function. It allows the initial value to be overriden.
+    static std::shared_ptr<FileSource> sharedFileSource(const FileSourceOptions& options = {}, std::shared_ptr<FileSource> initial = {});
+};
+
+} // namespace platform
+} // namespace mbgl
diff --git a/include/mbgl/renderer/renderer.hpp b/include/mbgl/renderer/renderer.hpp
index d75d8363a6..0eb449d3d6 100644
--- a/include/mbgl/renderer/renderer.hpp
+++ b/include/mbgl/renderer/renderer.hpp
@@ -13,7 +13,7 @@
 
 namespace mbgl {
 
-class FileSource;
+class FileSourceOptions;
 class RendererBackend;
 class RendererObserver;
 class RenderedQueryOptions;
@@ -22,7 +22,8 @@ class UpdateParameters;
 
 class Renderer {
 public:
-    Renderer(RendererBackend&, float pixelRatio_, FileSource&,
+    Renderer(RendererBackend&, float pixelRatio_,
+             const FileSourceOptions&,
              GLContextMode = GLContextMode::Unique,
              const optional<std::string> programCacheDir = {},
              const optional<std::string> localFontFamily = {});
diff --git a/include/mbgl/storage/file_source_options.hpp b/include/mbgl/storage/file_source_options.hpp
new file mode 100644
index 0000000000..6e9d8d6081
--- /dev/null
+++ b/include/mbgl/storage/file_source_options.hpp
@@ -0,0 +1,89 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <string>
+
+namespace mbgl {
+
+/**
+ * @brief Holds values for FileSource options.
+ */
+
+class FileSourceOptions {
+public:
+    /**
+     * @brief Constructs a FileSourceOptions object with default values.
+     */
+    FileSourceOptions();
+    ~FileSourceOptions();
+
+    /**
+     * @brief Sets the Mapbox API access token.
+     * Details: https://docs.mapbox.com/help/glossary/access-token/ 
+     * 
+     * @param accessToken Mapbox API access token, as string.
+     * @return reference to FileSourceOptions for chaining options together.
+     */
+    FileSourceOptions& withAccessToken(std::string accessToken);
+
+    /**
+     * @brief Gets the previously set Mapbox API access token.
+     * Details: https://docs.mapbox.com/help/glossary/access-token/ 
+     *
+     * @return Mapbox API access token, as string.
+     */
+    const std::string& accessToken() const;
+
+    /**
+     * @brief Sets the cache path.
+     *
+     * @param path Cache path.
+     * @return reference to FileSourceOptions for chaining options together.
+     */
+    FileSourceOptions& withCachePath(std::string path);
+
+    /**
+     * @brief Gets the previously set (or default) cache path.
+     *
+     * @return cache path
+     */
+    const std::string& cachePath() const;
+
+    /**
+     * @brief Sets the asset path, which is the root directory from where
+     * the asset:// scheme gets resolved in a style.
+     *
+     * @param path Asset path.
+     * @return reference to FileSourceOptions for chaining options together.
+     */
+    FileSourceOptions& withAssetRoot(std::string path);
+
+    /**
+     * @brief Gets the previously set (or default) asset path.
+     *
+     * @return asset path
+     */
+    const std::string& assetRoot() const;
+
+    /**
+     * @brief Sets the maximum cache size.
+     *
+     * @param size Cache maximum size in bytes.
+     * @return reference to FileSourceOptions for chaining options together.
+     */
+    FileSourceOptions& withMaximumCacheSize(uint64_t size);
+
+    /**
+     * @brief Gets the previously set (or default) maximum allowed cache size.
+     *
+     * @return maximum allowed cache database size in bytes.
+     */
+    uint64_t maximumCacheSize() const;
+
+private:
+    class Impl;
+    std::shared_ptr<Impl> impl_;
+};
+
+} // namespace mbgl
\ No newline at end of file
diff --git a/include/mbgl/style/source.hpp b/include/mbgl/style/source.hpp
index dc3a8d73fb..9f9443701f 100644
--- a/include/mbgl/style/source.hpp
+++ b/include/mbgl/style/source.hpp
@@ -69,7 +69,7 @@ public:
     void setObserver(SourceObserver*);
     SourceObserver* observer = nullptr;
 
-    virtual void loadDescription(FileSource&) = 0;
+    virtual void loadDescription(std::shared_ptr<FileSource>) = 0;
     void dumpDebugLogs() const;
 
     bool loaded = false;
diff --git a/include/mbgl/style/sources/custom_geometry_source.hpp b/include/mbgl/style/sources/custom_geometry_source.hpp
index 9daeeb3819..183c45f79b 100644
--- a/include/mbgl/style/sources/custom_geometry_source.hpp
+++ b/include/mbgl/style/sources/custom_geometry_source.hpp
@@ -12,6 +12,7 @@ class OverscaledTileID;
 class CanonicalTileID;
 template <class T>
 class Actor;
+class FileSource;
 
 namespace style {
 
@@ -38,7 +39,7 @@ public:
 public:
     CustomGeometrySource(std::string id, CustomGeometrySource::Options options);
     ~CustomGeometrySource() final;
-    void loadDescription(FileSource&) final;
+    void loadDescription(std::shared_ptr<FileSource>) final;
     void setTileData(const CanonicalTileID&, const GeoJSON&);
     void invalidateTile(const CanonicalTileID&);
     void invalidateRegion(const LatLngBounds&);
diff --git a/include/mbgl/style/sources/geojson_source.hpp b/include/mbgl/style/sources/geojson_source.hpp
index a03b910279..732b8cac75 100644
--- a/include/mbgl/style/sources/geojson_source.hpp
+++ b/include/mbgl/style/sources/geojson_source.hpp
@@ -5,9 +5,12 @@
 #include <mbgl/util/optional.hpp>
 #include <mbgl/util/constants.hpp>
 
+#include <memory>
+
 namespace mbgl {
 
 class AsyncRequest;
+class FileSource;
 
 namespace style {
 
@@ -39,7 +42,7 @@ public:
     class Impl;
     const Impl& impl() const;
 
-    void loadDescription(FileSource&) final;
+    void loadDescription(std::shared_ptr<FileSource>) final;
 
 private:
     optional<std::string> url;
diff --git a/include/mbgl/style/sources/image_source.hpp b/include/mbgl/style/sources/image_source.hpp
index 009764291f..2f3323a5b9 100644
--- a/include/mbgl/style/sources/image_source.hpp
+++ b/include/mbgl/style/sources/image_source.hpp
@@ -4,9 +4,12 @@
 #include <mbgl/util/image.hpp>
 #include <mbgl/util/optional.hpp>
 
+#include <memory>
+
 namespace mbgl {
 class LatLng;
 class AsyncRequest;
+class FileSource;
 
 namespace style {
 
@@ -26,7 +29,7 @@ public:
     class Impl;
     const Impl& impl() const;
 
-    void loadDescription(FileSource&) final;
+    void loadDescription(std::shared_ptr<FileSource>) final;
 private:
     optional<std::string> url;
     std::unique_ptr<AsyncRequest> req;
diff --git a/include/mbgl/style/sources/raster_source.hpp b/include/mbgl/style/sources/raster_source.hpp
index 5aa81aa979..7c6c2a52c1 100644
--- a/include/mbgl/style/sources/raster_source.hpp
+++ b/include/mbgl/style/sources/raster_source.hpp
@@ -7,6 +7,7 @@
 namespace mbgl {
 
 class AsyncRequest;
+class FileSource;
 
 namespace style {
 
@@ -23,7 +24,7 @@ public:
     class Impl;
     const Impl& impl() const;
 
-    void loadDescription(FileSource&) final;
+    void loadDescription(std::shared_ptr<FileSource>) final;
 
 private:
     const variant<std::string, Tileset> urlOrTileset;
diff --git a/include/mbgl/style/sources/vector_source.hpp b/include/mbgl/style/sources/vector_source.hpp
index 6f16974b40..e72244c361 100644
--- a/include/mbgl/style/sources/vector_source.hpp
+++ b/include/mbgl/style/sources/vector_source.hpp
@@ -7,6 +7,7 @@
 namespace mbgl {
 
 class AsyncRequest;
+class FileSource;
 
 namespace style {
 
@@ -21,7 +22,7 @@ public:
     class Impl;
     const Impl& impl() const;
 
-    void loadDescription(FileSource&) final;
+    void loadDescription(std::shared_ptr<FileSource>) final;
 
 private:
     const variant<std::string, Tileset> urlOrTileset;
diff --git a/include/mbgl/style/style.hpp b/include/mbgl/style/style.hpp
index 4a6a542b88..5568a1e33d 100644
--- a/include/mbgl/style/style.hpp
+++ b/include/mbgl/style/style.hpp
@@ -10,7 +10,7 @@
 
 namespace mbgl {
 
-class FileSource;
+class FileSourceOptions;
 
 namespace style {
 
@@ -21,7 +21,7 @@ class Layer;
 
 class Style {
 public:
-    Style(FileSource&, float pixelRatio);
+    Style(float pixelRatio, const FileSourceOptions&);
     ~Style();
 
     void loadJSON(const std::string&);
diff --git a/platform/default/filesource-files.json b/platform/default/filesource-files.json
index f61aa6a335..c256cec1be 100644
--- a/platform/default/filesource-files.json
+++ b/platform/default/filesource-files.json
@@ -3,6 +3,7 @@
     "sources": [
         "platform/default/src/mbgl/storage/asset_file_source.cpp",
         "platform/default/src/mbgl/storage/default_file_source.cpp",
+        "platform/default/src/mbgl/storage/file_source_options.cpp",
         "platform/default/src/mbgl/storage/file_source_request.cpp",
         "platform/default/src/mbgl/storage/local_file_request.cpp",
         "platform/default/src/mbgl/storage/local_file_source.cpp",
diff --git a/platform/default/include/mbgl/gl/headless_frontend.hpp b/platform/default/include/mbgl/gl/headless_frontend.hpp
index d32c2e7768..a30519ad4e 100644
--- a/platform/default/include/mbgl/gl/headless_frontend.hpp
+++ b/platform/default/include/mbgl/gl/headless_frontend.hpp
@@ -11,16 +11,16 @@
 
 namespace mbgl {
 
-class FileSource;
 class Renderer;
 class RendererBackend;
 class Map;
 class TransformState;
+class FileSourceOptions;
 
 class HeadlessFrontend : public RendererFrontend {
 public:
-    HeadlessFrontend(float pixelRatio_, FileSource&, const optional<std::string> programCacheDir = {}, GLContextMode mode = GLContextMode::Unique, const optional<std::string> localFontFamily = {});
-    HeadlessFrontend(Size, float pixelRatio_, FileSource&, const optional<std::string> programCacheDir = {}, GLContextMode mode = GLContextMode::Unique, const optional<std::string> localFontFamily = {});
+    HeadlessFrontend(float pixelRatio_, const FileSourceOptions&, const optional<std::string> programCacheDir = {}, GLContextMode mode = GLContextMode::Unique, const optional<std::string> localFontFamily = {});
+    HeadlessFrontend(Size, float pixelRatio_, const FileSourceOptions&, const optional<std::string> programCacheDir = {}, GLContextMode mode = GLContextMode::Unique, const optional<std::string> localFontFamily = {});
     ~HeadlessFrontend() override;
 
     void reset() override;
diff --git a/platform/default/include/mbgl/map/map_snapshotter.hpp b/platform/default/include/mbgl/map/map_snapshotter.hpp
index 8c4b3e023e..e7c6a94883 100644
--- a/platform/default/include/mbgl/map/map_snapshotter.hpp
+++ b/platform/default/include/mbgl/map/map_snapshotter.hpp
@@ -25,8 +25,7 @@ class Style;
 
 class MapSnapshotter {
 public:
-    MapSnapshotter(FileSource* fileSource,
-                   const std::pair<bool, std::string> style,
+    MapSnapshotter(const std::pair<bool, std::string> style,
                    const Size&,
                    const float pixelRatio,
                    const optional<CameraOptions> cameraOptions,
diff --git a/platform/default/src/mbgl/gl/headless_frontend.cpp b/platform/default/src/mbgl/gl/headless_frontend.cpp
index 71cd656e59..c1f8205fdb 100644
--- a/platform/default/src/mbgl/gl/headless_frontend.cpp
+++ b/platform/default/src/mbgl/gl/headless_frontend.cpp
@@ -8,11 +8,11 @@
 
 namespace mbgl {
 
-HeadlessFrontend::HeadlessFrontend(float pixelRatio_, FileSource& fileSource, const optional<std::string> programCacheDir, GLContextMode mode, const optional<std::string> localFontFamily)
-    : HeadlessFrontend({ 256, 256 }, pixelRatio_, fileSource, programCacheDir, mode, localFontFamily) {
+HeadlessFrontend::HeadlessFrontend(float pixelRatio_, const FileSourceOptions& fileSourceOptions, const optional<std::string> programCacheDir, GLContextMode mode, const optional<std::string> localFontFamily)
+    : HeadlessFrontend({ 256, 256 }, pixelRatio_, fileSourceOptions, programCacheDir, mode, localFontFamily) {
 }
 
-HeadlessFrontend::HeadlessFrontend(Size size_, float pixelRatio_, FileSource& fileSource, const optional<std::string> programCacheDir, GLContextMode mode, const optional<std::string> localFontFamily)
+HeadlessFrontend::HeadlessFrontend(Size size_, float pixelRatio_, const FileSourceOptions& fileSourceOptions, const optional<std::string> programCacheDir, GLContextMode mode, const optional<std::string> localFontFamily)
     : size(size_),
     pixelRatio(pixelRatio_),
     backend({ static_cast<uint32_t>(size.width * pixelRatio),
@@ -23,7 +23,7 @@ HeadlessFrontend::HeadlessFrontend(Size size_, float pixelRatio_, FileSource& fi
             renderer->render(*updateParameters);
         }
     }),
-    renderer(std::make_unique<Renderer>(backend, pixelRatio, fileSource, mode, programCacheDir, localFontFamily)) {
+    renderer(std::make_unique<Renderer>(backend, pixelRatio, fileSourceOptions, mode, programCacheDir, localFontFamily)) {
 }
 
 HeadlessFrontend::~HeadlessFrontend() = default;
diff --git a/platform/default/src/mbgl/map/map_snapshotter.cpp b/platform/default/src/mbgl/map/map_snapshotter.cpp
index 9532b01b7e..4d3dc75724 100644
--- a/platform/default/src/mbgl/map/map_snapshotter.cpp
+++ b/platform/default/src/mbgl/map/map_snapshotter.cpp
@@ -5,7 +5,6 @@
 #include <mbgl/map/map.hpp>
 #include <mbgl/map/map_options.hpp>
 #include <mbgl/map/transform_state.hpp>
-#include <mbgl/storage/file_source.hpp>
 #include <mbgl/style/style.hpp>
 #include <mbgl/util/event.hpp>
 #include <mbgl/map/transform.hpp>
@@ -14,8 +13,7 @@ namespace mbgl {
 
 class MapSnapshotter::Impl {
 public:
-    Impl(FileSource*,
-         const std::pair<bool, std::string> style,
+    Impl(const std::pair<bool, std::string> style,
          const Size&,
          const float pixelRatio,
          const optional<CameraOptions> cameraOptions,
@@ -45,7 +43,7 @@ private:
     Map map;
 };
 
-MapSnapshotter::Impl::Impl(FileSource* fileSource,
+MapSnapshotter::Impl::Impl(
            const std::pair<bool, std::string> style,
            const Size& size,
            const float pixelRatio,
@@ -53,8 +51,8 @@ MapSnapshotter::Impl::Impl(FileSource* fileSource,
            const optional<LatLngBounds> region,
            const optional<std::string> programCacheDir,
            const optional<std::string> localFontFamily)
-    , frontend(size, pixelRatio, programCacheDir, GLContextMode::Unique, localFontFamily)
-    , map(frontend, MapObserver::nullObserver(), size, pixelRatio, *fileSource, MapOptions().withMapMode(MapMode::Static)) {
+    : frontend(size, pixelRatio, FileSourceOptions(), programCacheDir, GLContextMode::Unique, localFontFamily)
+    , map(frontend, MapObserver::nullObserver(), size, pixelRatio, MapOptions().withMapMode(MapMode::Static), FileSourceOptions()) {
 
     if (style.first) {
         map.getStyle().loadJSON(style.second);
@@ -160,15 +158,14 @@ LatLngBounds MapSnapshotter::Impl::getRegion() const {
     return map.latLngBoundsForCamera(getCameraOptions());
 }
 
-MapSnapshotter::MapSnapshotter(FileSource* fileSource,
-                               const std::pair<bool, std::string> style,
+MapSnapshotter::MapSnapshotter(const std::pair<bool, std::string> style,
                                const Size& size,
                                const float pixelRatio,
                                const optional<CameraOptions> cameraOptions,
                                const optional<LatLngBounds> region,
                                const optional<std::string> programCacheDir,
                                const optional<std::string> localFontFamily)
-   : impl(std::make_unique<util::Thread<MapSnapshotter::Impl>>("Map Snapshotter", fileSource, style, size, pixelRatio, cameraOptions, region, programCacheDir, localFontFamily)) {
+   : impl(std::make_unique<util::Thread<MapSnapshotter::Impl>>("Map Snapshotter", style, size, pixelRatio, cameraOptions, region, programCacheDir, localFontFamily)) {
 }
 
 MapSnapshotter::~MapSnapshotter() = default;
diff --git a/platform/default/src/mbgl/storage/file_source_options.cpp b/platform/default/src/mbgl/storage/file_source_options.cpp
new file mode 100644
index 0000000000..782c90f768
--- /dev/null
+++ b/platform/default/src/mbgl/storage/file_source_options.cpp
@@ -0,0 +1,55 @@
+#include <mbgl/storage/file_source_options.hpp>
+#include <mbgl/util/constants.hpp>
+
+#include <cassert>
+
+namespace mbgl {
+
+class FileSourceOptions::Impl {
+public:
+    std::string accessToken;
+    std::string cachePath { ":memory:" };
+    std::string assetRoot { "." };
+    uint64_t maximumSize{mbgl::util::DEFAULT_MAX_CACHE_SIZE};
+};
+
+FileSourceOptions::FileSourceOptions() : impl_(std::make_shared<FileSourceOptions::Impl>()) {}
+FileSourceOptions::~FileSourceOptions() = default;
+
+FileSourceOptions& FileSourceOptions::withAccessToken(std::string accessToken) {
+    impl_->accessToken = std::move(accessToken);
+    return *this;
+}
+
+const std::string& FileSourceOptions::accessToken() const {
+    return impl_->accessToken;
+}
+
+FileSourceOptions& FileSourceOptions::withCachePath(std::string path) {
+    impl_->cachePath = std::move(path);
+    return *this;
+}
+
+const std::string& FileSourceOptions::cachePath() const {
+    return impl_->cachePath;
+}
+
+FileSourceOptions& FileSourceOptions::withAssetRoot(std::string path) {
+    impl_->assetRoot = std::move(path);
+    return *this;
+}
+
+const std::string& FileSourceOptions::assetRoot() const {
+    return impl_->assetRoot;
+}
+
+FileSourceOptions& FileSourceOptions::withMaximumCacheSize(uint64_t size) {
+    impl_->maximumSize = size;
+    return *this;
+}
+
+uint64_t FileSourceOptions::maximumCacheSize() const {
+    return impl_->maximumSize;
+}
+
+} // namespace mbgl
\ No newline at end of file
diff --git a/platform/glfw/main.cpp b/platform/glfw/main.cpp
index b66acf8088..4ce3706dea 100644
--- a/platform/glfw/main.cpp
+++ b/platform/glfw/main.cpp
@@ -8,6 +8,7 @@
 #include <mbgl/storage/default_file_source.hpp>
 #include <mbgl/style/style.hpp>
 #include <mbgl/renderer/renderer.hpp>
+#include <mbgl/platform/factory.hpp>
 
 #include <args/args.hxx>
 
@@ -92,22 +93,25 @@ int main(int argc, char *argv[]) {
     GLFWView backend(fullscreen, benchmark);
     view = &backend;
 
-    mbgl::DefaultFileSource fileSource(cacheDB, ".");
-    if (!settings.online) {
-        fileSource.setOnlineStatus(false);
-        mbgl::Log::Warning(mbgl::Event::Setup, "Application is offline. Press `O` to toggle online status.");
-    }
-
     // Set access token if present
     const char *token = getenv("MAPBOX_ACCESS_TOKEN");
     if (token == nullptr) {
         mbgl::Log::Warning(mbgl::Event::Setup, "no access token set. mapbox.com tiles won't work.");
-    } else {
-        fileSource.setAccessToken(std::string(token));
     }
 
-    GLFWRendererFrontend rendererFrontend { std::make_unique<mbgl::Renderer>(backend, view->getPixelRatio(), fileSource), backend };
-    mbgl::Map map(rendererFrontend, backend, view->getSize(), view->getPixelRatio(), fileSource, mbgl::MapOptions());
+    auto fileSourceOptions = mbgl::FileSourceOptions().withCachePath(cacheDB).withAccessToken(std::string(token));
+
+    GLFWRendererFrontend rendererFrontend { std::make_unique<mbgl::Renderer>(backend, view->getPixelRatio(), fileSourceOptions), backend };
+    mbgl::Map map(rendererFrontend, backend, view->getSize(), view->getPixelRatio(),
+                  mbgl::MapOptions(), fileSourceOptions);
+
+    auto fileSource = std::static_pointer_cast<mbgl::DefaultFileSource>(mbgl::platform::Factory::sharedFileSource(fileSourceOptions));
+    printf("accessToken: %s\n", fileSource->getAccessToken().c_str());
+
+    if (!settings.online) {
+        fileSource->setOnlineStatus(false);
+        mbgl::Log::Warning(mbgl::Event::Setup, "Application is offline. Press `O` to toggle online status.");
+    }
 
     backend.setMap(&map);
 
@@ -122,9 +126,9 @@ int main(int argc, char *argv[]) {
                    .withPitch(settings.pitch));
     map.setDebug(mbgl::MapDebugOptions(settings.debug));
 
-    view->setOnlineStatusCallback([&settings, &fileSource]() {
+    view->setOnlineStatusCallback([&settings, fileSource]() {
         settings.online = !settings.online;
-        fileSource.setOnlineStatus(settings.online);
+        fileSource->setOnlineStatus(settings.online);
         mbgl::Log::Info(mbgl::Event::Setup, "Application is %s. Press `O` to toggle online status.", settings.online ? "online" : "offline");
     });
 
@@ -142,13 +146,13 @@ int main(int argc, char *argv[]) {
         mbgl::Log::Info(mbgl::Event::Setup, "Changed style to: %s", newStyle.name);
     });
 
-    view->setPauseResumeCallback([&fileSource] () {
+    view->setPauseResumeCallback([fileSource] () {
         static bool isPaused = false;
 
         if (isPaused) {
-            fileSource.resume();
+            fileSource->resume();
         } else {
-            fileSource.pause();
+            fileSource->pause();
         }
 
         isPaused = !isPaused;
diff --git a/src/core-files.json b/src/core-files.json
index dbca83c029..a471177684 100644
--- a/src/core-files.json
+++ b/src/core-files.json
@@ -48,6 +48,7 @@
         "src/mbgl/map/transform.cpp",
         "src/mbgl/map/transform_state.cpp",
         "src/mbgl/math/log2.cpp",
+        "src/mbgl/platform/factory.cpp",
         "src/mbgl/platform/gl_functions.cpp",
         "src/mbgl/programs/background_program.cpp",
         "src/mbgl/programs/binary_program.cpp",
@@ -338,6 +339,7 @@
         "mbgl/math/log2.hpp": "include/mbgl/math/log2.hpp",
         "mbgl/math/minmax.hpp": "include/mbgl/math/minmax.hpp",
         "mbgl/math/wrap.hpp": "include/mbgl/math/wrap.hpp",
+        "mbgl/platform/factory.hpp": "include/mbgl/platform/factory.hpp",
         "mbgl/platform/gl_functions.hpp": "include/mbgl/platform/gl_functions.hpp",
         "mbgl/renderer/backend_scope.hpp": "include/mbgl/renderer/backend_scope.hpp",
         "mbgl/renderer/mode.hpp": "include/mbgl/renderer/mode.hpp",
@@ -349,6 +351,7 @@
         "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/file_source.hpp": "include/mbgl/storage/file_source.hpp",
+        "mbgl/storage/file_source_options.hpp": "include/mbgl/storage/file_source_options.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",
diff --git a/src/mbgl/annotation/annotation_source.cpp b/src/mbgl/annotation/annotation_source.cpp
index 68f36f2d3a..5746081d22 100644
--- a/src/mbgl/annotation/annotation_source.cpp
+++ b/src/mbgl/annotation/annotation_source.cpp
@@ -13,7 +13,7 @@ AnnotationSource::Impl::Impl()
     : Source::Impl(SourceType::Annotations, AnnotationManager::SourceID) {
 }
 
-void AnnotationSource::loadDescription(FileSource&) {
+void AnnotationSource::loadDescription(std::shared_ptr<FileSource>) {
     loaded = true;
 }
 
diff --git a/src/mbgl/annotation/annotation_source.hpp b/src/mbgl/annotation/annotation_source.hpp
index 0728f3207e..a0e59227e4 100644
--- a/src/mbgl/annotation/annotation_source.hpp
+++ b/src/mbgl/annotation/annotation_source.hpp
@@ -3,8 +3,12 @@
 #include <mbgl/style/source.hpp>
 #include <mbgl/style/source_impl.hpp>
 
+#include <memory>
+
 namespace mbgl {
 
+class FileSource;
+
 class AnnotationSource : public style::Source {
 public:
     AnnotationSource();
@@ -13,7 +17,7 @@ public:
     const Impl& impl() const;
 
 private:
-    void loadDescription(FileSource&) final;
+    void loadDescription(std::shared_ptr<FileSource>) final;
 
     Mutable<Impl> mutableImpl() const;
 };
diff --git a/src/mbgl/map/map.cpp b/src/mbgl/map/map.cpp
index 8b90aee492..059746430c 100644
--- a/src/mbgl/map/map.cpp
+++ b/src/mbgl/map/map.cpp
@@ -9,9 +9,6 @@
 #include <mbgl/renderer/update_parameters.hpp>
 #include <mbgl/renderer/renderer_frontend.hpp>
 #include <mbgl/renderer/renderer_observer.hpp>
-#include <mbgl/storage/file_source.hpp>
-#include <mbgl/storage/resource.hpp>
-#include <mbgl/storage/response.hpp>
 #include <mbgl/util/constants.hpp>
 #include <mbgl/util/math.hpp>
 #include <mbgl/util/exception.hpp>
@@ -30,17 +27,17 @@ Map::Map(RendererFrontend& rendererFrontend,
          MapObserver& mapObserver,
          const Size size,
          const float pixelRatio,
-         FileSource& fileSource,
-         const MapOptions& options)
+         const MapOptions& options,
+         const FileSourceOptions& fileSourceOptions)
     : impl(std::make_unique<Impl>(*this,
                                   rendererFrontend,
                                   mapObserver,
-                                  fileSource,
                                   size,
                                   pixelRatio,
                                   options.mapMode(),
                                   options.viewportMode(),
-                                  options.crossSourceCollisions())) {}
+                                  options.crossSourceCollisions(),
+                                  fileSourceOptions)) {}
 
 Map::~Map() = default;
 
diff --git a/src/mbgl/map/map_impl.cpp b/src/mbgl/map/map_impl.cpp
index 15caa34af4..572e1440e8 100644
--- a/src/mbgl/map/map_impl.cpp
+++ b/src/mbgl/map/map_impl.cpp
@@ -8,21 +8,21 @@ namespace mbgl {
 Map::Impl::Impl(Map& map_,
                 RendererFrontend& frontend,
                 MapObserver& mapObserver,
-                FileSource& fileSource_,
                 Size size_,
                 float pixelRatio_,
                 MapMode mode_,
                 ViewportMode viewportMode_,
-                bool crossSourceCollisions_)
+                bool crossSourceCollisions_,
+                const FileSourceOptions& fileSourceOptions)
     : map(map_),
       observer(mapObserver),
       rendererFrontend(frontend),
-      fileSource(fileSource_),
+      fileSource(platform::Factory::sharedFileSource(fileSourceOptions)),
       transform(observer, viewportMode_),
       mode(mode_),
       pixelRatio(pixelRatio_),
       crossSourceCollisions(crossSourceCollisions_),
-      style(std::make_unique<style::Style>(fileSource, pixelRatio)),
+      style(std::make_unique<style::Style>(pixelRatio, fileSourceOptions)),
       annotationManager(*style) {
 
     style->impl->setObserver(this);
diff --git a/src/mbgl/map/map_impl.hpp b/src/mbgl/map/map_impl.hpp
index af64d8c0f6..331ae7a588 100644
--- a/src/mbgl/map/map_impl.hpp
+++ b/src/mbgl/map/map_impl.hpp
@@ -5,9 +5,9 @@
 #include <mbgl/map/map_observer.hpp>
 #include <mbgl/map/mode.hpp>
 #include <mbgl/map/transform.hpp>
+#include <mbgl/platform/factory.hpp>
 #include <mbgl/renderer/renderer_frontend.hpp>
 #include <mbgl/renderer/renderer_observer.hpp>
-#include <mbgl/storage/file_source.hpp>
 #include <mbgl/style/observer.hpp>
 #include <mbgl/style/source.hpp>
 #include <mbgl/style/style.hpp>
@@ -28,14 +28,15 @@ public:
     Impl(Map&,
          RendererFrontend&,
          MapObserver&,
-         FileSource&,
 
          Size size,
          float pixelRatio,
 
          MapMode,
          ViewportMode,
-         bool crossSourceCollisions);
+         bool crossSourceCollisions,
+
+         const FileSourceOptions& fileSourceOptions);
 
     ~Impl() final;
 
@@ -57,7 +58,9 @@ public:
     Map& map;
     MapObserver& observer;
     RendererFrontend& rendererFrontend;
-    FileSource& fileSource;
+
+    // Keeps a reference to the initialized file source.
+    std::shared_ptr<FileSource> fileSource;
 
     Transform transform;
 
diff --git a/src/mbgl/map/map_options.cpp b/src/mbgl/map/map_options.cpp
index 34586f364c..90f81d4b36 100644
--- a/src/mbgl/map/map_options.cpp
+++ b/src/mbgl/map/map_options.cpp
@@ -36,32 +36,6 @@ ViewportMode MapOptions::viewportMode() const {
     return impl_->viewportMode;
 }
 
-MapOptions& MapOptions::withCachePath(std::string path) {
-    impl_->cachePath = std::move(path);
-    return *this;
-}
-
-const std::string& MapOptions::cachePath() const {
-    return impl_->cachePath;
-}
-
-MapOptions& MapOptions::withAssetRoot(std::string path) {
-    impl_->assetRoot = std::move(path);
-    return *this;
-}
-
-const std::string& MapOptions::assetRoot() const {
-    return impl_->assetRoot;
-}
-
-MapOptions& MapOptions::withMaximumCacheSize(uint64_t size) {
-    impl_->maximumSize = size;
-    return *this;
-}
-
-uint64_t MapOptions::maximumCacheSize() const {
-    return impl_->maximumSize;
-}
 
 MapOptions& MapOptions::withCrossSourceCollisions(bool enableCollisions) {
     impl_->crossSourceCollisions = enableCollisions;
diff --git a/src/mbgl/platform/factory.cpp b/src/mbgl/platform/factory.cpp
new file mode 100644
index 0000000000..6f595f9866
--- /dev/null
+++ b/src/mbgl/platform/factory.cpp
@@ -0,0 +1,27 @@
+#include <mbgl/platform/factory.hpp>
+#include <mbgl/storage/default_file_source.hpp>
+
+namespace mbgl {
+namespace platform {
+
+std::shared_ptr<FileSource> Factory::sharedFileSource(const FileSourceOptions& options, std::shared_ptr<FileSource> initial) {
+    static std::weak_ptr<FileSource> weak;
+
+    if (initial) {
+        // We can only assign a custom initial value if the weak pointer object has zero references.
+        assert(weak.use_count() == 0);
+        weak = initial;
+    }
+
+    std::shared_ptr<FileSource> strong = weak.lock();
+    if (!strong) {
+        auto defaultFileSource = std::make_shared<DefaultFileSource>(options.cachePath(), options.assetRoot(), options.maximumCacheSize());
+        defaultFileSource->setAccessToken(options.accessToken());
+        weak = strong = defaultFileSource;
+    }
+
+    return strong;
+}
+
+} // namespace platform
+} // namespace mbgl
diff --git a/src/mbgl/renderer/renderer.cpp b/src/mbgl/renderer/renderer.cpp
index c8be1d16ef..e5339326dd 100644
--- a/src/mbgl/renderer/renderer.cpp
+++ b/src/mbgl/renderer/renderer.cpp
@@ -9,12 +9,12 @@ namespace mbgl {
 
 Renderer::Renderer(RendererBackend& backend,
                    float pixelRatio_,
-                   FileSource& fileSource_,
+                   const FileSourceOptions& fileSourceOptions,
                    GLContextMode contextMode_,
                    const optional<std::string> programCacheDir_,
                    const optional<std::string> localFontFamily_)
-        : impl(std::make_unique<Impl>(backend, pixelRatio_, fileSource_,
-                                      contextMode_, std::move(programCacheDir_), std::move(localFontFamily_))) {
+        : impl(std::make_unique<Impl>(backend, pixelRatio_,
+                                      contextMode_, std::move(programCacheDir_), std::move(localFontFamily_), fileSourceOptions)) {
 }
 
 Renderer::~Renderer() {
diff --git a/src/mbgl/renderer/renderer_impl.cpp b/src/mbgl/renderer/renderer_impl.cpp
index bfd518c11b..2ec271a444 100644
--- a/src/mbgl/renderer/renderer_impl.cpp
+++ b/src/mbgl/renderer/renderer_impl.cpp
@@ -1,5 +1,6 @@
 #include <mbgl/annotation/annotation_manager.hpp>
 #include <mbgl/layermanager/layer_manager.hpp>
+#include <mbgl/platform/factory.hpp>
 #include <mbgl/renderer/renderer_impl.hpp>
 #include <mbgl/renderer/renderer_backend.hpp>
 #include <mbgl/renderer/renderer_observer.hpp>
@@ -37,17 +38,17 @@ static RendererObserver& nullObserver() {
 
 Renderer::Impl::Impl(RendererBackend& backend_,
                      float pixelRatio_,
-                     FileSource& fileSource_,
                      GLContextMode contextMode_,
                      const optional<std::string> programCacheDir_,
-                     const optional<std::string> localFontFamily_)
+                     const optional<std::string> localFontFamily_,
+                     const FileSourceOptions& fileSourceOptions)
     : backend(backend_)
-    , fileSource(fileSource_)
     , observer(&nullObserver())
     , contextMode(contextMode_)
     , pixelRatio(pixelRatio_)
     , programCacheDir(programCacheDir_)
-    , glyphManager(std::make_unique<GlyphManager>(fileSource, std::make_unique<LocalGlyphRasterizer>(localFontFamily_)))
+    , fileSource(platform::Factory::sharedFileSource(fileSourceOptions))
+    , glyphManager(std::make_unique<GlyphManager>(fileSourceOptions, std::make_unique<LocalGlyphRasterizer>(localFontFamily_)))
     , imageManager(std::make_unique<ImageManager>())
     , lineAtlas(std::make_unique<LineAtlas>(Size{ 256, 512 }))
     , imageImpls(makeMutable<std::vector<Immutable<style::Image::Impl>>>())
@@ -107,9 +108,9 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
 
     const TileParameters tileParameters {
         updateParameters.pixelRatio,
+        fileSource,
         updateParameters.debugOptions,
         updateParameters.transformState,
-        fileSource,
         updateParameters.mode,
         updateParameters.annotationManager,
         *imageManager,
diff --git a/src/mbgl/renderer/renderer_impl.hpp b/src/mbgl/renderer/renderer_impl.hpp
index d820a50789..ded312527a 100644
--- a/src/mbgl/renderer/renderer_impl.hpp
+++ b/src/mbgl/renderer/renderer_impl.hpp
@@ -28,6 +28,7 @@ class RenderStaticData;
 class RenderedQueryOptions;
 class SourceQueryOptions;
 class FileSource;
+class FileSourceOptions;
 class GlyphManager;
 class ImageManager;
 class LineAtlas;
@@ -36,8 +37,8 @@ class CrossTileSymbolIndex;
 class Renderer::Impl : public GlyphManagerObserver,
                        public RenderSourceObserver{
 public:
-    Impl(RendererBackend&, float pixelRatio_, FileSource&, GLContextMode,
-         const optional<std::string> programCacheDir, const optional<std::string> localFontFamily);
+    Impl(RendererBackend&, float pixelRatio_, GLContextMode,
+         const optional<std::string> programCacheDir, const optional<std::string> localFontFamily, const FileSourceOptions&);
     ~Impl() final;
 
     void markContextLost() {
@@ -89,7 +90,6 @@ private:
     friend class Renderer;
 
     RendererBackend& backend;
-    FileSource& fileSource;
 
     RendererObserver* observer;
 
@@ -107,6 +107,8 @@ private:
     ZoomHistory zoomHistory;
     TransformState transformState;
 
+    std::shared_ptr<FileSource> fileSource;
+
     std::unique_ptr<GlyphManager> glyphManager;
     std::unique_ptr<ImageManager> imageManager;
     std::unique_ptr<LineAtlas> lineAtlas;
diff --git a/src/mbgl/renderer/tile_parameters.hpp b/src/mbgl/renderer/tile_parameters.hpp
index cbe8dfb3ba..9af7ceb736 100644
--- a/src/mbgl/renderer/tile_parameters.hpp
+++ b/src/mbgl/renderer/tile_parameters.hpp
@@ -2,10 +2,12 @@
 
 #include <mbgl/map/mode.hpp>
 
+#include <memory>
+
 namespace mbgl {
 
-class TransformState;
 class FileSource;
+class TransformState;
 class AnnotationManager;
 class ImageManager;
 class GlyphManager;
@@ -13,9 +15,9 @@ class GlyphManager;
 class TileParameters {
 public:
     const float pixelRatio;
+    std::shared_ptr<FileSource> fileSource;
     const MapDebugOptions debugOptions;
     const TransformState& transformState;
-    FileSource& fileSource;
     const MapMode mode;
     AnnotationManager& annotationManager;
     ImageManager& imageManager;
diff --git a/src/mbgl/sprite/sprite_loader.cpp b/src/mbgl/sprite/sprite_loader.cpp
index d38d7a2715..856e9c69a2 100644
--- a/src/mbgl/sprite/sprite_loader.cpp
+++ b/src/mbgl/sprite/sprite_loader.cpp
@@ -12,6 +12,7 @@
 #include <mbgl/storage/response.hpp>
 #include <mbgl/actor/actor.hpp>
 #include <mbgl/actor/scheduler.hpp>
+#include <mbgl/platform/factory.hpp>
 
 #include <cassert>
 
@@ -33,14 +34,15 @@ struct SpriteLoader::Loader {
     Actor<SpriteLoaderWorker> worker;
 };
 
-SpriteLoader::SpriteLoader(float pixelRatio_)
+SpriteLoader::SpriteLoader(float pixelRatio_, const FileSourceOptions& fileSourceOptions)
         : pixelRatio(pixelRatio_)
+        , fileSource(platform::Factory::sharedFileSource(fileSourceOptions))
         , observer(&nullObserver) {
 }
 
 SpriteLoader::~SpriteLoader() = default;
 
-void SpriteLoader::load(const std::string& url, FileSource& fileSource) {
+void SpriteLoader::load(const std::string& url) {
     if (url.empty()) {
         // Treat a non-existent sprite as a successfully loaded empty sprite.
         observer->onSpriteLoaded({});
@@ -49,7 +51,7 @@ void SpriteLoader::load(const std::string& url, FileSource& fileSource) {
 
     loader = std::make_unique<Loader>(*this);
 
-    loader->jsonRequest = fileSource.request(Resource::spriteJSON(url, pixelRatio), [this](Response res) {
+    loader->jsonRequest = fileSource->request(Resource::spriteJSON(url, pixelRatio), [this](Response res) {
         if (res.error) {
             observer->onSpriteError(std::make_exception_ptr(std::runtime_error(res.error->message)));
         } else if (res.notModified) {
@@ -64,7 +66,7 @@ void SpriteLoader::load(const std::string& url, FileSource& fileSource) {
         }
     });
 
-    loader->spriteRequest = fileSource.request(Resource::spriteImage(url, pixelRatio), [this](Response res) {
+    loader->spriteRequest = fileSource->request(Resource::spriteImage(url, pixelRatio), [this](Response res) {
         if (res.error) {
             observer->onSpriteError(std::make_exception_ptr(std::runtime_error(res.error->message)));
         } else if (res.notModified) {
diff --git a/src/mbgl/sprite/sprite_loader.hpp b/src/mbgl/sprite/sprite_loader.hpp
index 0b7d37fa14..e9b9c12616 100644
--- a/src/mbgl/sprite/sprite_loader.hpp
+++ b/src/mbgl/sprite/sprite_loader.hpp
@@ -13,14 +13,16 @@
 namespace mbgl {
 
 class FileSource;
+class FileSourceOptions;
+
 class SpriteLoaderObserver;
 
 class SpriteLoader : public util::noncopyable {
 public:
-    SpriteLoader(float pixelRatio);
+    SpriteLoader(float pixelRatio, const FileSourceOptions&);
     ~SpriteLoader();
 
-    void load(const std::string& url, FileSource&);
+    void load(const std::string& url);
 
     void setObserver(SpriteLoaderObserver*);
 
@@ -36,6 +38,7 @@ private:
 
     struct Loader;
     std::unique_ptr<Loader> loader;
+    std::shared_ptr<FileSource> fileSource;
 
     SpriteLoaderObserver* observer = nullptr;
 };
diff --git a/src/mbgl/style/sources/custom_geometry_source.cpp b/src/mbgl/style/sources/custom_geometry_source.cpp
index 6e9d8d65fb..546feacb8f 100644
--- a/src/mbgl/style/sources/custom_geometry_source.cpp
+++ b/src/mbgl/style/sources/custom_geometry_source.cpp
@@ -22,7 +22,7 @@ const CustomGeometrySource::Impl& CustomGeometrySource::impl() const {
     return static_cast<const CustomGeometrySource::Impl&>(*baseImpl);
 }
 
-void CustomGeometrySource::loadDescription(FileSource&) {
+void CustomGeometrySource::loadDescription(std::shared_ptr<FileSource>) {
     baseImpl = makeMutable<CustomGeometrySource::Impl>(impl(), loader->self());
     loaded = true;
 }
diff --git a/src/mbgl/style/sources/geojson_source.cpp b/src/mbgl/style/sources/geojson_source.cpp
index 4e3478322d..cb83b75ec7 100644
--- a/src/mbgl/style/sources/geojson_source.cpp
+++ b/src/mbgl/style/sources/geojson_source.cpp
@@ -40,7 +40,7 @@ optional<std::string> GeoJSONSource::getURL() const {
     return url;
 }
 
-void GeoJSONSource::loadDescription(FileSource& fileSource) {
+void GeoJSONSource::loadDescription(std::shared_ptr<FileSource> fileSource) {
     if (!url) {
         loaded = true;
         return;
@@ -50,7 +50,7 @@ void GeoJSONSource::loadDescription(FileSource& fileSource) {
         return;
     }
 
-    req = fileSource.request(Resource::source(*url), [this](Response res) {
+    req = fileSource->request(Resource::source(*url), [this](Response res) {
         if (res.error) {
             observer->onSourceError(
                 *this, std::make_exception_ptr(std::runtime_error(res.error->message)));
diff --git a/src/mbgl/style/sources/image_source.cpp b/src/mbgl/style/sources/image_source.cpp
index fa268da0ef..da046ba882 100644
--- a/src/mbgl/style/sources/image_source.cpp
+++ b/src/mbgl/style/sources/image_source.cpp
@@ -51,7 +51,7 @@ optional<std::string> ImageSource::getURL() const {
     return url;
 }
 
-void ImageSource::loadDescription(FileSource& fileSource) {
+void ImageSource::loadDescription(std::shared_ptr<FileSource> fileSource) {
     if (!url) {
         loaded = true;
     }
@@ -61,7 +61,7 @@ void ImageSource::loadDescription(FileSource& fileSource) {
     }
     const Resource imageResource { Resource::Image, *url, {} };
 
-    req = fileSource.request(imageResource, [this](Response res) {
+    req = fileSource->request(imageResource, [this](Response res) {
         if (res.error) {
             observer->onSourceError(*this, std::make_exception_ptr(std::runtime_error(res.error->message)));
         } else if (res.notModified) {
diff --git a/src/mbgl/style/sources/raster_source.cpp b/src/mbgl/style/sources/raster_source.cpp
index c2f96dbd55..5faa6a0335 100644
--- a/src/mbgl/style/sources/raster_source.cpp
+++ b/src/mbgl/style/sources/raster_source.cpp
@@ -11,8 +11,8 @@ namespace mbgl {
 namespace style {
 
 RasterSource::RasterSource(std::string id, variant<std::string, Tileset> urlOrTileset_, uint16_t tileSize, SourceType sourceType)
-    : Source(makeMutable<Impl>(sourceType, std::move(id), tileSize)),
-      urlOrTileset(std::move(urlOrTileset_)) {
+    : Source(makeMutable<Impl>(sourceType, std::move(id), tileSize))
+    , urlOrTileset(std::move(urlOrTileset_)) {
 }
 
 RasterSource::~RasterSource() = default;
@@ -37,7 +37,7 @@ uint16_t RasterSource::getTileSize() const {
     return impl().getTileSize();
 }
 
-void RasterSource::loadDescription(FileSource& fileSource) {
+void RasterSource::loadDescription(std::shared_ptr<FileSource> fileSource) {
     if (urlOrTileset.is<Tileset>()) {
         baseImpl = makeMutable<Impl>(impl(), urlOrTileset.get<Tileset>());
         loaded = true;
@@ -49,7 +49,7 @@ void RasterSource::loadDescription(FileSource& fileSource) {
     }
 
     const std::string& url = urlOrTileset.get<std::string>();
-    req = fileSource.request(Resource::source(url), [this, url](Response res) {
+    req = fileSource->request(Resource::source(url), [this, url](Response res) {
         if (res.error) {
             observer->onSourceError(*this, std::make_exception_ptr(std::runtime_error(res.error->message)));
         } else if (res.notModified) {
diff --git a/src/mbgl/style/sources/vector_source.cpp b/src/mbgl/style/sources/vector_source.cpp
index 6cede8fae9..b0152974da 100644
--- a/src/mbgl/style/sources/vector_source.cpp
+++ b/src/mbgl/style/sources/vector_source.cpp
@@ -12,8 +12,8 @@ namespace mbgl {
 namespace style {
 
 VectorSource::VectorSource(std::string id, variant<std::string, Tileset> urlOrTileset_)
-    : Source(makeMutable<Impl>(std::move(id))),
-      urlOrTileset(std::move(urlOrTileset_)) {
+    : Source(makeMutable<Impl>(std::move(id)))
+    , urlOrTileset(std::move(urlOrTileset_)) {
 }
 
 VectorSource::~VectorSource() = default;
@@ -34,7 +34,7 @@ optional<std::string> VectorSource::getURL() const {
     return urlOrTileset.get<std::string>();
 }
 
-void VectorSource::loadDescription(FileSource& fileSource) {
+void VectorSource::loadDescription(std::shared_ptr<FileSource> fileSource) {
     if (urlOrTileset.is<Tileset>()) {
         baseImpl = makeMutable<Impl>(impl(), urlOrTileset.get<Tileset>());
         loaded = true;
@@ -46,7 +46,7 @@ void VectorSource::loadDescription(FileSource& fileSource) {
     }
 
     const std::string& url = urlOrTileset.get<std::string>();
-    req = fileSource.request(Resource::source(url), [this, url](Response res) {
+    req = fileSource->request(Resource::source(url), [this, url](Response res) {
         if (res.error) {
             observer->onSourceError(*this, std::make_exception_ptr(std::runtime_error(res.error->message)));
         } else if (res.notModified) {
diff --git a/src/mbgl/style/style.cpp b/src/mbgl/style/style.cpp
index 783c850097..b70b7ee3be 100644
--- a/src/mbgl/style/style.cpp
+++ b/src/mbgl/style/style.cpp
@@ -8,8 +8,8 @@
 namespace mbgl {
 namespace style {
 
-Style::Style(FileSource& fileSource, float pixelRatio)
-    : impl(std::make_unique<Impl>(fileSource, pixelRatio)) {
+Style::Style(float pixelRatio, const FileSourceOptions& fileSourceOptions)
+    : impl(std::make_unique<Impl>(pixelRatio, fileSourceOptions)) {
 }
 
 Style::~Style() = default;
diff --git a/src/mbgl/style/style_impl.cpp b/src/mbgl/style/style_impl.cpp
index ebddfbcb22..deb77e2ed6 100644
--- a/src/mbgl/style/style_impl.cpp
+++ b/src/mbgl/style/style_impl.cpp
@@ -1,3 +1,4 @@
+#include <mbgl/platform/factory.hpp>
 #include <mbgl/style/style_impl.hpp>
 #include <mbgl/style/observer.hpp>
 #include <mbgl/style/source_impl.hpp>
@@ -27,9 +28,9 @@ namespace style {
 
 static Observer nullObserver;
 
-Style::Impl::Impl(FileSource& fileSource_, float pixelRatio)
-    : fileSource(fileSource_),
-      spriteLoader(std::make_unique<SpriteLoader>(pixelRatio)),
+Style::Impl::Impl(float pixelRatio, const FileSourceOptions& fileSourceOptions)
+    : fileSource(platform::Factory::sharedFileSource(fileSourceOptions)),
+      spriteLoader(std::make_unique<SpriteLoader>(pixelRatio, fileSourceOptions)),
       light(std::make_unique<Light>()),
       observer(&nullObserver) {
     spriteLoader->setObserver(this);
@@ -53,7 +54,7 @@ void Style::Impl::loadURL(const std::string& url_) {
     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;
@@ -110,7 +111,7 @@ void Style::Impl::parse(const std::string& json_) {
     setLight(std::make_unique<Light>(parser.light));
 
     spriteLoaded = false;
-    spriteLoader->load(parser.spriteURL, fileSource);
+    spriteLoader->load(parser.spriteURL);
     glyphURL = parser.glyphURL;
 
     loaded = true;
diff --git a/src/mbgl/style/style_impl.hpp b/src/mbgl/style/style_impl.hpp
index 4c56f6785b..1f62685c34 100644
--- a/src/mbgl/style/style_impl.hpp
+++ b/src/mbgl/style/style_impl.hpp
@@ -25,9 +25,9 @@
 
 namespace mbgl {
 
-class FileSource;
 class AsyncRequest;
 class SpriteLoader;
+class FileSourceOptions;
 
 namespace style {
 
@@ -37,7 +37,7 @@ class Style::Impl : public SpriteLoaderObserver,
                     public LightObserver,
                     public util::noncopyable {
 public:
-    Impl(FileSource&, float pixelRatio);
+    Impl(float pixelRatio, const FileSourceOptions&);
     ~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 b947ef72c8..da1d774797 100644
--- a/src/mbgl/text/glyph_manager.cpp
+++ b/src/mbgl/text/glyph_manager.cpp
@@ -1,7 +1,8 @@
+#include <mbgl/platform/factory.hpp>
 #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/default_file_source.hpp>
 #include <mbgl/storage/resource.hpp>
 #include <mbgl/storage/response.hpp>
 #include <mbgl/util/tiny_sdf.hpp>
@@ -11,8 +12,8 @@ namespace mbgl {
 
 static GlyphManagerObserver nullObserver;
 
-GlyphManager::GlyphManager(FileSource& fileSource_, std::unique_ptr<LocalGlyphRasterizer> localGlyphRasterizer_)
-    : fileSource(fileSource_),
+GlyphManager::GlyphManager(const FileSourceOptions& options, std::unique_ptr<LocalGlyphRasterizer> localGlyphRasterizer_)
+    : fileSource(platform::Factory::sharedFileSource(options)),
       observer(&nullObserver),
       localGlyphRasterizer(std::move(localGlyphRasterizer_)) {
 }
@@ -70,7 +71,7 @@ void GlyphManager::requestRange(GlyphRequest& request, const FontStack& fontStac
         return;
     }
 
-    request.req = fileSource.request(Resource::glyphs(glyphURL, fontStack, range), [this, fontStack, range](Response res) {
+    request.req = static_cast<DefaultFileSource*>(fileSource.get())->request(Resource::glyphs(glyphURL, fontStack, range), [this, fontStack, range](Response res) {
         processResponse(res, fontStack, range);
     });
 }
diff --git a/src/mbgl/text/glyph_manager.hpp b/src/mbgl/text/glyph_manager.hpp
index 831d84719c..d1c05482e5 100644
--- a/src/mbgl/text/glyph_manager.hpp
+++ b/src/mbgl/text/glyph_manager.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <mbgl/storage/file_source_options.hpp>
 #include <mbgl/text/glyph.hpp>
 #include <mbgl/text/glyph_manager_observer.hpp>
 #include <mbgl/text/glyph_range.hpp>
@@ -8,6 +9,7 @@
 #include <mbgl/util/font_stack.hpp>
 #include <mbgl/util/immutable.hpp>
 
+#include <memory>
 #include <string>
 #include <unordered_map>
 
@@ -25,7 +27,7 @@ public:
 
 class GlyphManager : public util::noncopyable {
 public:
-    GlyphManager(FileSource&, std::unique_ptr<LocalGlyphRasterizer> = std::make_unique<LocalGlyphRasterizer>(optional<std::string>()));
+    GlyphManager(const FileSourceOptions&, std::unique_ptr<LocalGlyphRasterizer> = std::make_unique<LocalGlyphRasterizer>(optional<std::string>()));
     ~GlyphManager();
 
     // Workers send a `getGlyphs` message to the main thread once they have determined
@@ -48,7 +50,7 @@ public:
 private:
     Glyph generateLocalSDF(const FontStack& fontStack, GlyphID glyphID);
 
-    FileSource& fileSource;
+    std::shared_ptr<FileSource> fileSource;
     std::string glyphURL;
 
     struct GlyphRequest {
diff --git a/src/mbgl/tile/tile_loader.hpp b/src/mbgl/tile/tile_loader.hpp
index 92ca74330f..0e96c5eb25 100644
--- a/src/mbgl/tile/tile_loader.hpp
+++ b/src/mbgl/tile/tile_loader.hpp
@@ -50,7 +50,7 @@ private:
     T& tile;
     TileNecessity necessity;
     Resource resource;
-    FileSource& fileSource;
+    std::shared_ptr<FileSource> fileSource;
     std::unique_ptr<AsyncRequest> request;
 };
 
diff --git a/src/mbgl/tile/tile_loader_impl.hpp b/src/mbgl/tile/tile_loader_impl.hpp
index 5835858d1a..0bb40434e7 100644
--- a/src/mbgl/tile/tile_loader_impl.hpp
+++ b/src/mbgl/tile/tile_loader_impl.hpp
@@ -1,9 +1,10 @@
 #pragma once
 
+#include <mbgl/platform/factory.hpp>
 #include <mbgl/tile/tile_loader.hpp>
-#include <mbgl/storage/file_source.hpp>
 #include <mbgl/renderer/tile_parameters.hpp>
 #include <mbgl/util/tileset.hpp>
+#include <mbgl/storage/default_file_source.hpp>
 
 #include <cassert>
 
@@ -27,7 +28,7 @@ TileLoader<T>::TileLoader(T& tile_,
         Resource::LoadingMethod::CacheOnly)),
       fileSource(parameters.fileSource) {
     assert(!request);
-    if (fileSource.supportsCacheOnlyRequests()) {
+    if (std::static_pointer_cast<DefaultFileSource>(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
         // to load when the TileLoader is later changed from required to optional. If we
@@ -52,7 +53,7 @@ void TileLoader<T>::loadFromCache() {
     assert(!request);
 
     resource.loadingMethod = Resource::LoadingMethod::CacheOnly;
-    request = fileSource.request(resource, [this](Response res) {
+    request = fileSource->request(resource, [this](Response res) {
         request.reset();
 
         tile.setTriedCache();
@@ -118,7 +119,7 @@ void TileLoader<T>::loadFromNetwork() {
     // Instead of using Resource::LoadingMethod::All, we're first doing a CacheOnly, and then a
     // NetworkOnly request.
     resource.loadingMethod = Resource::LoadingMethod::NetworkOnly;
-    request = fileSource.request(resource, [this](Response res) { loadedData(res); });
+    request = fileSource->request(resource, [this](Response res) { loadedData(res); });
 }
 
 } // namespace mbgl
diff --git a/test/api/annotations.test.cpp b/test/api/annotations.test.cpp
index a67e691f69..a4ba981a13 100644
--- a/test/api/annotations.test.cpp
+++ b/test/api/annotations.test.cpp
@@ -6,6 +6,7 @@
 #include <mbgl/style/image.hpp>
 #include <mbgl/map/map.hpp>
 #include <mbgl/map/map_options.hpp>
+#include <mbgl/platform/factory.hpp>
 #include <mbgl/util/io.hpp>
 #include <mbgl/util/run_loop.hpp>
 #include <mbgl/util/color.hpp>
@@ -27,12 +28,15 @@ std::unique_ptr<style::Image> namedMarker(const std::string& name) {
 class AnnotationTest {
 public:
     util::RunLoop loop;
-    StubFileSource fileSource;
+    FileSourceOptions stubFileSourceOptions;
+    std::shared_ptr<FileSource> fileSource = platform::Factory::sharedFileSource(
+        stubFileSourceOptions, std::make_shared<StubFileSource>());
     float pixelRatio { 1 };
-    HeadlessFrontend frontend { pixelRatio, fileSource };
 
-    Map map { frontend, MapObserver::nullObserver(), frontend.getSize(), pixelRatio, fileSource,
-              MapOptions().withMapMode(MapMode::Static)};
+    HeadlessFrontend frontend { pixelRatio, stubFileSourceOptions };
+
+    Map map { frontend, MapObserver::nullObserver(), frontend.getSize(), pixelRatio,
+              MapOptions().withMapMode(MapMode::Static), stubFileSourceOptions };
 
     void checkRendering(const char * name) {
         test::checkImage(std::string("test/fixtures/annotations/") + name,
diff --git a/test/api/api_misuse.test.cpp b/test/api/api_misuse.test.cpp
index 9490c14e1f..ab98aa0e81 100644
--- a/test/api/api_misuse.test.cpp
+++ b/test/api/api_misuse.test.cpp
@@ -4,6 +4,7 @@
 
 #include <mbgl/map/map.hpp>
 #include <mbgl/map/map_options.hpp>
+#include <mbgl/platform/factory.hpp>
 #include <mbgl/renderer/backend_scope.hpp>
 #include <mbgl/gl/headless_frontend.hpp>
 #include <mbgl/storage/online_file_source.hpp>
@@ -21,13 +22,15 @@ TEST(API, RenderWithoutCallback) {
 
     util::RunLoop loop;
 
-    StubFileSource fileSource;
+    FileSourceOptions stubFileSourceOptions;
+    auto fileSource = platform::Factory::sharedFileSource(stubFileSourceOptions, std::make_shared<StubFileSource>());
+
     float pixelRatio { 1 };
-    HeadlessFrontend frontend { pixelRatio, fileSource };
+
+    HeadlessFrontend frontend { pixelRatio, stubFileSourceOptions };
 
     auto map = std::make_unique<Map>(frontend, MapObserver::nullObserver(), frontend.getSize(),
-                                     pixelRatio, fileSource,
-                                     MapOptions().withMapMode(MapMode::Static));
+                                     pixelRatio, MapOptions().withMapMode(MapMode::Static), stubFileSourceOptions);
     map->renderStill(nullptr);
 
     // Force Map thread to join.
diff --git a/test/api/custom_geometry_source.test.cpp b/test/api/custom_geometry_source.test.cpp
index 54df2e5cfb..549036e3b0 100644
--- a/test/api/custom_geometry_source.test.cpp
+++ b/test/api/custom_geometry_source.test.cpp
@@ -2,6 +2,7 @@
 
 #include <mbgl/map/map.hpp>
 #include <mbgl/map/map_options.hpp>
+#include <mbgl/platform/factory.hpp>
 #include <mbgl/storage/default_file_source.hpp>
 #include <mbgl/gl/headless_frontend.hpp>
 #include <mbgl/style/style.hpp>
@@ -15,15 +16,17 @@
 
 using namespace mbgl;
 using namespace mbgl::style;
+using namespace mbgl::platform;
 
 TEST(CustomGeometrySource, Grid) {
     util::RunLoop loop;
 
-    DefaultFileSource fileSource(":memory:", "test/fixtures/api/assets");
+    auto fileSourceOptions = FileSourceOptions().withCachePath(":memory:").withAssetRoot("test/fixtures/api/assets");
+
     float pixelRatio { 1 };
-    HeadlessFrontend frontend { pixelRatio, fileSource };
-    Map map(frontend, MapObserver::nullObserver(), frontend.getSize(), pixelRatio, fileSource,
-            MapOptions().withMapMode(MapMode::Static));
+    HeadlessFrontend frontend { pixelRatio, fileSourceOptions };
+    Map map(frontend, MapObserver::nullObserver(), frontend.getSize(), pixelRatio,
+            MapOptions().withMapMode(MapMode::Static), fileSourceOptions);
     map.getStyle().loadJSON(util::read_file("test/fixtures/api/water.json"));
     map.jumpTo(CameraOptions().withCenter(LatLng { 37.8, -122.5 }).withZoom(10.0));
 
diff --git a/test/api/custom_layer.test.cpp b/test/api/custom_layer.test.cpp
index 7ea5f57cd8..e55398f0d9 100644
--- a/test/api/custom_layer.test.cpp
+++ b/test/api/custom_layer.test.cpp
@@ -1,6 +1,7 @@
 #include <mbgl/test/util.hpp>
 
 #include <mbgl/platform/gl_functions.hpp>
+#include <mbgl/platform/factory.hpp>
 #include <mbgl/map/map.hpp>
 #include <mbgl/map/map_options.hpp>
 #include <mbgl/storage/default_file_source.hpp>
@@ -89,11 +90,12 @@ public:
 TEST(CustomLayer, Basic) {
     util::RunLoop loop;
 
-    DefaultFileSource fileSource(":memory:", "test/fixtures/api/assets");
+    auto fileSourceOptions = FileSourceOptions().withCachePath(":memory:").withAssetRoot("test/fixtures/api/assets");
+
     float pixelRatio { 1 };
-    HeadlessFrontend frontend { pixelRatio, fileSource };
-    Map map(frontend, MapObserver::nullObserver(), frontend.getSize(), pixelRatio, fileSource,
-            MapOptions().withMapMode(MapMode::Static));
+    HeadlessFrontend frontend { pixelRatio, fileSourceOptions };
+    Map map(frontend, MapObserver::nullObserver(), frontend.getSize(), pixelRatio,
+            MapOptions().withMapMode(MapMode::Static), fileSourceOptions);
     map.getStyle().loadJSON(util::read_file("test/fixtures/api/water.json"));
     map.jumpTo(CameraOptions().withCenter(LatLng { 37.8, -122.5 }).withZoom(10.0));
     map.getStyle().addLayer(std::make_unique<CustomLayer>(
diff --git a/test/api/query.test.cpp b/test/api/query.test.cpp
index b7359e4e60..99b74ab393 100644
--- a/test/api/query.test.cpp
+++ b/test/api/query.test.cpp
@@ -1,6 +1,7 @@
 #include <mbgl/map/map.hpp>
-#include <mbgl/map/map_options.hpp>
 #include <mbgl/test/stub_file_source.hpp>
+#include <mbgl/map/map_options.hpp>
+#include <mbgl/platform/factory.hpp>
 #include <mbgl/test/util.hpp>
 #include <mbgl/util/image.hpp>
 #include <mbgl/util/io.hpp>
@@ -32,15 +33,17 @@ public:
     }
 
     util::RunLoop loop;
-    StubFileSource fileSource;
+    FileSourceOptions stubFileSourceOptions;
+    std::shared_ptr<FileSource> fileSource = platform::Factory::sharedFileSource(stubFileSourceOptions, std::make_shared<StubFileSource>());
     float pixelRatio { 1 };
-    HeadlessFrontend frontend { pixelRatio, fileSource };
-    Map map { frontend, MapObserver::nullObserver(), frontend.getSize(), pixelRatio, fileSource,
-              MapOptions().withMapMode(MapMode::Static)};
+    HeadlessFrontend frontend { pixelRatio, stubFileSourceOptions };
+    Map map { frontend, MapObserver::nullObserver(), frontend.getSize(), pixelRatio,
+              MapOptions().withMapMode(MapMode::Static), stubFileSourceOptions };
 };
 
 std::vector<Feature> getTopClusterFeature(QueryTest& test) {
-    test.fileSource.sourceResponse = [&] (const Resource& resource) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->sourceResponse = [&] (const Resource& resource) {
         EXPECT_EQ("http://url"s, resource.url);
         Response response;
         response.data = std::make_unique<std::string>(util::read_file("test/fixtures/supercluster/places.json"s));
@@ -52,7 +55,7 @@ std::vector<Feature> getTopClusterFeature(QueryTest& test) {
     options.cluster = true;
     auto source = std::make_unique<GeoJSONSource>("cluster_source"s, options);
     source->setURL("http://url"s);
-    source->loadDescription(test.fileSource);
+    source->loadDescription(stubFileSource);
 
     auto clusterLayer = std::make_unique<SymbolLayer>("cluster_layer"s, "cluster_source"s);
     clusterLayer->setIconImage("test-icon"s);
diff --git a/test/api/recycle_map.cpp b/test/api/recycle_map.cpp
index 5598dfbd85..fe6161d6fa 100644
--- a/test/api/recycle_map.cpp
+++ b/test/api/recycle_map.cpp
@@ -4,6 +4,7 @@
 #include <mbgl/gl/headless_frontend.hpp>
 #include <mbgl/map/map.hpp>
 #include <mbgl/map/map_options.hpp>
+#include <mbgl/platform/factory.hpp>
 #include <mbgl/renderer/backend_scope.hpp>
 #include <mbgl/storage/online_file_source.hpp>
 #include <mbgl/style/layers/symbol_layer.hpp>
@@ -23,13 +24,13 @@ using namespace mbgl::style;
 TEST(API, RecycleMapUpdateImages) {
     util::RunLoop loop;
 
-    StubFileSource fileSource;
+    auto fileSource = platform::Factory::sharedFileSource({}, std::make_shared<StubFileSource>());
     float pixelRatio { 1 };
 
-    HeadlessFrontend frontend { pixelRatio, fileSource };
-    auto map = std::make_unique<Map>(frontend, MapObserver::nullObserver(), frontend.getSize(),
-                                     pixelRatio, fileSource,
-                                     MapOptions().withMapMode(MapMode::Static));
+    FileSourceOptions stubFileSourceOptions;
+    HeadlessFrontend frontend { pixelRatio, stubFileSourceOptions };
+    auto map = std::make_unique<Map>(frontend, MapObserver::nullObserver(), frontend.getSize(), pixelRatio,
+                                     MapOptions().withMapMode(MapMode::Static), stubFileSourceOptions );
 
     EXPECT_TRUE(map);
 
diff --git a/test/gl/context.test.cpp b/test/gl/context.test.cpp
index 5703792a7d..a0024f24df 100644
--- a/test/gl/context.test.cpp
+++ b/test/gl/context.test.cpp
@@ -1,6 +1,7 @@
 #include <mbgl/test/util.hpp>
 
 #include <mbgl/platform/gl_functions.hpp>
+#include <mbgl/platform/factory.hpp>
 #include <mbgl/gl/context.hpp>
 #include <mbgl/map/map.hpp>
 #include <mbgl/map/map_options.hpp>
@@ -85,13 +86,14 @@ struct Buffer {
 TEST(GLContextMode, Shared) {
     util::RunLoop loop;
 
-    DefaultFileSource fileSource(":memory:", "test/fixtures/api/assets");
     float pixelRatio { 1 };
 
-    HeadlessFrontend frontend { pixelRatio, fileSource, {}, GLContextMode::Shared };
+    auto fileSourceOptions = FileSourceOptions().withCachePath(":memory:").withAssetRoot("test/fixtures/api/assets");
+
+    HeadlessFrontend frontend { pixelRatio, fileSourceOptions, {}, GLContextMode::Shared };
 
     Map map(frontend, MapObserver::nullObserver(), frontend.getSize(), pixelRatio,
-            fileSource, MapOptions().withMapMode(MapMode::Static));
+            MapOptions().withMapMode(MapMode::Static), fileSourceOptions);
     map.getStyle().loadJSON(util::read_file("test/fixtures/api/water.json"));
     map.jumpTo(CameraOptions().withCenter(LatLng { 37.8, -122.5 }).withZoom(10.0));
 
diff --git a/test/map/map.test.cpp b/test/map/map.test.cpp
index ecbb92d164..6970ab8b72 100644
--- a/test/map/map.test.cpp
+++ b/test/map/map.test.cpp
@@ -6,6 +6,7 @@
 
 #include <mbgl/map/map.hpp>
 #include <mbgl/map/map_options.hpp>
+#include <mbgl/platform/factory.hpp>
 #include <mbgl/gl/context.hpp>
 #include <mbgl/gl/headless_frontend.hpp>
 #include <mbgl/storage/network_status.hpp>
@@ -26,29 +27,31 @@ using namespace mbgl;
 using namespace mbgl::style;
 using namespace std::literals::string_literals;
 
-template <class FileSource = StubFileSource>
+template <class T = StubFileSource>
 class MapTest {
 public:
     util::RunLoop runLoop;
-    FileSource fileSource;
+    FileSourceOptions fileSourceOptions;
+    std::shared_ptr<FileSource> fileSource;
     StubMapObserver observer;
     HeadlessFrontend frontend;
     Map map;
 
     MapTest(float pixelRatio = 1, MapMode mode = MapMode::Static)
-        : frontend(pixelRatio, fileSource)
+        : fileSource(platform::Factory::sharedFileSource(fileSourceOptions, std::make_shared<T>()))
+        , frontend(pixelRatio, fileSourceOptions)
         , map(frontend, observer, frontend.getSize(), pixelRatio,
-              fileSource, MapOptions().withMapMode(mode)) {
+              MapOptions().withMapMode(mode), fileSourceOptions) {
     }
 
-    template <typename T = FileSource>
+    template <typename U = T>
     MapTest(const std::string& cachePath, const std::string& assetRoot,
             float pixelRatio = 1, MapMode mode = MapMode::Static,
-            typename std::enable_if<std::is_same<T, DefaultFileSource>::value>::type* = 0)
-            : fileSource { cachePath, assetRoot }
-            , frontend(pixelRatio, fileSource)
-            , map(frontend, observer, frontend.getSize(), pixelRatio,
-                  fileSource, MapOptions().withMapMode(mode)) {
+            typename std::enable_if<std::is_same<U, DefaultFileSource>::value>::type* = 0)
+            : fileSourceOptions(FileSourceOptions().withCachePath(cachePath).withAssetRoot(assetRoot))
+            , fileSource(platform::Factory::sharedFileSource(fileSourceOptions))
+            , frontend(pixelRatio, fileSourceOptions)
+            , map(frontend, observer, frontend.getSize(), pixelRatio, MapOptions().withMapMode(mode), fileSourceOptions) {
     }
 };
 
@@ -233,12 +236,13 @@ TEST(Map, Offline) {
     };
 
     const std::string prefix = "http://127.0.0.1:3000/";
-    test.fileSource.put(Resource::style(prefix + "style.json"), expiredItem("style.json"));
-    test.fileSource.put(Resource::source(prefix + "streets.json"), expiredItem("streets.json"));
-    test.fileSource.put(Resource::spriteJSON(prefix + "sprite", 1.0), expiredItem("sprite.json"));
-    test.fileSource.put(Resource::spriteImage(prefix + "sprite", 1.0), expiredItem("sprite.png"));
-    test.fileSource.put(Resource::tile(prefix + "{z}-{x}-{y}.vector.pbf", 1.0, 0, 0, 0, Tileset::Scheme::XYZ), expiredItem("0-0-0.vector.pbf"));
-    test.fileSource.put(Resource::glyphs(prefix + "{fontstack}/{range}.pbf", {{"Helvetica"}}, {0, 255}), expiredItem("glyph.pbf"));
+    auto fileSource = std::static_pointer_cast<DefaultFileSource>(test.fileSource);
+    fileSource->put(Resource::style(prefix + "style.json"), expiredItem("style.json"));
+    fileSource->put(Resource::source(prefix + "streets.json"), expiredItem("streets.json"));
+    fileSource->put(Resource::spriteJSON(prefix + "sprite", 1.0), expiredItem("sprite.json"));
+    fileSource->put(Resource::spriteImage(prefix + "sprite", 1.0), expiredItem("sprite.png"));
+    fileSource->put(Resource::tile(prefix + "{z}-{x}-{y}.vector.pbf", 1.0, 0, 0, 0, Tileset::Scheme::XYZ), expiredItem("0-0-0.vector.pbf"));
+    fileSource->put(Resource::glyphs(prefix + "{fontstack}/{range}.pbf", {{"Helvetica"}}, {0, 255}), expiredItem("glyph.pbf"));
     NetworkStatus::Set(NetworkStatus::Status::Offline);
 
     test.map.getStyle().loadURL(prefix + "style.json");
@@ -306,7 +310,8 @@ TEST(Map, SetStyleInvalidJSON) {
 TEST(Map, SetStyleInvalidURL) {
     MapTest<> test;
 
-    test.fileSource.styleResponse = [] (const Resource&) {
+    auto fileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    fileSource->styleResponse = [] (const Resource&) {
         Response response;
         response.error = std::make_unique<Response::Error>(
             Response::Error::Reason::Other,
@@ -336,14 +341,16 @@ TEST(Map, StyleFresh) {
     MapTest<FakeFileSource> test;
 
     test.map.getStyle().loadURL("mapbox://styles/test");
-    EXPECT_EQ(1u, test.fileSource.requests.size());
+
+    auto fileSource = std::static_pointer_cast<FakeFileSource>(test.fileSource);
+    EXPECT_EQ(1u, fileSource->requests.size());
 
     Response response;
     response.data = std::make_shared<std::string>(util::read_file("test/fixtures/api/empty.json"));
     response.expires = Timestamp::max();
 
-    test.fileSource.respond(Resource::Style, response);
-    EXPECT_EQ(1u, test.fileSource.requests.size());
+    fileSource->respond(Resource::Style, response);
+    EXPECT_EQ(1u, fileSource->requests.size());
 }
 
 TEST(Map, StyleExpired) {
@@ -354,31 +361,33 @@ TEST(Map, StyleExpired) {
     MapTest<FakeFileSource> test;
 
     test.map.getStyle().loadURL("mapbox://styles/test");
-    EXPECT_EQ(1u, test.fileSource.requests.size());
+
+    auto fileSource = std::static_pointer_cast<FakeFileSource>(test.fileSource);
+    EXPECT_EQ(1u, fileSource->requests.size());
 
     Response response;
     response.data = std::make_shared<std::string>(util::read_file("test/fixtures/api/empty.json"));
     response.expires = util::now() - 1h;
 
-    test.fileSource.respond(Resource::Style, response);
-    EXPECT_EQ(1u, test.fileSource.requests.size());
+    fileSource->respond(Resource::Style, response);
+    EXPECT_EQ(1u, fileSource->requests.size());
 
     // Mutate layer. From now on, sending a response to the style won't overwrite it anymore, but
     // we should continue to wait for a fresh response.
     test.map.getStyle().addLayer(std::make_unique<style::BackgroundLayer>("bg"));
-    EXPECT_EQ(1u, test.fileSource.requests.size());
+    EXPECT_EQ(1u, fileSource->requests.size());
 
     // Send another expired response, and confirm that we didn't overwrite the style, but continue
     // to wait for a fresh response.
-    test.fileSource.respond(Resource::Style, response);
-    EXPECT_EQ(1u, test.fileSource.requests.size());
+    fileSource->respond(Resource::Style, response);
+    EXPECT_EQ(1u, fileSource->requests.size());
     EXPECT_NE(nullptr, test.map.getStyle().getLayer("bg"));
 
     // Send a fresh response, and confirm that we didn't overwrite the style, but continue to wait
     // for a fresh response.
     response.expires = util::now() + 1h;
-    test.fileSource.respond(Resource::Style, response);
-    EXPECT_EQ(1u, test.fileSource.requests.size());
+    fileSource->respond(Resource::Style, response);
+    EXPECT_EQ(1u, fileSource->requests.size());
     EXPECT_NE(nullptr, test.map.getStyle().getLayer("bg"));
 }
 
@@ -390,20 +399,22 @@ TEST(Map, StyleExpiredWithAnnotations) {
     MapTest<FakeFileSource> test;
 
     test.map.getStyle().loadURL("mapbox://styles/test");
-    EXPECT_EQ(1u, test.fileSource.requests.size());
+
+    auto fileSource = std::static_pointer_cast<FakeFileSource>(test.fileSource);
+    EXPECT_EQ(1u, fileSource->requests.size());
 
     Response response;
     response.data = std::make_shared<std::string>(util::read_file("test/fixtures/api/empty.json"));
     response.expires = util::now() - 1h;
 
-    test.fileSource.respond(Resource::Style, response);
-    EXPECT_EQ(1u, test.fileSource.requests.size());
+    fileSource->respond(Resource::Style, response);
+    EXPECT_EQ(1u, fileSource->requests.size());
 
     test.map.addAnnotation(LineAnnotation { LineString<double> {{ { 0, 0 }, { 10, 10 } }} });
-    EXPECT_EQ(1u, test.fileSource.requests.size());
+    EXPECT_EQ(1u, fileSource->requests.size());
 
-    test.fileSource.respond(Resource::Style, response);
-    EXPECT_EQ(1u, test.fileSource.requests.size());
+    fileSource->respond(Resource::Style, response);
+    EXPECT_EQ(1u, fileSource->requests.size());
 }
 
 TEST(Map, StyleExpiredWithRender) {
@@ -414,20 +425,22 @@ TEST(Map, StyleExpiredWithRender) {
     MapTest<FakeFileSource> test;
 
     test.map.getStyle().loadURL("mapbox://styles/test");
-    EXPECT_EQ(1u, test.fileSource.requests.size());
+
+    auto fileSource = std::static_pointer_cast<FakeFileSource>(test.fileSource);
+    EXPECT_EQ(1u, fileSource->requests.size());
 
     Response response;
     response.data = std::make_shared<std::string>(util::read_file("test/fixtures/api/empty.json"));
     response.expires = util::now() - 1h;
 
-    test.fileSource.respond(Resource::Style, response);
-    EXPECT_EQ(1u, test.fileSource.requests.size());
+    fileSource->respond(Resource::Style, response);
+    EXPECT_EQ(1u, fileSource->requests.size());
 
     test.frontend.render(test.map);
-    EXPECT_EQ(1u, test.fileSource.requests.size());
+    EXPECT_EQ(1u, fileSource->requests.size());
 
-    test.fileSource.respond(Resource::Style, response);
-    EXPECT_EQ(1u, test.fileSource.requests.size());
+    fileSource->respond(Resource::Style, response);
+    EXPECT_EQ(1u, fileSource->requests.size());
 }
 
 TEST(Map, StyleEarlyMutation) {
@@ -440,9 +453,10 @@ TEST(Map, StyleEarlyMutation) {
 
     Response response;
     response.data = std::make_shared<std::string>(util::read_file("test/fixtures/api/water.json"));
-    test.fileSource.respond(Resource::Style, response);
+    auto fileSource = std::static_pointer_cast<FakeFileSource>(test.fileSource);
+    fileSource->respond(Resource::Style, response);
 
-    EXPECT_EQ(1u, test.fileSource.requests.size());
+    EXPECT_EQ(1u, fileSource->requests.size());
     EXPECT_NE(nullptr, test.map.getStyle().getLayer("water"));
 }
 
@@ -564,7 +578,8 @@ TEST(Map, DisabledSources) {
     MapTest<> test;
 
     // Always load the same image tile for raster layers.
-    test.fileSource.response = [] (const Resource& res) -> optional<Response> {
+    auto fileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    fileSource->response = [] (const Resource& res) -> optional<Response> {
         if (res.url == "asset://tile.png") {
             Response response;
             response.data = std::make_shared<std::string>(
@@ -640,7 +655,8 @@ TEST(Map, DontLoadUnneededTiles) {
     using Tiles = std::unordered_set<std::string>;
     Tiles tiles;
 
-    test.fileSource.tileResponse = [&](const Resource& rsc) {
+    auto fileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    fileSource->tileResponse = [&](const Resource& rsc) {
         tiles.emplace(rsc.url);
         Response res;
         res.noContent = true;
@@ -669,7 +685,7 @@ TEST(Map, DontLoadUnneededTiles) {
 
 TEST(Map, TEST_DISABLED_ON_CI(ContinuousRendering)) {
     util::RunLoop runLoop;
-    DefaultFileSource fileSource(":memory:", "test/fixtures/api/assets");
+    auto fileSource = platform::Factory::sharedFileSource(FileSourceOptions().withCachePath(":memory:").withAssetRoot("test/fixtures/api/assets"));
     float pixelRatio { 1 };
 
     using namespace std::chrono_literals;
@@ -682,7 +698,8 @@ TEST(Map, TEST_DISABLED_ON_CI(ContinuousRendering)) {
 
     util::Timer timer;
 
-    HeadlessFrontend frontend(pixelRatio, fileSource);
+    FileSourceOptions fileSourceOptions;
+    HeadlessFrontend frontend(pixelRatio, fileSourceOptions);
 
     StubMapObserver observer;
     observer.didFinishRenderingFrameCallback = [&] (MapObserver::RenderMode) {
@@ -694,8 +711,8 @@ TEST(Map, TEST_DISABLED_ON_CI(ContinuousRendering)) {
         });
     };
 
-    Map map(frontend, observer, frontend.getSize(), pixelRatio, fileSource,
-            MapOptions().withMapMode(MapMode::Continuous));
+    Map map(frontend, observer, frontend.getSize(), pixelRatio,
+            MapOptions().withMapMode(MapMode::Continuous), fileSourceOptions);
     map.getStyle().loadJSON(util::read_file("test/fixtures/api/water.json"));
 
     runLoop.run();
@@ -710,9 +727,10 @@ TEST(Map, NoContentTiles) {
     Response response;
     response.noContent = true;
     response.expires = util::now() + 1h;
-    test.fileSource.put(Resource::tile("http://example.com/{z}-{x}-{y}.vector.pbf", 1.0, 0, 0, 0,
-                                       Tileset::Scheme::XYZ),
-                        response);
+    auto fileSource = std::static_pointer_cast<DefaultFileSource>(test.fileSource);
+    fileSource->put(Resource::tile("http://example.com/{z}-{x}-{y}.vector.pbf", 1.0, 0, 0, 0,
+                                   Tileset::Scheme::XYZ),
+                    response);
 
     test.map.getStyle().loadJSON(R"STYLE({
       "version": 8,
@@ -747,7 +765,8 @@ TEST(Map, NoContentTiles) {
 TEST(Map, Issue12432) {
     MapTest<> test { 1, MapMode::Continuous };
 
-    test.fileSource.tileResponse = [&](const Resource&) {
+    auto fileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    fileSource->tileResponse = [&](const Resource&) {
         Response result;
         result.data = std::make_shared<std::string>(util::read_file("test/fixtures/map/issue12432/0-0-0.mvt"));
         return result;
diff --git a/test/map/prefetch.test.cpp b/test/map/prefetch.test.cpp
index ba1bd5258e..ac42495b56 100644
--- a/test/map/prefetch.test.cpp
+++ b/test/map/prefetch.test.cpp
@@ -4,6 +4,7 @@
 
 #include <mbgl/map/map.hpp>
 #include <mbgl/map/map_options.hpp>
+#include <mbgl/platform/factory.hpp>
 #include <mbgl/gl/headless_frontend.hpp>
 #include <mbgl/storage/default_file_source.hpp>
 #include <mbgl/style/style.hpp>
@@ -22,7 +23,9 @@ using namespace std::chrono_literals;
 
 TEST(Map, PrefetchTiles) {
     util::RunLoop runLoop;
-    StubFileSource fileSource;
+
+    FileSourceOptions stubFileSourceOptions;
+    auto fileSource = platform::Factory::sharedFileSource(stubFileSourceOptions, std::make_shared<StubFileSource>());
 
     util::Timer emergencyShutoff;
     emergencyShutoff.start(10s, 0s, [&] {
@@ -35,13 +38,14 @@ TEST(Map, PrefetchTiles) {
         runLoop.stop();
     };
 
-    HeadlessFrontend frontend { { 512, 512 }, 1, fileSource };
-    Map map(frontend, observer, frontend.getSize(), 1, fileSource,
-            MapOptions().withMapMode(MapMode::Continuous));
+    HeadlessFrontend frontend { { 512, 512 }, 1, stubFileSourceOptions };
+    Map map(frontend, observer, frontend.getSize(), 1,
+            MapOptions().withMapMode(MapMode::Continuous), stubFileSourceOptions);
 
     std::vector<int> tiles;
 
-    fileSource.response = [&] (const Resource& res) -> optional<Response> {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(fileSource);
+    stubFileSource->response = [&] (const Resource& res) -> optional<Response> {
         static std::string tile = util::read_file("test/fixtures/map/prefetch/tile.png");
 
         auto zoom = std::stoi(res.url);
diff --git a/test/sprite/sprite_loader.test.cpp b/test/sprite/sprite_loader.test.cpp
index 122e711f51..0e681615c9 100644
--- a/test/sprite/sprite_loader.test.cpp
+++ b/test/sprite/sprite_loader.test.cpp
@@ -2,6 +2,7 @@
 #include <mbgl/test/fixture_log_observer.hpp>
 #include <mbgl/test/stub_file_source.hpp>
 
+#include <mbgl/platform/factory.hpp>
 #include <mbgl/sprite/sprite_loader.hpp>
 #include <mbgl/sprite/sprite_loader_observer.hpp>
 #include <mbgl/sprite/sprite_parser.hpp>
@@ -34,16 +35,17 @@ public:
     SpriteLoaderTest() = default;
 
     util::RunLoop loop;
-    StubFileSource fileSource;
+    FileSourceOptions stubFileSourceOptions;
+    std::shared_ptr<FileSource> fileSource = platform::Factory::sharedFileSource(stubFileSourceOptions, std::make_shared<StubFileSource>());
     StubSpriteLoaderObserver observer;
-    SpriteLoader spriteLoader{ 1 };
+    SpriteLoader spriteLoader{ 1.0, stubFileSourceOptions };
 
     void run() {
         // Squelch logging.
         Log::setObserver(std::make_unique<Log::NullObserver>());
 
         spriteLoader.setObserver(&observer);
-        spriteLoader.load("test/fixtures/resources/sprite", fileSource);
+        spriteLoader.load("test/fixtures/resources/sprite");
 
         loop.run();
     }
@@ -84,8 +86,9 @@ Response corruptSpriteResponse(const Resource&) {
 TEST(SpriteLoader, LoadingSuccess) {
     SpriteLoaderTest test;
 
-    test.fileSource.spriteImageResponse = successfulSpriteImageResponse;
-    test.fileSource.spriteJSONResponse = successfulSpriteJSONResponse;
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->spriteImageResponse = successfulSpriteImageResponse;
+    stubFileSource->spriteJSONResponse = successfulSpriteJSONResponse;
 
     test.observer.spriteError = [&] (std::exception_ptr error) {
         FAIL() << util::toString(error);
@@ -103,8 +106,9 @@ TEST(SpriteLoader, LoadingSuccess) {
 TEST(SpriteLoader, JSONLoadingFail) {
     SpriteLoaderTest test;
 
-    test.fileSource.spriteImageResponse = successfulSpriteImageResponse;
-    test.fileSource.spriteJSONResponse = failedSpriteResponse;
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->spriteImageResponse = successfulSpriteImageResponse;
+    stubFileSource->spriteJSONResponse = failedSpriteResponse;
 
     test.observer.spriteError = [&] (std::exception_ptr error) {
         EXPECT_TRUE(error != nullptr);
@@ -118,8 +122,9 @@ TEST(SpriteLoader, JSONLoadingFail) {
 TEST(SpriteLoader, ImageLoadingFail) {
     SpriteLoaderTest test;
 
-    test.fileSource.spriteImageResponse = failedSpriteResponse;
-    test.fileSource.spriteJSONResponse = successfulSpriteJSONResponse;
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->spriteImageResponse = failedSpriteResponse;
+    stubFileSource->spriteJSONResponse = successfulSpriteJSONResponse;
 
     test.observer.spriteError = [&] (std::exception_ptr error) {
         EXPECT_TRUE(error != nullptr);
@@ -133,8 +138,9 @@ TEST(SpriteLoader, ImageLoadingFail) {
 TEST(SpriteLoader, JSONLoadingCorrupted) {
     SpriteLoaderTest test;
 
-    test.fileSource.spriteImageResponse = successfulSpriteImageResponse;
-    test.fileSource.spriteJSONResponse = corruptSpriteResponse;
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->spriteImageResponse = successfulSpriteImageResponse;
+    stubFileSource->spriteJSONResponse = corruptSpriteResponse;
 
     test.observer.spriteError = [&] (std::exception_ptr error) {
         EXPECT_TRUE(error != nullptr);
@@ -148,8 +154,9 @@ TEST(SpriteLoader, JSONLoadingCorrupted) {
 TEST(SpriteLoader, ImageLoadingCorrupted) {
     SpriteLoaderTest test;
 
-    test.fileSource.spriteImageResponse = corruptSpriteResponse;
-    test.fileSource.spriteJSONResponse = successfulSpriteJSONResponse;
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->spriteImageResponse = corruptSpriteResponse;
+    stubFileSource->spriteJSONResponse = successfulSpriteJSONResponse;
 
     test.observer.spriteError = [&] (std::exception_ptr error) {
         EXPECT_TRUE(error != nullptr);
@@ -163,8 +170,9 @@ TEST(SpriteLoader, ImageLoadingCorrupted) {
 TEST(SpriteLoader, LoadingCancel) {
     SpriteLoaderTest test;
 
-    test.fileSource.spriteImageResponse =
-    test.fileSource.spriteJSONResponse = [&] (const Resource&) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->spriteImageResponse =
+    stubFileSource->spriteJSONResponse = [&] (const Resource&) {
         test.end();
         return optional<Response>();
     };
diff --git a/test/style/source.test.cpp b/test/style/source.test.cpp
index 73212189de..127a3b78a1 100644
--- a/test/style/source.test.cpp
+++ b/test/style/source.test.cpp
@@ -37,6 +37,7 @@
 #include <mbgl/annotation/annotation_source.hpp>
 #include <mbgl/renderer/image_manager.hpp>
 #include <mbgl/text/glyph_manager.hpp>
+#include <mbgl/platform/factory.hpp>
 
 #include <cstdint>
 
@@ -46,21 +47,23 @@ using SourceType = mbgl::style::SourceType;
 class SourceTest {
 public:
     util::RunLoop loop;
-    StubFileSource fileSource;
+    FileSourceOptions stubFileSourceOptions;
+    std::shared_ptr<FileSource> fileSource = platform::Factory::sharedFileSource(
+        stubFileSourceOptions, std::make_shared<StubFileSource>());
     StubStyleObserver styleObserver;
     StubRenderSourceObserver renderSourceObserver;
     Transform transform;
     TransformState transformState;
-    Style style { fileSource, 1 };
+    Style style { 1.0, stubFileSourceOptions };
     AnnotationManager annotationManager { style };
     ImageManager imageManager;
-    GlyphManager glyphManager { fileSource };
+    GlyphManager glyphManager { stubFileSourceOptions };
 
     TileParameters tileParameters {
         1.0,
+        fileSource,
         MapDebugOptions(),
         transformState,
-        fileSource,
         MapMode::Continuous,
         annotationManager,
         imageManager,
@@ -90,7 +93,8 @@ public:
 TEST(Source, LoadingFail) {
     SourceTest test;
 
-    test.fileSource.sourceResponse = [&] (const Resource& resource) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->sourceResponse = [&] (const Resource& resource) {
         EXPECT_EQ("url", resource.url);
         Response response;
         response.error = std::make_unique<Response::Error>(
@@ -107,7 +111,7 @@ TEST(Source, LoadingFail) {
 
     VectorSource source("source", "url");
     source.setObserver(&test.styleObserver);
-    source.loadDescription(test.fileSource);
+    source.loadDescription(stubFileSource);
 
     test.run();
 }
@@ -115,7 +119,8 @@ TEST(Source, LoadingFail) {
 TEST(Source, LoadingCorrupt) {
     SourceTest test;
 
-    test.fileSource.sourceResponse = [&] (const Resource& resource) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->sourceResponse = [&] (const Resource& resource) {
         EXPECT_EQ("url", resource.url);
         Response response;
         response.data = std::make_unique<std::string>("CORRUPTED");
@@ -130,7 +135,7 @@ TEST(Source, LoadingCorrupt) {
 
     VectorSource source("source", "url");
     source.setObserver(&test.styleObserver);
-    source.loadDescription(test.fileSource);
+    source.loadDescription(stubFileSource);
 
     test.run();
 }
@@ -138,7 +143,8 @@ TEST(Source, LoadingCorrupt) {
 TEST(Source, RasterTileEmpty) {
     SourceTest test;
 
-    test.fileSource.tileResponse = [&] (const Resource&) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->tileResponse = [&] (const Resource&) {
         Response response;
         response.noContent = true;
         return response;
@@ -151,7 +157,7 @@ TEST(Source, RasterTileEmpty) {
     tileset.tiles = { "tiles" };
 
     RasterSource source("source", tileset, 512);
-    source.loadDescription(test.fileSource);
+    source.loadDescription(stubFileSource);
 
     test.renderSourceObserver.tileChanged = [&] (RenderSource& source_, const OverscaledTileID&) {
         EXPECT_EQ("source", source_.baseImpl->id);
@@ -176,7 +182,8 @@ TEST(Source, RasterTileEmpty) {
 TEST(Source, RasterDEMTileEmpty) {
     SourceTest test;
 
-    test.fileSource.tileResponse = [&] (const Resource&) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->tileResponse = [&] (const Resource&) {
         Response response;
         response.noContent = true;
         return response;
@@ -189,7 +196,7 @@ TEST(Source, RasterDEMTileEmpty) {
     tileset.tiles = { "tiles" };
 
     RasterDEMSource source("source", tileset, 512);
-    source.loadDescription(test.fileSource);
+    source.loadDescription(stubFileSource);
 
     test.renderSourceObserver.tileChanged = [&] (RenderSource& source_, const OverscaledTileID&) {
         EXPECT_EQ("source", source_.baseImpl->id);
@@ -214,7 +221,8 @@ TEST(Source, RasterDEMTileEmpty) {
 TEST(Source, VectorTileEmpty) {
     SourceTest test;
 
-    test.fileSource.tileResponse = [&] (const Resource&) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->tileResponse = [&] (const Resource&) {
         Response response;
         response.noContent = true;
         return response;
@@ -229,7 +237,7 @@ TEST(Source, VectorTileEmpty) {
     tileset.tiles = { "tiles" };
 
     VectorSource source("source", tileset);
-    source.loadDescription(test.fileSource);
+    source.loadDescription(stubFileSource);
 
     test.renderSourceObserver.tileChanged = [&] (RenderSource& source_, const OverscaledTileID&) {
         EXPECT_EQ("source", source_.baseImpl->id);
@@ -254,7 +262,8 @@ TEST(Source, VectorTileEmpty) {
 TEST(Source, RasterTileFail) {
     SourceTest test;
 
-    test.fileSource.tileResponse = [&] (const Resource&) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->tileResponse = [&] (const Resource&) {
         Response response;
         response.error = std::make_unique<Response::Error>(
             Response::Error::Reason::Other,
@@ -269,7 +278,7 @@ TEST(Source, RasterTileFail) {
     tileset.tiles = { "tiles" };
 
     RasterSource source("source", tileset, 512);
-    source.loadDescription(test.fileSource);
+    source.loadDescription(stubFileSource);
 
     test.renderSourceObserver.tileError = [&] (RenderSource& source_, const OverscaledTileID& tileID, std::exception_ptr error) {
         EXPECT_EQ(SourceType::Raster, source_.baseImpl->type);
@@ -292,7 +301,8 @@ TEST(Source, RasterTileFail) {
 TEST(Source, RasterDEMTileFail) {
     SourceTest test;
 
-    test.fileSource.tileResponse = [&] (const Resource&) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->tileResponse = [&] (const Resource&) {
         Response response;
         response.error = std::make_unique<Response::Error>(
             Response::Error::Reason::Other,
@@ -307,7 +317,7 @@ TEST(Source, RasterDEMTileFail) {
     tileset.tiles = { "tiles" };
 
     RasterDEMSource source("source", tileset, 512);
-    source.loadDescription(test.fileSource);
+    source.loadDescription(stubFileSource);
 
     test.renderSourceObserver.tileError = [&] (RenderSource& source_, const OverscaledTileID& tileID, std::exception_ptr error) {
         EXPECT_EQ(SourceType::RasterDEM, source_.baseImpl->type);
@@ -330,7 +340,8 @@ TEST(Source, RasterDEMTileFail) {
 TEST(Source, VectorTileFail) {
     SourceTest test;
 
-    test.fileSource.tileResponse = [&] (const Resource&) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->tileResponse = [&] (const Resource&) {
         Response response;
         response.error = std::make_unique<Response::Error>(
             Response::Error::Reason::Other,
@@ -347,7 +358,7 @@ TEST(Source, VectorTileFail) {
     tileset.tiles = { "tiles" };
 
     VectorSource source("source", tileset);
-    source.loadDescription(test.fileSource);
+    source.loadDescription(stubFileSource);
 
     test.renderSourceObserver.tileError = [&] (RenderSource& source_, const OverscaledTileID& tileID, std::exception_ptr error) {
         EXPECT_EQ(SourceType::Vector, source_.baseImpl->type);
@@ -370,7 +381,8 @@ TEST(Source, VectorTileFail) {
 TEST(Source, RasterTileCorrupt) {
     SourceTest test;
 
-    test.fileSource.tileResponse = [&] (const Resource&) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->tileResponse = [&] (const Resource&) {
         Response response;
         response.data = std::make_unique<std::string>("CORRUPTED");
         return response;
@@ -383,7 +395,7 @@ TEST(Source, RasterTileCorrupt) {
     tileset.tiles = { "tiles" };
 
     RasterSource source("source", tileset, 512);
-    source.loadDescription(test.fileSource);
+    source.loadDescription(stubFileSource);
 
     test.renderSourceObserver.tileError = [&] (RenderSource& source_, const OverscaledTileID& tileID, std::exception_ptr error) {
         EXPECT_EQ(source_.baseImpl->type, SourceType::Raster);
@@ -407,7 +419,8 @@ TEST(Source, RasterTileCorrupt) {
 TEST(Source, RasterDEMTileCorrupt) {
     SourceTest test;
 
-    test.fileSource.tileResponse = [&] (const Resource&) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->tileResponse = [&] (const Resource&) {
         Response response;
         response.data = std::make_unique<std::string>("CORRUPTED");
         return response;
@@ -420,7 +433,7 @@ TEST(Source, RasterDEMTileCorrupt) {
     tileset.tiles = { "tiles" };
 
     RasterDEMSource source("source", tileset, 512);
-    source.loadDescription(test.fileSource);
+    source.loadDescription(stubFileSource);
 
     test.renderSourceObserver.tileError = [&] (RenderSource& source_, const OverscaledTileID& tileID, std::exception_ptr error) {
         EXPECT_EQ(source_.baseImpl->type, SourceType::RasterDEM);
@@ -444,7 +457,8 @@ TEST(Source, RasterDEMTileCorrupt) {
 TEST(Source, VectorTileCorrupt) {
     SourceTest test;
 
-    test.fileSource.tileResponse = [&] (const Resource&) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->tileResponse = [&] (const Resource&) {
         Response response;
         response.data = std::make_unique<std::string>("CORRUPTED");
         return response;
@@ -459,7 +473,7 @@ TEST(Source, VectorTileCorrupt) {
     tileset.tiles = { "tiles" };
 
     VectorSource source("source", tileset);
-    source.loadDescription(test.fileSource);
+    source.loadDescription(stubFileSource);
 
     test.renderSourceObserver.tileError = [&] (RenderSource& source_, const OverscaledTileID& tileID, std::exception_ptr error) {
         EXPECT_EQ(source_.baseImpl->type, SourceType::Vector);
@@ -482,7 +496,8 @@ TEST(Source, VectorTileCorrupt) {
 TEST(Source, RasterTileCancel) {
     SourceTest test;
 
-    test.fileSource.tileResponse = [&] (const Resource&) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->tileResponse = [&] (const Resource&) {
         test.end();
         return optional<Response>();
     };
@@ -494,7 +509,7 @@ TEST(Source, RasterTileCancel) {
     tileset.tiles = { "tiles" };
 
     RasterSource source("source", tileset, 512);
-    source.loadDescription(test.fileSource);
+    source.loadDescription(stubFileSource);
 
     test.renderSourceObserver.tileChanged = [&] (RenderSource&, const OverscaledTileID&) {
         FAIL() << "Should never be called";
@@ -518,7 +533,8 @@ TEST(Source, RasterTileCancel) {
 TEST(Source, RasterDEMTileCancel) {
     SourceTest test;
 
-    test.fileSource.tileResponse = [&] (const Resource&) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->tileResponse = [&] (const Resource&) {
         test.end();
         return optional<Response>();
     };
@@ -530,7 +546,7 @@ TEST(Source, RasterDEMTileCancel) {
     tileset.tiles = { "tiles" };
 
     RasterDEMSource source("source", tileset, 512);
-    source.loadDescription(test.fileSource);
+    source.loadDescription(stubFileSource);
 
     test.renderSourceObserver.tileChanged = [&] (RenderSource&, const OverscaledTileID&) {
         FAIL() << "Should never be called";
@@ -554,7 +570,8 @@ TEST(Source, RasterDEMTileCancel) {
 TEST(Source, VectorTileCancel) {
     SourceTest test;
 
-    test.fileSource.tileResponse = [&] (const Resource&) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->tileResponse = [&] (const Resource&) {
         test.end();
         return optional<Response>();
     };
@@ -568,7 +585,7 @@ TEST(Source, VectorTileCancel) {
     tileset.tiles = { "tiles" };
 
     VectorSource source("source", tileset);
-    source.loadDescription(test.fileSource);
+    source.loadDescription(stubFileSource);
 
     test.renderSourceObserver.tileChanged = [&] (RenderSource&, const OverscaledTileID&) {
         FAIL() << "Should never be called";
@@ -598,13 +615,14 @@ TEST(Source, RasterTileAttribution) {
     std::string mapboxOSM = ("<a href='https://www.mapbox.com/about/maps/' target='_blank'>&copy; Mapbox</a> "
                              "<a href='http://www.openstreetmap.org/about/' target='_blank'>©️ OpenStreetMap</a>");
 
-    test.fileSource.tileResponse = [&] (const Resource&) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->tileResponse = [&] (const Resource&) {
         Response response;
         response.noContent = true;
         return response;
     };
 
-    test.fileSource.sourceResponse = [&] (const Resource& resource) {
+    stubFileSource->sourceResponse = [&] (const Resource& resource) {
         EXPECT_EQ("url", resource.url);
         Response response;
         response.data = std::make_unique<std::string>(R"TILEJSON({ "tilejson": "2.1.0", "attribution": ")TILEJSON" +
@@ -621,7 +639,7 @@ TEST(Source, RasterTileAttribution) {
 
     RasterSource source("source", "url", 512);
     source.setObserver(&test.styleObserver);
-    source.loadDescription(test.fileSource);
+    source.loadDescription(stubFileSource);
 
     auto renderSource = RenderSource::create(source.baseImpl);
     renderSource->update(source.baseImpl,
@@ -641,13 +659,14 @@ TEST(Source, RasterDEMTileAttribution) {
 
     std::string mapbox = ("<a href='https://www.mapbox.com/about/maps/' target='_blank'>&copy; Mapbox</a> ");
 
-    test.fileSource.tileResponse = [&] (const Resource&) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->tileResponse = [&] (const Resource&) {
         Response response;
         response.noContent = true;
         return response;
     };
 
-    test.fileSource.sourceResponse = [&] (const Resource& resource) {
+    stubFileSource->sourceResponse = [&] (const Resource& resource) {
         EXPECT_EQ("url", resource.url);
         Response response;
         response.data = std::make_unique<std::string>(R"TILEJSON({ "tilejson": "2.1.0", "attribution": ")TILEJSON" +
@@ -663,7 +682,7 @@ TEST(Source, RasterDEMTileAttribution) {
 
     RasterDEMSource source("source", "url", 512);
     source.setObserver(&test.styleObserver);
-    source.loadDescription(test.fileSource);
+    source.loadDescription(stubFileSource);
 
     auto renderSource = RenderSource::create(source.baseImpl);
     renderSource->update(source.baseImpl,
@@ -678,7 +697,8 @@ TEST(Source, RasterDEMTileAttribution) {
 TEST(Source, GeoJSonSourceUrlUpdate) {
     SourceTest test;
 
-    test.fileSource.sourceResponse = [&] (const Resource& resource) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->sourceResponse = [&] (const Resource& resource) {
         EXPECT_EQ("url", resource.url);
         Response response;
         response.data = std::make_unique<std::string>(R"({"geometry": {"type": "Point", "coordinates": [1.1, 1.1]}, "type": "Feature", "properties": {}})");
@@ -694,7 +714,7 @@ TEST(Source, GeoJSonSourceUrlUpdate) {
     source.setObserver(&test.styleObserver);
 
     // Load initial, so the source state will be loaded=true
-    source.loadDescription(test.fileSource);
+    source.loadDescription(stubFileSource);
 
     // Schedule an update
     test.loop.invoke([&] () {
@@ -708,7 +728,8 @@ TEST(Source, GeoJSonSourceUrlUpdate) {
 TEST(Source, ImageSourceImageUpdate) {
     SourceTest test;
 
-    test.fileSource.response = [&] (const Resource& resource) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->response = [&] (const Resource& resource) {
         EXPECT_EQ("http://url", resource.url);
         Response response;
         response.data = std::make_unique<std::string>(util::read_file("test/fixtures/image/no_profile.png"));
@@ -725,7 +746,7 @@ TEST(Source, ImageSourceImageUpdate) {
     source.setObserver(&test.styleObserver);
 
     // Load initial, so the source state will be loaded=true
-    source.loadDescription(test.fileSource);
+    source.loadDescription(stubFileSource);
     PremultipliedImage rgba({ 1, 1 });
     rgba.data[0] = 255;
     rgba.data[1] = 254;
diff --git a/test/style/style.test.cpp b/test/style/style.test.cpp
index 72f74d3b01..a82868e242 100644
--- a/test/style/style.test.cpp
+++ b/test/style/style.test.cpp
@@ -2,6 +2,7 @@
 #include <mbgl/test/stub_file_source.hpp>
 #include <mbgl/test/fixture_log_observer.hpp>
 
+#include <mbgl/platform/factory.hpp>
 #include <mbgl/style/style_impl.hpp>
 #include <mbgl/style/source_impl.hpp>
 #include <mbgl/style/sources/vector_source.hpp>
@@ -18,8 +19,10 @@ using namespace mbgl::style;
 TEST(Style, Properties) {
     util::RunLoop loop;
 
-    StubFileSource fileSource;
-    Style::Impl style { fileSource, 1.0 };
+    FileSourceOptions stubFileSourceOptions;
+    auto fileSource = platform::Factory::sharedFileSource(
+        stubFileSourceOptions, std::make_shared<StubFileSource>());
+    Style::Impl style { 1.0, stubFileSourceOptions };
 
     style.loadJSON(R"STYLE({"name": "Test"})STYLE");
     ASSERT_EQ("Test", style.getName());
@@ -60,8 +63,10 @@ TEST(Style, Properties) {
 TEST(Style, DuplicateSource) {
     util::RunLoop loop;
 
-    StubFileSource fileSource;
-    Style::Impl style { fileSource, 1.0 };
+    FileSourceOptions stubFileSourceOptions;
+    auto fileSource = platform::Factory::sharedFileSource(
+        stubFileSourceOptions, std::make_shared<StubFileSource>());
+    Style::Impl style { 1.0, stubFileSourceOptions };
 
     style.loadJSON(util::read_file("test/fixtures/resources/style-unused-sources.json"));
 
@@ -81,8 +86,10 @@ TEST(Style, RemoveSourceInUse) {
     auto log = new FixtureLogObserver();
     Log::setObserver(std::unique_ptr<Log::Observer>(log));
 
-    StubFileSource fileSource;
-    Style::Impl style { fileSource, 1.0 };
+    FileSourceOptions stubFileSourceOptions;
+    auto fileSource = platform::Factory::sharedFileSource(
+        stubFileSourceOptions, std::make_shared<StubFileSource>());
+    Style::Impl style { 1.0, stubFileSourceOptions };
 
     style.loadJSON(util::read_file("test/fixtures/resources/style-unused-sources.json"));
 
diff --git a/test/style/style_layer.test.cpp b/test/style/style_layer.test.cpp
index 5f9de07dba..64c36ef6f7 100644
--- a/test/style/style_layer.test.cpp
+++ b/test/style/style_layer.test.cpp
@@ -1,6 +1,7 @@
 #include <mbgl/test/util.hpp>
 #include <mbgl/test/stub_layer_observer.hpp>
 #include <mbgl/test/stub_file_source.hpp>
+#include <mbgl/platform/factory.hpp>
 #include <mbgl/style/style_impl.hpp>
 #include <mbgl/style/layers/background_layer.hpp>
 #include <mbgl/style/layers/background_layer_impl.hpp>
@@ -272,8 +273,10 @@ TEST(Layer, DuplicateLayer) {
     util::RunLoop loop;
 
     // Setup style
-    StubFileSource fileSource;
-    Style::Impl style { fileSource, 1.0 };
+    FileSourceOptions stubFileSourceOptions;
+    std::shared_ptr<FileSource> fileSource = platform::Factory::sharedFileSource(
+        stubFileSourceOptions, std::make_shared<StubFileSource>());
+    Style::Impl style { 1.0, stubFileSourceOptions };
     style.loadJSON(util::read_file("test/fixtures/resources/style-unused-sources.json"));
 
     // Add initial layer
diff --git a/test/text/glyph_manager.test.cpp b/test/text/glyph_manager.test.cpp
index 3d7a220dc5..bcec1ad0cf 100644
--- a/test/text/glyph_manager.test.cpp
+++ b/test/text/glyph_manager.test.cpp
@@ -1,6 +1,7 @@
 #include <mbgl/test/util.hpp>
 #include <mbgl/test/stub_file_source.hpp>
 
+#include <mbgl/platform/factory.hpp>
 #include <mbgl/text/glyph_manager.hpp>
 #include <mbgl/util/run_loop.hpp>
 #include <mbgl/util/string.hpp>
@@ -65,10 +66,12 @@ public:
 class GlyphManagerTest {
 public:
     util::RunLoop loop;
-    StubFileSource fileSource;
+    FileSourceOptions stubFileSourceOptions;
+    std::shared_ptr<FileSource> fileSource = platform::Factory::sharedFileSource(
+        stubFileSourceOptions, std::make_shared<StubFileSource>());
     StubGlyphManagerObserver observer;
     StubGlyphRequestor requestor;
-    GlyphManager glyphManager{ fileSource, std::make_unique<StubLocalGlyphRasterizer>() };
+    GlyphManager glyphManager{ stubFileSourceOptions, std::make_unique<StubLocalGlyphRasterizer>() };
 
     void run(const std::string& url, GlyphDependencies dependencies) {
         // Squelch logging.
@@ -89,7 +92,8 @@ public:
 TEST(GlyphManager, LoadingSuccess) {
     GlyphManagerTest test;
 
-    test.fileSource.glyphsResponse = [&] (const Resource& resource) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->glyphsResponse = [&] (const Resource& resource) {
         EXPECT_EQ(Resource::Kind::Glyphs, resource.kind);
         Response response;
         response.data = std::make_shared<std::string>(util::read_file("test/fixtures/resources/glyphs.pbf"));
@@ -128,7 +132,8 @@ TEST(GlyphManager, LoadingSuccess) {
 TEST(GlyphManager, LoadingFail) {
     GlyphManagerTest test;
 
-    test.fileSource.glyphsResponse = [&] (const Resource&) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->glyphsResponse = [&] (const Resource&) {
         Response response;
         response.error = std::make_unique<Response::Error>(
             Response::Error::Reason::Other,
@@ -161,7 +166,8 @@ TEST(GlyphManager, LoadingFail) {
 TEST(GlyphManager, LoadingCorrupted) {
     GlyphManagerTest test;
 
-    test.fileSource.glyphsResponse = [&] (const Resource&) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->glyphsResponse = [&] (const Resource&) {
         Response response;
         response.data = std::make_unique<std::string>("CORRUPTED");
         return response;
@@ -192,7 +198,8 @@ TEST(GlyphManager, LoadingCorrupted) {
 TEST(GlyphManager, LoadingCancel) {
     GlyphManagerTest test;
 
-    test.fileSource.glyphsResponse = [&] (const Resource&) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->glyphsResponse = [&] (const Resource&) {
         test.end();
         return optional<Response>();
     };
@@ -212,7 +219,8 @@ TEST(GlyphManager, LoadLocalCJKGlyph) {
     GlyphManagerTest test;
     int glyphResponses = 0;
 
-    test.fileSource.glyphsResponse = [&] (const Resource&) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->glyphsResponse = [&] (const Resource&) {
         glyphResponses++;
         return optional<Response>();
     };
@@ -257,7 +265,8 @@ TEST(GlyphManager, LoadLocalCJKGlyph) {
 TEST(GlyphManager, LoadingInvalid) {
     GlyphManagerTest test;
 
-    test.fileSource.glyphsResponse = [&] (const Resource& resource) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->glyphsResponse = [&] (const Resource& resource) {
         EXPECT_EQ(Resource::Kind::Glyphs, resource.kind);
         Response response;
         response.data = std::make_shared<std::string>(util::read_file("test/fixtures/resources/fake_glyphs-0-255.pbf"));
@@ -295,10 +304,12 @@ TEST(GlyphManager, ImmediateFileSource) {
     class GlyphManagerTestSynchronous {
     public:
         util::RunLoop loop;
-        StubFileSource fileSource = { StubFileSource::ResponseType::Synchronous };
+        FileSourceOptions stubFileSourceOptions;
+        std::shared_ptr<FileSource> fileSource = platform::Factory::sharedFileSource(
+            stubFileSourceOptions, std::make_shared<StubFileSource>(StubFileSource::ResponseType::Synchronous));
         StubGlyphManagerObserver observer;
         StubGlyphRequestor requestor;
-        GlyphManager glyphManager { fileSource };
+        GlyphManager glyphManager { stubFileSourceOptions };
 
         void run(const std::string& url, GlyphDependencies dependencies) {
             // Squelch logging.
@@ -318,7 +329,8 @@ TEST(GlyphManager, ImmediateFileSource) {
 
     GlyphManagerTestSynchronous test;
 
-    test.fileSource.glyphsResponse = [&] (const Resource&) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->glyphsResponse = [&] (const Resource&) {
         Response response;
         response.data = std::make_shared<std::string>(util::read_file("test/fixtures/resources/glyphs.pbf"));
         return response;
diff --git a/test/text/local_glyph_rasterizer.test.cpp b/test/text/local_glyph_rasterizer.test.cpp
index 5c03945b8c..0d69ff5697 100644
--- a/test/text/local_glyph_rasterizer.test.cpp
+++ b/test/text/local_glyph_rasterizer.test.cpp
@@ -2,6 +2,7 @@
 #include <mbgl/test/stub_file_source.hpp>
 #include <mbgl/map/map.hpp>
 #include <mbgl/map/map_options.hpp>
+#include <mbgl/platform/factory.hpp>
 #include <mbgl/util/io.hpp>
 #include <mbgl/util/run_loop.hpp>
 #include <mbgl/util/color.hpp>
@@ -32,16 +33,18 @@ namespace {
 class LocalGlyphRasterizerTest {
 public:
     LocalGlyphRasterizerTest(const optional<std::string> fontFamily)
-        : frontend(pixelRatio, fileSource, optional<std::string>(), GLContextMode::Unique, fontFamily)
+        : frontend(pixelRatio, stubFileSourceOptions, optional<std::string>(), GLContextMode::Unique, fontFamily)
     {
     }
 
     util::RunLoop loop;
-    StubFileSource fileSource;
+    FileSourceOptions stubFileSourceOptions;
+    std::shared_ptr<FileSource> fileSource = platform::Factory::sharedFileSource(
+        stubFileSourceOptions, std::make_shared<StubFileSource>());
     float pixelRatio { 1 };
-    HeadlessFrontend frontend;
-    Map map { frontend, MapObserver::nullObserver(), frontend.getSize(), pixelRatio, fileSource,
-              MapOptions().withMapMode(MapMode::Static)};
+    HeadlessFrontend frontend { pixelRatio, stubFileSourceOptions };
+    Map map { frontend, MapObserver::nullObserver(), frontend.getSize(), pixelRatio,
+              MapOptions().withMapMode(MapMode::Static), stubFileSourceOptions };
 
     void checkRendering(const char * name) {
         test::checkImage(std::string("test/fixtures/local_glyphs/") + name,
@@ -57,7 +60,8 @@ public:
 TEST(LocalGlyphRasterizer, PingFang) {
     LocalGlyphRasterizerTest test(std::string("PingFang"));
 
-    test.fileSource.glyphsResponse = [&] (const Resource& resource) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->glyphsResponse = [&] (const Resource& resource) {
         EXPECT_EQ(Resource::Kind::Glyphs, resource.kind);
         Response response;
         response.data = std::make_shared<std::string>(util::read_file("test/fixtures/resources/glyphs.pbf"));
@@ -78,7 +82,8 @@ TEST(LocalGlyphRasterizer, NoLocal) {
     // the output should just contain basic latin characters.
     LocalGlyphRasterizerTest test({});
 
-    test.fileSource.glyphsResponse = [&] (const Resource& resource) {
+    auto stubFileSource = std::static_pointer_cast<StubFileSource>(test.fileSource);
+    stubFileSource->glyphsResponse = [&] (const Resource& resource) {
         EXPECT_EQ(Resource::Kind::Glyphs, resource.kind);
         Response response;
         response.data = std::make_shared<std::string>(util::read_file("test/fixtures/resources/glyphs.pbf"));
diff --git a/test/tile/custom_geometry_tile.test.cpp b/test/tile/custom_geometry_tile.test.cpp
index 834f02879b..4e31ea4dd4 100644
--- a/test/tile/custom_geometry_tile.test.cpp
+++ b/test/tile/custom_geometry_tile.test.cpp
@@ -13,6 +13,7 @@
 #include <mbgl/annotation/annotation_manager.hpp>
 #include <mbgl/renderer/image_manager.hpp>
 #include <mbgl/text/glyph_manager.hpp>
+#include <mbgl/platform/factory.hpp>
 
 #include <memory>
 
@@ -21,19 +22,21 @@ using namespace mbgl::style;
 
 class CustomTileTest {
 public:
-    FakeFileSource fileSource;
+    FileSourceOptions fakeFileSourceOptions;
+    std::shared_ptr<FileSource> fileSource = platform::Factory::sharedFileSource(
+        fakeFileSourceOptions, std::make_shared<FakeFileSource>());
     TransformState transformState;
     util::RunLoop loop;
-    style::Style style { fileSource, 1 };
+    style::Style style { 1.0, fakeFileSourceOptions };
     AnnotationManager annotationManager { style };
     ImageManager imageManager;
-    GlyphManager glyphManager { fileSource };
+    GlyphManager glyphManager { fakeFileSourceOptions };
 
     TileParameters tileParameters {
         1.0,
+        fileSource,
         MapDebugOptions(),
         transformState,
-        fileSource,
         MapMode::Continuous,
         annotationManager,
         imageManager,
diff --git a/test/tile/geojson_tile.test.cpp b/test/tile/geojson_tile.test.cpp
index e68103f4a0..3c78edf6ea 100644
--- a/test/tile/geojson_tile.test.cpp
+++ b/test/tile/geojson_tile.test.cpp
@@ -12,6 +12,7 @@
 #include <mbgl/annotation/annotation_manager.hpp>
 #include <mbgl/renderer/image_manager.hpp>
 #include <mbgl/text/glyph_manager.hpp>
+#include <mbgl/platform/factory.hpp>
 
 #include <memory>
 
@@ -20,20 +21,22 @@ using namespace mbgl::style;
 
 class GeoJSONTileTest {
 public:
-    FakeFileSource fileSource;
+    FileSourceOptions fakeFileSourceOptions;
+    std::shared_ptr<FileSource> fileSource = platform::Factory::sharedFileSource(
+        fakeFileSourceOptions, std::make_shared<FakeFileSource>());
     TransformState transformState;
     util::RunLoop loop;
-    style::Style style { fileSource, 1 };
+    style::Style style { 1.0, fakeFileSourceOptions };
     AnnotationManager annotationManager { style };
     ImageManager imageManager;
-    GlyphManager glyphManager { fileSource };
+    GlyphManager glyphManager { fakeFileSourceOptions };
     Tileset tileset { { "https://example.com" }, { 0, 22 }, "none" };
 
     TileParameters tileParameters {
         1.0,
+        fileSource,
         MapDebugOptions(),
         transformState,
-        fileSource,
         MapMode::Continuous,
         annotationManager,
         imageManager,
diff --git a/test/tile/raster_dem_tile.test.cpp b/test/tile/raster_dem_tile.test.cpp
index e2e7d44b9b..1b0460cb9a 100644
--- a/test/tile/raster_dem_tile.test.cpp
+++ b/test/tile/raster_dem_tile.test.cpp
@@ -11,25 +11,28 @@
 #include <mbgl/renderer/buckets/hillshade_bucket.hpp>
 #include <mbgl/renderer/image_manager.hpp>
 #include <mbgl/text/glyph_manager.hpp>
+#include <mbgl/platform/factory.hpp>
 
 using namespace mbgl;
 
 class RasterDEMTileTest {
 public:
-    FakeFileSource fileSource;
+    FileSourceOptions fakeFileSourceOptions;
+    std::shared_ptr<FileSource> fileSource = platform::Factory::sharedFileSource(
+        fakeFileSourceOptions, std::make_shared<FakeFileSource>());
     TransformState transformState;
     util::RunLoop loop;
-    style::Style style { fileSource, 1 };
+    style::Style style { 1.0, fakeFileSourceOptions };
     AnnotationManager annotationManager { style };
     ImageManager imageManager;
-    GlyphManager glyphManager { fileSource };
+    GlyphManager glyphManager { fakeFileSourceOptions };
     Tileset tileset { { "https://example.com" }, { 0, 22 }, "none" };
 
     TileParameters tileParameters {
         1.0,
+        fileSource,
         MapDebugOptions(),
         transformState,
-        fileSource,
         MapMode::Continuous,
         annotationManager,
         imageManager,
diff --git a/test/tile/raster_tile.test.cpp b/test/tile/raster_tile.test.cpp
index 2e35a94025..1bce370d95 100644
--- a/test/tile/raster_tile.test.cpp
+++ b/test/tile/raster_tile.test.cpp
@@ -11,25 +11,28 @@
 #include <mbgl/renderer/buckets/raster_bucket.hpp>
 #include <mbgl/renderer/image_manager.hpp>
 #include <mbgl/text/glyph_manager.hpp>
+#include <mbgl/platform/factory.hpp>
 
 using namespace mbgl;
 
 class RasterTileTest {
 public:
-    FakeFileSource fileSource;
+    FileSourceOptions fakeFileSourceOptions;
+    std::shared_ptr<FileSource> fileSource = platform::Factory::sharedFileSource(
+        fakeFileSourceOptions, std::make_shared<FakeFileSource>());
     TransformState transformState;
     util::RunLoop loop;
-    style::Style style { fileSource, 1 };
+    style::Style style { 1.0, fakeFileSourceOptions };
     AnnotationManager annotationManager { style };
     ImageManager imageManager;
-    GlyphManager glyphManager { fileSource };
+    GlyphManager glyphManager { fakeFileSourceOptions };
     Tileset tileset { { "https://example.com" }, { 0, 22 }, "none" };
 
     TileParameters tileParameters {
         1.0,
+        fileSource,
         MapDebugOptions(),
         transformState,
-        fileSource,
         MapMode::Continuous,
         annotationManager,
         imageManager,
diff --git a/test/tile/vector_tile.test.cpp b/test/tile/vector_tile.test.cpp
index c610d8c1a7..c32a4c42be 100644
--- a/test/tile/vector_tile.test.cpp
+++ b/test/tile/vector_tile.test.cpp
@@ -15,6 +15,7 @@
 #include <mbgl/annotation/annotation_manager.hpp>
 #include <mbgl/renderer/image_manager.hpp>
 #include <mbgl/text/glyph_manager.hpp>
+#include <mbgl/platform/factory.hpp>
 
 #include <memory>
 
@@ -22,20 +23,22 @@ using namespace mbgl;
 
 class VectorTileTest {
 public:
-    FakeFileSource fileSource;
+    FileSourceOptions fakeFileSourceOptions;
+    std::shared_ptr<FileSource> fileSource = platform::Factory::sharedFileSource(
+        fakeFileSourceOptions, std::make_shared<FakeFileSource>());
     TransformState transformState;
     util::RunLoop loop;
-    style::Style style { fileSource, 1 };
+    style::Style style { 1.0, fakeFileSourceOptions };
     AnnotationManager annotationManager { style };
     ImageManager imageManager;
-    GlyphManager glyphManager { fileSource };
+    GlyphManager glyphManager { fakeFileSourceOptions };
     Tileset tileset { { "https://example.com" }, { 0, 22 }, "none" };
 
     TileParameters tileParameters {
         1.0,
+        fileSource,
         MapDebugOptions(),
         transformState,
-        fileSource,
         MapMode::Continuous,
         annotationManager,
         imageManager,
diff --git a/test/util/memory.test.cpp b/test/util/memory.test.cpp
index b64e05124f..7a309770e6 100644
--- a/test/util/memory.test.cpp
+++ b/test/util/memory.test.cpp
@@ -4,6 +4,7 @@
 
 #include <mbgl/map/map.hpp>
 #include <mbgl/map/map_options.hpp>
+#include <mbgl/platform/factory.hpp>
 #include <mbgl/gl/headless_frontend.hpp>
 #include <mbgl/util/io.hpp>
 #include <mbgl/util/run_loop.hpp>
@@ -25,16 +26,19 @@ using namespace std::literals::string_literals;
 class MemoryTest {
 public:
     MemoryTest() {
-        fileSource.styleResponse = [&](const Resource& res) { return response("style_" + getType(res) + ".json");};
-        fileSource.tileResponse = [&](const Resource& res) { return response(getType(res) + ".tile"); };
-        fileSource.sourceResponse = [&](const Resource& res) { return response("source_" + getType(res) + ".json"); };
-        fileSource.glyphsResponse = [&](const Resource&) { return response("glyphs.pbf"); };
-        fileSource.spriteJSONResponse = [&](const Resource&) { return response("sprite.json"); };
-        fileSource.spriteImageResponse = [&](const Resource&) { return response("sprite.png"); };
+        auto stubFileSource = std::static_pointer_cast<StubFileSource>(fileSource);
+        stubFileSource->styleResponse = [&](const Resource& res) { return response("style_" + getType(res) + ".json");};
+        stubFileSource->tileResponse = [&](const Resource& res) { return response(getType(res) + ".tile"); };
+        stubFileSource->sourceResponse = [&](const Resource& res) { return response("source_" + getType(res) + ".json"); };
+        stubFileSource->glyphsResponse = [&](const Resource&) { return response("glyphs.pbf"); };
+        stubFileSource->spriteJSONResponse = [&](const Resource&) { return response("sprite.json"); };
+        stubFileSource->spriteImageResponse = [&](const Resource&) { return response("sprite.png"); };
     }
 
     util::RunLoop runLoop;
-    StubFileSource fileSource;
+    FileSourceOptions stubFileSourceOptions;
+    std::shared_ptr<FileSource> fileSource = platform::Factory::sharedFileSource(
+        stubFileSourceOptions, std::make_shared<StubFileSource>());
 
 private:
     Response response(const std::string& path) {
@@ -69,9 +73,9 @@ TEST(Memory, Vector) {
     MemoryTest test;
     float ratio { 2 };
 
-    HeadlessFrontend frontend { { 256, 256 }, ratio, test.fileSource };
-    Map map(frontend, MapObserver::nullObserver(), frontend.getSize(), ratio, test.fileSource,
-            MapOptions().withMapMode(MapMode::Static));
+    HeadlessFrontend frontend { { 256, 256 }, ratio, test.stubFileSourceOptions };
+    Map map(frontend, MapObserver::nullObserver(), frontend.getSize(), ratio,
+            MapOptions().withMapMode(MapMode::Static), test.stubFileSourceOptions);
     map.jumpTo(CameraOptions().withZoom(16));
     map.getStyle().loadURL("mapbox://streets");
 
@@ -82,9 +86,9 @@ TEST(Memory, Raster) {
     MemoryTest test;
     float ratio { 2 };
 
-    HeadlessFrontend frontend { { 256, 256 }, ratio, test.fileSource };
-    Map map(frontend, MapObserver::nullObserver(), frontend.getSize(), ratio, test.fileSource,
-            MapOptions().withMapMode(MapMode::Static));
+    HeadlessFrontend frontend { { 256, 256 }, ratio, test.stubFileSourceOptions };
+    Map map(frontend, MapObserver::nullObserver(), frontend.getSize(), ratio,
+            MapOptions().withMapMode(MapMode::Static), test.stubFileSourceOptions);
     map.getStyle().loadURL("mapbox://satellite");
 
     frontend.render(map);
@@ -119,10 +123,10 @@ TEST(Memory, Footprint) {
 
     class FrontendAndMap {
     public:
-        FrontendAndMap(MemoryTest& test_, const char* style)
-            : frontend(Size{ 256, 256 }, 2, test_.fileSource)
-            , map(frontend, MapObserver::nullObserver(), frontend.getSize(), 2, test_.fileSource,
-                  MapOptions().withMapMode(MapMode::Static)) {
+        FrontendAndMap(const FileSourceOptions& fileSourceOptions, const char* style)
+            : frontend(Size{ 256, 256 }, 2, fileSourceOptions)
+            , map(frontend, MapObserver::nullObserver(), frontend.getSize(), 2,
+                  MapOptions().withMapMode(MapMode::Static), fileSourceOptions) {
             map.jumpTo(CameraOptions().withZoom(16));
             map.getStyle().loadURL(style);
             frontend.render(map);
@@ -134,8 +138,8 @@ TEST(Memory, Footprint) {
 
     // Warm up buffers and cache.
     for (unsigned i = 0; i < 10; ++i) {
-        FrontendAndMap(test, "mapbox://streets");
-        FrontendAndMap(test, "mapbox://satellite");
+        FrontendAndMap(test.stubFileSourceOptions, "mapbox://streets");
+        FrontendAndMap(test.stubFileSourceOptions, "mapbox://satellite");
     }
 
     // Process close callbacks, mostly needed by
@@ -147,14 +151,14 @@ TEST(Memory, Footprint) {
 
     long vectorInitialRSS = mbgl::test::getCurrentRSS();
     for (unsigned i = 0; i < runs; ++i) {
-        maps.emplace_back(std::make_unique<FrontendAndMap>(test, "mapbox://streets"));
+        maps.emplace_back(std::make_unique<FrontendAndMap>(test.stubFileSourceOptions, "mapbox://streets"));
     }
 
     double vectorFootprint = (mbgl::test::getCurrentRSS() - vectorInitialRSS) / double(runs);
 
     long rasterInitialRSS = mbgl::test::getCurrentRSS();
     for (unsigned i = 0; i < runs; ++i) {
-        maps.emplace_back(std::make_unique<FrontendAndMap>(test, "mapbox://satellite"));
+        maps.emplace_back(std::make_unique<FrontendAndMap>(test.stubFileSourceOptions, "mapbox://satellite"));
     }
 
     double rasterFootprint = (mbgl::test::getCurrentRSS() - rasterInitialRSS) / double(runs);