Bump Mapbox GL Native

mapbox-gl-native @ 10f7af19ce1ec61f37459f9cd75e2a0c89a0c790

16 files changed, 357 insertions, 67 deletions

diff --git a/platform/default/default_file_source.cpp b/platform/default/default_file_source.cpp
index 9c8a38a308..608b782ab9 100644
--- a/platform/default/default_file_source.cpp
+++ b/platform/default/default_file_source.cpp
@@ -28,10 +28,15 @@ namespace mbgl {
 
 class DefaultFileSource::Impl {
 public:
-    Impl(ActorRef<Impl>, std::shared_ptr<FileSource> assetFileSource_, const std::string& cachePath, uint64_t maximumCacheSize)
+    Impl(ActorRef<Impl> self, std::shared_ptr<FileSource> assetFileSource_, const std::string& cachePath, uint64_t maximumCacheSize)
             : assetFileSource(assetFileSource_)
-            , localFileSource(std::make_unique<LocalFileSource>())
-            , offlineDatabase(cachePath, maximumCacheSize) {
+            , localFileSource(std::make_unique<LocalFileSource>()) {
+        // Initialize the Database asynchronously so as to not block Actor creation.
+        self.invoke(&Impl::initializeOfflineDatabase, cachePath, maximumCacheSize);
+    }
+
+    void initializeOfflineDatabase(std::string cachePath, uint64_t maximumCacheSize) {
+        offlineDatabase = std::make_unique<OfflineDatabase>(cachePath, maximumCacheSize);
     }
 
     void setAPIBaseURL(const std::string& url) {
@@ -56,7 +61,7 @@ public:
 
     void listRegions(std::function<void (std::exception_ptr, optional<std::vector<OfflineRegion>>)> callback) {
         try {
-            callback({}, offlineDatabase.listRegions());
+            callback({}, offlineDatabase->listRegions());
         } catch (...) {
             callback(std::current_exception(), {});
         }
@@ -66,7 +71,7 @@ public:
                       const OfflineRegionMetadata& metadata,
                       std::function<void (std::exception_ptr, optional<OfflineRegion>)> callback) {
         try {
-            callback({}, offlineDatabase.createRegion(definition, metadata));
+            callback({}, offlineDatabase->createRegion(definition, metadata));
         } catch (...) {
             callback(std::current_exception(), {});
         }
@@ -76,7 +81,7 @@ public:
                       const OfflineRegionMetadata& metadata,
                       std::function<void (std::exception_ptr, optional<OfflineRegionMetadata>)> callback) {
         try {
-            callback({}, offlineDatabase.updateMetadata(regionID, metadata));
+            callback({}, offlineDatabase->updateMetadata(regionID, metadata));
         } catch (...) {
             callback(std::current_exception(), {});
         }
@@ -93,7 +98,7 @@ public:
     void deleteRegion(OfflineRegion&& region, std::function<void (std::exception_ptr)> callback) {
         try {
             downloads.erase(region.getID());
-            offlineDatabase.deleteRegion(std::move(region));
+            offlineDatabase->deleteRegion(std::move(region));
             callback({});
         } catch (...) {
             callback(std::current_exception());
@@ -121,43 +126,43 @@ public:
             tasks[req] = localFileSource->request(resource, callback);
         } else {
             // Try the offline database
-            Resource revalidation = resource;
-
-            const bool hasPrior = resource.priorEtag || resource.priorModified || resource.priorExpires;
-            if (!hasPrior || resource.necessity == Resource::Optional) {
-                auto offlineResponse = offlineDatabase.get(resource);
-
-                if (resource.necessity == Resource::Optional && !offlineResponse) {
-                    // Ensure there's always a response that we can send, so the caller knows that
-                    // there's no optional data available in the cache.
-                    offlineResponse.emplace();
-                    offlineResponse->noContent = true;
-                    offlineResponse->error = std::make_unique<Response::Error>(
-                            Response::Error::Reason::NotFound, "Not found in offline database");
-                }
-
-                if (offlineResponse) {
-                    revalidation.priorModified = offlineResponse->modified;
-                    revalidation.priorExpires = offlineResponse->expires;
-                    revalidation.priorEtag = offlineResponse->etag;
+            if (resource.hasLoadingMethod(Resource::LoadingMethod::Cache)) {
+                auto offlineResponse = offlineDatabase->get(resource);
+
+                if (resource.loadingMethod == Resource::LoadingMethod::CacheOnly) {
+                    if (!offlineResponse) {
+                        // Ensure there's always a response that we can send, so the caller knows that
+                        // there's no optional data available in the cache, when it's the only place
+                        // we're supposed to load from.
+                        offlineResponse.emplace();
+                        offlineResponse->noContent = true;
+                        offlineResponse->error = std::make_unique<Response::Error>(
+                                Response::Error::Reason::NotFound, "Not found in offline database");
+                    } else if (!offlineResponse->isUsable()) {
+                        // Don't return resources the server requested not to show when they're stale.
+                        // Even if we can't directly use the response, we may still use it to send a
+                        // conditional HTTP request, which is why we're saving it above.
+                        offlineResponse->error = std::make_unique<Response::Error>(
+                            Response::Error::Reason::NotFound, "Cached resource is unusable");
+                    }
+                    callback(*offlineResponse);
+                } else if (offlineResponse) {
+                    // Copy over the fields so that we can use them when making a refresh request.
+                    resource.priorModified = offlineResponse->modified;
+                    resource.priorExpires = offlineResponse->expires;
+                    resource.priorEtag = offlineResponse->etag;
+                    resource.priorData = offlineResponse->data;
 
-                    // Don't return resources the server requested not to show when they're stale.
-                    // Even if we can't directly use the response, we may still use it to send a
-                    // conditional HTTP request.
                     if (offlineResponse->isUsable()) {
                         callback(*offlineResponse);
-                    } else {
-                        // Since we can't return the data immediately, we'll have to hold on so that
-                        // we can return it later in case we get a 304 Not Modified response.
-                        revalidation.priorData = offlineResponse->data;
                     }
                 }
             }
 
             // Get from the online file source
-            if (resource.necessity == Resource::Required) {
-                tasks[req] = onlineFileSource.request(revalidation, [=] (Response onlineResponse) mutable {
-                    this->offlineDatabase.put(revalidation, onlineResponse);
+            if (resource.hasLoadingMethod(Resource::LoadingMethod::Network)) {
+                tasks[req] = onlineFileSource.request(resource, [=] (Response onlineResponse) mutable {
+                    this->offlineDatabase->put(resource, onlineResponse);
                     callback(onlineResponse);
                 });
             }
@@ -169,11 +174,15 @@ public:
     }
 
     void setOfflineMapboxTileCountLimit(uint64_t limit) {
-        offlineDatabase.setOfflineMapboxTileCountLimit(limit);
+        offlineDatabase->setOfflineMapboxTileCountLimit(limit);
+    }
+
+    void setOnlineStatus(const bool status) {
+        onlineFileSource.setOnlineStatus(status);
     }
 
     void put(const Resource& resource, const Response& response) {
-        offlineDatabase.put(resource, response);
+        offlineDatabase->put(resource, response);
     }
 
 private:
@@ -183,13 +192,13 @@ private:
             return *it->second;
         }
         return *downloads.emplace(regionID,
-            std::make_unique<OfflineDownload>(regionID, offlineDatabase.getRegionDefinition(regionID), offlineDatabase, onlineFileSource)).first->second;
+            std::make_unique<OfflineDownload>(regionID, offlineDatabase->getRegionDefinition(regionID), *offlineDatabase, onlineFileSource)).first->second;
     }
 
     // shared so that destruction is done on the creating thread
     const std::shared_ptr<FileSource> assetFileSource;
     const std::unique_ptr<FileSource> localFileSource;
-    OfflineDatabase offlineDatabase;
+    std::unique_ptr<OfflineDatabase> offlineDatabase;
     OnlineFileSource onlineFileSource;
     std::unordered_map<AsyncRequest*, std::unique_ptr<AsyncRequest>> tasks;
     std::unordered_map<int64_t, std::unique_ptr<OfflineDownload>> downloads;
@@ -298,6 +307,10 @@ void DefaultFileSource::resume() {
 
 // For testing only:
 
+void DefaultFileSource::setOnlineStatus(const bool status) {
+    impl->actor().invoke(&Impl::setOnlineStatus, status);
+}
+
 void DefaultFileSource::put(const Resource& resource, const Response& response) {
     impl->actor().invoke(&Impl::put, resource, response);
 }
diff --git a/platform/default/file_source_request.cpp b/platform/default/file_source_request.cpp
new file mode 100644
index 0000000000..09ea8cc32a
--- /dev/null
+++ b/platform/default/file_source_request.cpp
@@ -0,0 +1,37 @@
+#include <mbgl/storage/file_source_request.hpp>
+
+#include <mbgl/actor/mailbox.hpp>
+#include <mbgl/actor/scheduler.hpp>
+
+namespace mbgl {
+
+FileSourceRequest::FileSourceRequest(FileSource::Callback&& callback)
+    : responseCallback(callback)
+    , mailbox(std::make_shared<Mailbox>(*Scheduler::GetCurrent())) {
+}
+
+FileSourceRequest::~FileSourceRequest() {
+    if (cancelCallback) {
+        cancelCallback();
+    }
+
+    mailbox->close();
+}
+
+void FileSourceRequest::onCancel(std::function<void()>&& callback) {
+    cancelCallback = std::move(callback);
+}
+
+void FileSourceRequest::setResponse(const Response& response) {
+    // Copy, because calling the callback will sometimes self
+    // destroy this object. We cannot move because this method
+    // can be called more than one.
+    auto callback = responseCallback;
+    callback(response);
+}
+
+ActorRef<FileSourceRequest> FileSourceRequest::actor() {
+    return ActorRef<FileSourceRequest>(*this, mailbox);
+}
+
+} // namespace mbgl
diff --git a/platform/default/mbgl/gl/headless_backend.cpp b/platform/default/mbgl/gl/headless_backend.cpp
index fe77b80985..edf637a560 100644
--- a/platform/default/mbgl/gl/headless_backend.cpp
+++ b/platform/default/mbgl/gl/headless_backend.cpp
@@ -64,6 +64,10 @@ void HeadlessBackend::bind() {
     context_.viewport = { 0, 0, size };
 }
 
+Size HeadlessBackend::getFramebufferSize() const {
+    return size;
+}
+
 void HeadlessBackend::updateAssumedState() {
     // no-op
 }
diff --git a/platform/default/mbgl/gl/headless_backend.hpp b/platform/default/mbgl/gl/headless_backend.hpp
index 8d86ea8c47..66f861e213 100644
--- a/platform/default/mbgl/gl/headless_backend.hpp
+++ b/platform/default/mbgl/gl/headless_backend.hpp
@@ -15,6 +15,7 @@ public:
     ~HeadlessBackend() override;
 
     void bind() override;
+    Size getFramebufferSize() const override;
     void updateAssumedState() override;
 
     void setSize(Size);
diff --git a/platform/default/mbgl/gl/headless_frontend.cpp b/platform/default/mbgl/gl/headless_frontend.cpp
index ad03706be7..5d2932258a 100644
--- a/platform/default/mbgl/gl/headless_frontend.cpp
+++ b/platform/default/mbgl/gl/headless_frontend.cpp
@@ -5,11 +5,11 @@
 
 namespace mbgl {
 
-HeadlessFrontend::HeadlessFrontend(float pixelRatio_, FileSource& fileSource, Scheduler& scheduler)
-    : HeadlessFrontend({ 256, 256 }, pixelRatio_, fileSource, scheduler) {
+HeadlessFrontend::HeadlessFrontend(float pixelRatio_, FileSource& fileSource, Scheduler& scheduler, const optional<std::string> programCacheDir)
+    : HeadlessFrontend({ 256, 256 }, pixelRatio_, fileSource, scheduler, programCacheDir) {
 }
 
-HeadlessFrontend::HeadlessFrontend(Size size_, float pixelRatio_, FileSource& fileSource, Scheduler& scheduler)
+HeadlessFrontend::HeadlessFrontend(Size size_, float pixelRatio_, FileSource& fileSource, Scheduler& scheduler, const optional<std::string> programCacheDir)
     : size(size_),
     pixelRatio(pixelRatio_),
     backend({ static_cast<uint32_t>(size.width * pixelRatio),
@@ -20,7 +20,7 @@ HeadlessFrontend::HeadlessFrontend(Size size_, float pixelRatio_, FileSource& fi
             renderer->render(*updateParameters);
         }
     }),
-    renderer(std::make_unique<Renderer>(backend, pixelRatio, fileSource, scheduler)) {
+    renderer(std::make_unique<Renderer>(backend, pixelRatio, fileSource, scheduler, GLContextMode::Unique, programCacheDir)) {
 }
 
 HeadlessFrontend::~HeadlessFrontend() = default;
diff --git a/platform/default/mbgl/gl/headless_frontend.hpp b/platform/default/mbgl/gl/headless_frontend.hpp
index 18d0d2527b..33503bc13b 100644
--- a/platform/default/mbgl/gl/headless_frontend.hpp
+++ b/platform/default/mbgl/gl/headless_frontend.hpp
@@ -3,6 +3,7 @@
 #include <mbgl/renderer/renderer_frontend.hpp>
 #include <mbgl/gl/headless_backend.hpp>
 #include <mbgl/util/async_task.hpp>
+#include <mbgl/util/optional.hpp>
 
 #include <memory>
 
@@ -16,8 +17,8 @@ class Map;
 
 class HeadlessFrontend : public RendererFrontend {
 public:
-    HeadlessFrontend(float pixelRatio_, FileSource&, Scheduler&);
-    HeadlessFrontend(Size, float pixelRatio_, FileSource&, Scheduler&);
+    HeadlessFrontend(float pixelRatio_, FileSource&, Scheduler&, const optional<std::string> programCacheDir = {});
+    HeadlessFrontend(Size, float pixelRatio_, FileSource&, Scheduler&, const optional<std::string> programCacheDir = {});
     ~HeadlessFrontend() override;
 
     void reset() override;
diff --git a/platform/default/mbgl/map/map_snapshotter.cpp b/platform/default/mbgl/map/map_snapshotter.cpp
new file mode 100644
index 0000000000..95c46344fe
--- /dev/null
+++ b/platform/default/mbgl/map/map_snapshotter.cpp
@@ -0,0 +1,76 @@
+#include <mbgl/map/map_snapshotter.hpp>
+
+#include <mbgl/actor/actor_ref.hpp>
+#include <mbgl/gl/headless_frontend.hpp>
+#include <mbgl/map/map.hpp>
+#include <mbgl/storage/file_source.hpp>
+#include <mbgl/style/style.hpp>
+#include <mbgl/util/event.hpp>
+
+namespace mbgl {
+
+class MapSnapshotter::Impl {
+public:
+    Impl(FileSource&,
+         Scheduler&,
+         const std::string& styleURL,
+         const Size&,
+         const float pixelRatio,
+         const CameraOptions&,
+         const optional<LatLngBounds> region,
+         const optional<std::string> programCacheDir);
+
+    void snapshot(ActorRef<MapSnapshotter::Callback>);
+
+private:
+    HeadlessFrontend frontend;
+    Map map;
+};
+
+MapSnapshotter::Impl::Impl(FileSource& fileSource,
+           Scheduler& scheduler,
+           const std::string& styleURL,
+           const Size& size,
+           const float pixelRatio,
+           const CameraOptions& cameraOptions,
+           const optional<LatLngBounds> region,
+           const optional<std::string> programCacheDir)
+    : frontend(size, pixelRatio, fileSource, scheduler, programCacheDir)
+    , map(frontend, MapObserver::nullObserver(), size, pixelRatio, fileSource, scheduler, MapMode::Still) {
+
+    map.getStyle().loadURL(styleURL);
+
+    map.jumpTo(cameraOptions);
+
+    // Set region, if specified
+    if (region) {
+        mbgl::EdgeInsets insets = { 0, 0, 0, 0 };
+        std::vector<LatLng> latLngs = { region->southwest(), region->northeast() };
+        map.jumpTo(map.cameraForLatLngs(latLngs, insets));
+    }
+}
+
+void MapSnapshotter::Impl::snapshot(ActorRef<MapSnapshotter::Callback> callback) {
+    map.renderStill([this, callback = std::move(callback)] (std::exception_ptr error) mutable {
+        callback.invoke(&MapSnapshotter::Callback::operator(), error, error ? PremultipliedImage() : frontend.readStillImage());
+    });
+}
+
+MapSnapshotter::MapSnapshotter(FileSource& fileSource,
+                               Scheduler& scheduler,
+                               const std::string& styleURL,
+                               const Size& size,
+                               const float pixelRatio,
+                               const CameraOptions& cameraOptions,
+                               const optional<LatLngBounds> region,
+                               const optional<std::string> programCacheDir)
+   : impl(std::make_unique<util::Thread<MapSnapshotter::Impl>>("Map Snapshotter", fileSource, scheduler, styleURL, size, pixelRatio, cameraOptions, region, programCacheDir)) {
+}
+
+MapSnapshotter::~MapSnapshotter() = default;
+
+void MapSnapshotter::snapshot(ActorRef<MapSnapshotter::Callback> callback) {
+   impl->actor().invoke(&Impl::snapshot, std::move(callback));
+}
+
+} // namespace mbgl
diff --git a/platform/default/mbgl/map/map_snapshotter.hpp b/platform/default/mbgl/map/map_snapshotter.hpp
new file mode 100644
index 0000000000..0afa848fd8
--- /dev/null
+++ b/platform/default/mbgl/map/map_snapshotter.hpp
@@ -0,0 +1,40 @@
+#pragma once
+
+#include <mbgl/util/image.hpp>
+#include <mbgl/util/thread.hpp>
+#include <mbgl/util/optional.hpp>
+
+#include <exception>
+#include <string>
+#include <functional>
+
+namespace mbgl {
+
+template<class> class ActorRef;
+struct CameraOptions;
+class FileSource;
+class Size;
+class LatLngBounds;
+
+class MapSnapshotter {
+public:
+    MapSnapshotter(FileSource& fileSource,
+                   Scheduler& scheduler,
+                   const std::string& styleURL,
+                   const Size&,
+                   const float pixelRatio,
+                   const CameraOptions&,
+                   const optional<LatLngBounds> region,
+                   const optional<std::string> cacheDir = {});
+
+    ~MapSnapshotter();
+
+    using Callback = std::function<void (std::exception_ptr, PremultipliedImage)>;
+    void snapshot(ActorRef<Callback>);
+
+private:
+    class Impl;
+    std::unique_ptr<util::Thread<Impl>> impl;
+};
+
+} // namespace mbgl
diff --git a/platform/default/mbgl/storage/file_source_request.hpp b/platform/default/mbgl/storage/file_source_request.hpp
new file mode 100644
index 0000000000..6bd0d44df6
--- /dev/null
+++ b/platform/default/mbgl/storage/file_source_request.hpp
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <mbgl/actor/actor_ref.hpp>
+#include <mbgl/storage/file_source.hpp>
+#include <mbgl/util/async_request.hpp>
+
+#include <memory>
+#include <functional>
+
+namespace mbgl {
+
+class Mailbox;
+
+class FileSourceRequest : public AsyncRequest {
+public:
+    FileSourceRequest(FileSource::Callback&& callback);
+    ~FileSourceRequest() final;
+
+    void onCancel(std::function<void()>&& callback);
+    void setResponse(const Response& res);
+
+    ActorRef<FileSourceRequest> actor();
+
+private:
+    FileSource::Callback responseCallback = nullptr;
+    std::function<void()> cancelCallback = nullptr;
+
+    std::shared_ptr<Mailbox> mailbox;
+};
+
+} // namespace mbgl
diff --git a/platform/default/mbgl/storage/offline.cpp b/platform/default/mbgl/storage/offline.cpp
index fd2d47819b..7670790be9 100644
--- a/platform/default/mbgl/storage/offline.cpp
+++ b/platform/default/mbgl/storage/offline.cpp
@@ -1,6 +1,7 @@
 #include <mbgl/storage/offline.hpp>
 #include <mbgl/util/tile_cover.hpp>
 #include <mbgl/util/tileset.hpp>
+#include <mbgl/util/projection.hpp>
 
 #include <rapidjson/document.h>
 #include <rapidjson/stringbuffer.h>
@@ -23,18 +24,12 @@ OfflineTilePyramidRegionDefinition::OfflineTilePyramidRegionDefinition(
     }
 }
 
-std::vector<CanonicalTileID> OfflineTilePyramidRegionDefinition::tileCover(SourceType type, uint16_t tileSize, const Range<uint8_t>& zoomRange) const {
-    double minZ = std::max<double>(util::coveringZoomLevel(minZoom, type, tileSize), zoomRange.min);
-    double maxZ = std::min<double>(util::coveringZoomLevel(maxZoom, type, tileSize), zoomRange.max);
-
-    assert(minZ >= 0);
-    assert(maxZ >= 0);
-    assert(minZ < std::numeric_limits<uint8_t>::max());
-    assert(maxZ < std::numeric_limits<uint8_t>::max());
+std::vector<CanonicalTileID> OfflineTilePyramidRegionDefinition::tileCover(style::SourceType type, uint16_t tileSize, const Range<uint8_t>& zoomRange) const {
+    const Range<uint8_t> clampedZoomRange = coveringZoomRange(type, tileSize, zoomRange);
 
     std::vector<CanonicalTileID> result;
 
-    for (uint8_t z = minZ; z <= maxZ; z++) {
+    for (uint8_t z = clampedZoomRange.min; z <= clampedZoomRange.max; z++) {
         for (const auto& tile : util::tileCover(bounds, z)) {
             result.emplace_back(tile.canonical);
         }
@@ -43,6 +38,28 @@ std::vector<CanonicalTileID> OfflineTilePyramidRegionDefinition::tileCover(Sourc
     return result;
 }
 
+uint64_t OfflineTilePyramidRegionDefinition::tileCount(style::SourceType type, uint16_t tileSize, const Range<uint8_t>& zoomRange) const {
+    
+    const Range<uint8_t> clampedZoomRange = coveringZoomRange(type, tileSize, zoomRange);
+    unsigned long result = 0;;
+    for (uint8_t z = clampedZoomRange.min; z <= clampedZoomRange.max; z++) {
+        result +=  util::tileCount(bounds, z, tileSize);
+    }
+
+    return result;
+}
+
+Range<uint8_t> OfflineTilePyramidRegionDefinition::coveringZoomRange(style::SourceType type, uint16_t tileSize, const Range<uint8_t>& zoomRange) const {
+    double minZ = std::max<double>(util::coveringZoomLevel(minZoom, type, tileSize), zoomRange.min);
+    double maxZ = std::min<double>(util::coveringZoomLevel(maxZoom, type, tileSize), zoomRange.max);
+
+    assert(minZ >= 0);
+    assert(maxZ >= 0);
+    assert(minZ < std::numeric_limits<uint8_t>::max());
+    assert(maxZ < std::numeric_limits<uint8_t>::max());
+    return { static_cast<uint8_t>(minZ), static_cast<uint8_t>(maxZ) };
+}
+
 OfflineRegionDefinition decodeOfflineRegionDefinition(const std::string& region) {
     rapidjson::GenericDocument<rapidjson::UTF8<>, rapidjson::CrtAllocator> doc;
     doc.Parse<0>(region.c_str());
diff --git a/platform/default/mbgl/storage/offline_download.cpp b/platform/default/mbgl/storage/offline_download.cpp
index 7f0001f64b..ff61114888 100644
--- a/platform/default/mbgl/storage/offline_download.cpp
+++ b/platform/default/mbgl/storage/offline_download.cpp
@@ -80,7 +80,7 @@ OfflineRegionStatus OfflineDownload::getStatus() const {
         auto handleTiledSource = [&] (const variant<std::string, Tileset>& urlOrTileset, const uint16_t tileSize) {
             if (urlOrTileset.is<Tileset>()) {
                 result.requiredResourceCount +=
-                    definition.tileCover(type, tileSize, urlOrTileset.get<Tileset>().zoomRange).size();
+                    definition.tileCount(type, tileSize, urlOrTileset.get<Tileset>().zoomRange);
             } else {
                 result.requiredResourceCount += 1;
                 const auto& url = urlOrTileset.get<std::string>();
@@ -90,7 +90,7 @@ OfflineRegionStatus OfflineDownload::getStatus() const {
                     optional<Tileset> tileset = style::conversion::convertJSON<Tileset>(*sourceResponse->data, error);
                     if (tileset) {
                         result.requiredResourceCount +=
-                            definition.tileCover(type, tileSize, (*tileset).zoomRange).size();
+                            definition.tileCount(type, tileSize, (*tileset).zoomRange);
                     }
                 } else {
                     result.requiredResourceCountIsPrecise = false;
diff --git a/platform/default/mbgl/storage/offline_download.hpp b/platform/default/mbgl/storage/offline_download.hpp
index c978ded931..437f221c11 100644
--- a/platform/default/mbgl/storage/offline_download.hpp
+++ b/platform/default/mbgl/storage/offline_download.hpp
@@ -60,7 +60,7 @@ private:
     std::deque<Resource> resourcesRemaining;
 
     void queueResource(Resource);
-    void queueTiles(SourceType, uint16_t tileSize, const Tileset&);
+    void queueTiles(style::SourceType, uint16_t tileSize, const Tileset&);
 };
 
 } // namespace mbgl
diff --git a/platform/default/online_file_source.cpp b/platform/default/online_file_source.cpp
index 1c594f87a0..d685109b95 100644
--- a/platform/default/online_file_source.cpp
+++ b/platform/default/online_file_source.cpp
@@ -117,13 +117,24 @@ public:
     }
 
     void activateRequest(OnlineFileRequest* request) {
-        activeRequests.insert(request);
-        request->request = httpFileSource.request(request->resource, [=] (Response response) {
+        auto callback = [=](Response response) {
             activeRequests.erase(request);
-            activatePendingRequest();
             request->request.reset();
             request->completed(response);
-        });
+            activatePendingRequest();
+        };
+
+        activeRequests.insert(request);
+
+        if (online) {
+            request->request = httpFileSource.request(request->resource, callback);
+        } else {
+            Response response;
+            response.error = std::make_unique<Response::Error>(Response::Error::Reason::Connection,
+                                                               "Online connectivity is disabled.");
+            callback(response);
+        }
+
         assert(pendingRequestsMap.size() == pendingRequestsList.size());
     }
 
@@ -153,6 +164,11 @@ public:
         resourceTransform = std::move(transform);
     }
 
+    void setOnlineStatus(const bool status) {
+        online = status;
+        networkIsReachableAgain();
+    }
+
 private:
     void networkIsReachableAgain() {
         for (auto& request : allRequests) {
@@ -178,6 +194,7 @@ private:
     std::unordered_map<OnlineFileRequest*, std::list<OnlineFileRequest*>::iterator> pendingRequestsMap;
     std::unordered_set<OnlineFileRequest*> activeRequests;
 
+    bool online = true;
     HTTPFileSource httpFileSource;
     util::AsyncTask reachability { std::bind(&Impl::networkIsReachableAgain, this) };
 };
@@ -389,4 +406,10 @@ ActorRef<OnlineFileRequest> OnlineFileRequest::actor() {
     return ActorRef<OnlineFileRequest>(*this, mailbox);
 }
 
+// For testing only:
+
+void OnlineFileSource::setOnlineStatus(const bool status) {
+    impl->setOnlineStatus(status);
+}
+
 } // namespace mbgl
diff --git a/platform/qt/include/qmapboxgl.hpp b/platform/qt/include/qmapboxgl.hpp
index e2fb283989..ebbd949921 100644
--- a/platform/qt/include/qmapboxgl.hpp
+++ b/platform/qt/include/qmapboxgl.hpp
@@ -10,6 +10,8 @@
 #include <QString>
 #include <QStringList>
 
+#include <functional>
+
 class QMapboxGLPrivate;
 
 // This header follows the Qt coding style: https://wiki.qt.io/Qt_Coding_Style
@@ -59,6 +61,9 @@ public:
     QString apiBaseUrl() const;
     void setApiBaseUrl(const QString &);
 
+    std::function<std::string(const std::string &&)> resourceTransform() const;
+    void setResourceTransform(const std::function<std::string(const std::string &&)> &);
+
 private:
     GLContextMode m_contextMode;
     ConstrainMode m_constrainMode;
@@ -69,6 +74,7 @@ private:
     QString m_assetPath;
     QString m_accessToken;
     QString m_apiBaseUrl;
+    std::function<std::string(const std::string &&)> m_resourceTransform;
 };
 
 struct Q_DECL_EXPORT QMapboxGLCameraOptions {
diff --git a/platform/qt/src/qmapboxgl.cpp b/platform/qt/src/qmapboxgl.cpp
index c7c4cf1e4a..074ef280aa 100644
--- a/platform/qt/src/qmapboxgl.cpp
+++ b/platform/qt/src/qmapboxgl.cpp
@@ -29,6 +29,7 @@
 #include <mbgl/util/run_loop.hpp>
 #include <mbgl/util/shared_thread_pool.hpp>
 #include <mbgl/util/traits.hpp>
+#include <mbgl/actor/scheduler.hpp>
 
 #if QT_VERSION >= 0x050000
 #include <QGuiApplication>
@@ -362,6 +363,27 @@ void QMapboxGLSettings::setApiBaseUrl(const QString& url)
 }
 
 /*!
+    Returns resource transformation callback used to transform requested URLs.
+*/
+std::function<std::string(const std::string &&)> QMapboxGLSettings::resourceTransform() const
+{
+    return m_resourceTransform;
+}
+
+/*!
+    Sets the resource transformation callback.
+
+    When given, resource transformation callback will be used to transform the
+    requested resource URLs before they are requested from internet. This can be
+    used add or remove custom parameters, or reroute certain requests to other
+    servers or endpoints.
+*/
+void QMapboxGLSettings::setResourceTransform(const std::function<std::string(const std::string &&)> &transform)
+{
+    m_resourceTransform = transform;
+}
+
+/*!
     \class QMapboxGL
     \brief The QMapboxGL class is a Qt wrapper for the Mapbox GL Native engine.
 
@@ -1499,13 +1521,25 @@ QMapboxGLPrivate::QMapboxGLPrivate(QMapboxGL *q, const QMapboxGLSettings &settin
         settings.cacheDatabaseMaximumSize()))
     , threadPool(mbgl::sharedThreadPool())
 {
+    // Setup resource transform if needed
+    if (settings.resourceTransform()) {
+      m_resourceTransform =
+        std::make_unique< mbgl::Actor<mbgl::ResourceTransform> >( *mbgl::Scheduler::GetCurrent(),
+                                                                  [callback = settings.resourceTransform()]
+                                                                  (mbgl::Resource::Kind , const std::string&& url_)  -> std::string {
+                                                                    return callback(std::move(url_));
+                                                                  }
+                                                                  );
+      fileSourceObj->setResourceTransform(m_resourceTransform->self());
+    }
+
     // Setup and connect the renderer frontend
     frontend = std::make_unique<QMapboxGLRendererFrontend>(
             std::make_unique<mbgl::Renderer>(*this, pixelRatio, *fileSourceObj, *threadPool,
                                              static_cast<mbgl::GLContextMode>(settings.contextMode())),
             *this);
     connect(frontend.get(), SIGNAL(updated()), this, SLOT(invalidate()));
-    
+
     mapObj = std::make_unique<mbgl::Map>(
             *frontend,
             *this, sanitizedSize(size),
@@ -1528,18 +1562,18 @@ QMapboxGLPrivate::~QMapboxGLPrivate()
 {
 }
 
-mbgl::Size QMapboxGLPrivate::framebufferSize() const {
+mbgl::Size QMapboxGLPrivate::getFramebufferSize() const {
     return sanitizedSize(fbSize);
 }
 
 void QMapboxGLPrivate::updateAssumedState() {
     assumeFramebufferBinding(fbObject);
-    assumeViewport(0, 0, framebufferSize());
+    assumeViewport(0, 0, getFramebufferSize());
 }
 
 void QMapboxGLPrivate::bind() {
     setFramebufferBinding(fbObject);
-    setViewport(0, 0, framebufferSize());
+    setViewport(0, 0, getFramebufferSize());
 }
 
 void QMapboxGLPrivate::invalidate()
diff --git a/platform/qt/src/qmapboxgl_p.hpp b/platform/qt/src/qmapboxgl_p.hpp
index 7b0dd8c192..5e12b44a20 100644
--- a/platform/qt/src/qmapboxgl_p.hpp
+++ b/platform/qt/src/qmapboxgl_p.hpp
@@ -3,15 +3,19 @@
 #include "qmapboxgl.hpp"
 #include "qmapboxgl_renderer_frontend_p.hpp"
 
+#include <mbgl/actor/actor.hpp>
 #include <mbgl/map/map.hpp>
 #include <mbgl/renderer/renderer_backend.hpp>
 #include <mbgl/util/default_thread_pool.hpp>
 #include <mbgl/storage/default_file_source.hpp>
 #include <mbgl/util/geo.hpp>
+#include <mbgl/storage/resource_transform.hpp>
 
 #include <QObject>
 #include <QSize>
 
+#include <memory>
+
 class QMapboxGLPrivate : public QObject, public mbgl::RendererBackend, public mbgl::MapObserver
 {
     Q_OBJECT
@@ -20,10 +24,10 @@ public:
     explicit QMapboxGLPrivate(QMapboxGL *, const QMapboxGLSettings &, const QSize &size, qreal pixelRatio);
     virtual ~QMapboxGLPrivate();
 
-    mbgl::Size framebufferSize() const;
 
     // mbgl::RendererBackend implementation.
     void bind() final;
+    mbgl::Size getFramebufferSize() const final;
     void updateAssumedState() final;
     void activate() final {}
     void deactivate() final {}
@@ -68,4 +72,7 @@ signals:
     void needsRendering();
     void mapChanged(QMapboxGL::MapChange);
     void copyrightsChanged(const QString &copyrightsHtml);
+
+private:
+    std::unique_ptr< mbgl::Actor<mbgl::ResourceTransform> > m_resourceTransform;
 };