1 files changed, 59 insertions, 30 deletions

diff --git a/platform/default/mbgl/storage/offline_download.cpp b/platform/default/mbgl/storage/offline_download.cpp
index 901f996a4f..ff61114888 100644
--- a/platform/default/mbgl/storage/offline_download.cpp
+++ b/platform/default/mbgl/storage/offline_download.cpp
@@ -5,8 +5,10 @@
 #include <mbgl/storage/response.hpp>
 #include <mbgl/storage/http_file_source.hpp>
 #include <mbgl/style/parser.hpp>
-#include <mbgl/style/sources/geojson_source_impl.hpp>
-#include <mbgl/style/tile_source_impl.hpp>
+#include <mbgl/style/sources/vector_source.hpp>
+#include <mbgl/style/sources/raster_source.hpp>
+#include <mbgl/style/sources/geojson_source.hpp>
+#include <mbgl/style/sources/image_source.hpp>
 #include <mbgl/style/conversion/json.hpp>
 #include <mbgl/style/conversion/tileset.hpp>
 #include <mbgl/text/glyph.hpp>
@@ -19,6 +21,8 @@
 
 namespace mbgl {
 
+using namespace style;
+
 OfflineDownload::OfflineDownload(int64_t id_,
                                  OfflineRegionDefinition&& definition_,
                                  OfflineDatabase& offlineDatabase_,
@@ -71,40 +75,53 @@ OfflineRegionStatus OfflineDownload::getStatus() const {
     result.requiredResourceCountIsPrecise = true;
 
     for (const auto& source : parser.sources) {
-        SourceType type = source->baseImpl->type;
-
-        switch (type) {
-        case SourceType::Vector:
-        case SourceType::Raster: {
-            style::TileSourceImpl* tileSource =
-                static_cast<style::TileSourceImpl*>(source->baseImpl.get());
-            const variant<std::string, Tileset>& urlOrTileset = tileSource->getURLOrTileset();
-            const uint16_t tileSize = tileSource->getTileSize();
+        SourceType type = source->getType();
 
+        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 std::string& url = urlOrTileset.get<std::string>();
+                const auto& url = urlOrTileset.get<std::string>();
                 optional<Response> sourceResponse = offlineDatabase.get(Resource::source(url));
                 if (sourceResponse) {
                     style::conversion::Error error;
                     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;
                 }
             }
+        };
+
+        switch (type) {
+        case SourceType::Vector: {
+            const auto& vectorSource = *source->as<VectorSource>();
+            handleTiledSource(vectorSource.getURLOrTileset(), util::tileSize);
+            break;
+        }
+
+        case SourceType::Raster: {
+            const auto& rasterSource = *source->as<RasterSource>();
+            handleTiledSource(rasterSource.getURLOrTileset(), rasterSource.getTileSize());
             break;
         }
 
         case SourceType::GeoJSON: {
-            style::GeoJSONSource* geojsonSource = source->as<style::GeoJSONSource>();
-            if (geojsonSource->getURL()) {
+            const auto& geojsonSource = *source->as<GeoJSONSource>();
+            if (geojsonSource.getURL()) {
+                result.requiredResourceCount += 1;
+            }
+            break;
+        }
+
+        case SourceType::Image: {
+            const auto& imageSource = *source->as<ImageSource>();
+            if (imageSource.getURL()) {
                 result.requiredResourceCount += 1;
             }
             break;
@@ -138,20 +155,13 @@ void OfflineDownload::activateDownload() {
         parser.parse(*styleResponse.data);
 
         for (const auto& source : parser.sources) {
-            SourceType type = source->baseImpl->type;
-
-            switch (type) {
-            case SourceType::Vector:
-            case SourceType::Raster: {
-                const style::TileSourceImpl* tileSource =
-                    static_cast<style::TileSourceImpl*>(source->baseImpl.get());
-                const variant<std::string, Tileset>& urlOrTileset = tileSource->getURLOrTileset();
-                const uint16_t tileSize = tileSource->getTileSize();
+            SourceType type = source->getType();
 
+            auto handleTiledSource = [&] (const variant<std::string, Tileset>& urlOrTileset, const uint16_t tileSize) {
                 if (urlOrTileset.is<Tileset>()) {
                     queueTiles(type, tileSize, urlOrTileset.get<Tileset>());
                 } else {
-                    const std::string& url = urlOrTileset.get<std::string>();
+                    const auto& url = urlOrTileset.get<std::string>();
                     status.requiredResourceCountIsPrecise = false;
                     status.requiredResourceCount++;
                     requiredSourceURLs.insert(url);
@@ -170,15 +180,34 @@ void OfflineDownload::activateDownload() {
                         }
                     });
                 }
+            };
+
+            switch (type) {
+            case SourceType::Vector: {
+                const auto& vectorSource = *source->as<VectorSource>();
+                handleTiledSource(vectorSource.getURLOrTileset(), util::tileSize);
+                break;
+            }
+
+            case SourceType::Raster: {
+                const auto& rasterSource = *source->as<RasterSource>();
+                handleTiledSource(rasterSource.getURLOrTileset(), rasterSource.getTileSize());
                 break;
             }
 
             case SourceType::GeoJSON: {
-                style::GeoJSONSource::Impl* geojsonSource =
-                    static_cast<style::GeoJSONSource::Impl*>(source->baseImpl.get());
+                const auto& geojsonSource = *source->as<GeoJSONSource>();
+                if (geojsonSource.getURL()) {
+                    queueResource(Resource::source(*geojsonSource.getURL()));
+                }
+                break;
+            }
 
-                if (geojsonSource->getURL()) {
-                    queueResource(Resource::source(*geojsonSource->getURL()));
+            case SourceType::Image: {
+                const auto& imageSource = *source->as<ImageSource>();
+                auto imageUrl = imageSource.getURL();
+                if (imageUrl && !imageUrl->empty()) {
+                    queueResource(Resource::image(*imageUrl));
                 }
                 break;
             }