Refactor for Immutable Source::Impl

17 files changed, 181 insertions, 139 deletions

diff --git a/include/mbgl/style/sources/image_source.hpp b/include/mbgl/style/sources/image_source.hpp
index a0ea29175f..b0dafaa2d4 100644
--- a/include/mbgl/style/sources/image_source.hpp
+++ b/include/mbgl/style/sources/image_source.hpp
@@ -2,29 +2,39 @@
 
 #include <mbgl/style/source.hpp>
 #include <mbgl/util/image.hpp>
+#include <mbgl/util/optional.hpp>
 
 namespace mbgl {
 class LatLng;
+class AsyncRequest;
 
 namespace style {
 
 class ImageSource : public Source {
 public:
     ImageSource(std::string id, const std::vector<LatLng>);
-    
+    ~ImageSource();
+
     const std::string& getURL() const;
     void setURL(const std::string& url) ;
+
     void setImage(mbgl::UnassociatedImage);
+
     void setCoordinates(const std::vector<LatLng>);
-    
-    // Private implementation
+    std::vector<LatLng> getCoordinates() const;
+
     class Impl;
-    Impl* const impl;
+    const Impl& impl() const;
+
+    void loadDescription(FileSource&) final;
+private:
+    optional<std::string> url;
+    std::unique_ptr<AsyncRequest> req;
 };
 
 template <>
 inline bool Source::is<ImageSource>() const {
-    return type == SourceType::Vector;
+    return getType() == SourceType::Image;
 }
 
 } // namespace style
diff --git a/src/mbgl/renderer/buckets/raster_bucket.hpp b/src/mbgl/renderer/buckets/raster_bucket.hpp
index 334954e3f4..69404785b2 100644
--- a/src/mbgl/renderer/buckets/raster_bucket.hpp
+++ b/src/mbgl/renderer/buckets/raster_bucket.hpp
@@ -4,6 +4,11 @@
 #include <mbgl/util/image.hpp>
 #include <mbgl/util/optional.hpp>
 #include <mbgl/gl/texture.hpp>
+#include <mbgl/gl/vertex_buffer.hpp>
+#include <mbgl/gl/index_buffer.hpp>
+#include <mbgl/util/mat4.hpp>
+#include <mbgl/programs/raster_program.hpp>
+#include <mbgl/util/optional.hpp>
 
 namespace mbgl {
 
@@ -13,10 +18,21 @@ public:
 
     void upload(gl::Context&) override;
     void render(Painter&, PaintParameters&, const RenderLayer&, const RenderTile&) override;
+    void render(Painter& painter,
+                              PaintParameters& parameters,
+                              const RenderLayer& layer,
+                              const mat4& matrix);
     bool hasData() const override;
 
     UnassociatedImage image;
     optional<gl::Texture> texture;
+
+    gl::VertexVector<RasterLayoutVertex> vertices;
+    gl::IndexVector<gl::Triangles> indices;
+    gl::SegmentVector<RasterAttributes> segments;
+
+    optional<gl::VertexBuffer<RasterLayoutVertex>> vertexBuffer;
+    optional<gl::IndexBuffer<gl::Triangles>> indexBuffer;
 };
 
 } // namespace mbgl
diff --git a/src/mbgl/renderer/layers/render_circle_layer.cpp b/src/mbgl/renderer/layers/render_circle_layer.cpp
index 24abf5253e..94aa64f088 100644
--- a/src/mbgl/renderer/layers/render_circle_layer.cpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.cpp
@@ -44,7 +44,7 @@ bool RenderCircleLayer::hasTransition() const {
 
 void RenderCircleLayer::uploadBuckets(gl::Context& context, RenderSource*) {
     for (const auto& tileRef : renderTiles) {
-        const auto& bucket = tileRef.get().tile.getBucket(*this);
+        const auto& bucket = tileRef.get().tile.getBucket(impl());
         if (bucket && bucket->needsUpload()) {
             bucket->upload(context);
         }
@@ -54,7 +54,7 @@ void RenderCircleLayer::uploadBuckets(gl::Context& context, RenderSource*) {
 void RenderCircleLayer::render(Painter& painter, PaintParameters& parameters, RenderSource*) {
     for (auto& tileRef : renderTiles) {
         auto& tile = tileRef.get();
-        auto bucket = tile.tile.getBucket(*this);
+        auto bucket = tile.tile.getBucket(impl());
         bucket->render(painter, parameters, *this, tile);
     }
 }
diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
index 25dae7a58b..4e39741e54 100644
--- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
@@ -39,7 +39,7 @@ bool RenderFillExtrusionLayer::hasTransition() const {
 
 void RenderFillExtrusionLayer::uploadBuckets(gl::Context& context, RenderSource*) {
     for (const auto& tileRef : renderTiles) {
-        const auto& bucket = tileRef.get().tile.getBucket(*this);
+        const auto& bucket = tileRef.get().tile.getBucket(impl());
         if (bucket && bucket->needsUpload()) {
             bucket->upload(context);
         }
@@ -49,7 +49,7 @@ void RenderFillExtrusionLayer::uploadBuckets(gl::Context& context, RenderSource*
 void RenderFillExtrusionLayer::render(Painter& painter, PaintParameters& parameters, RenderSource*) {
     for (auto& tileRef : renderTiles) {
         auto& tile = tileRef.get();
-        auto bucket = tile.tile.getBucket(*this);
+        auto bucket = tile.tile.getBucket(impl());
         bucket->render(painter, parameters, *this, tile);
     }
 }
diff --git a/src/mbgl/renderer/layers/render_fill_layer.cpp b/src/mbgl/renderer/layers/render_fill_layer.cpp
index 9cb36008ce..a15719b735 100644
--- a/src/mbgl/renderer/layers/render_fill_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_layer.cpp
@@ -54,7 +54,7 @@ bool RenderFillLayer::hasTransition() const {
 
 void RenderFillLayer::uploadBuckets(gl::Context& context, RenderSource*) {
     for (const auto& tileRef : renderTiles) {
-        const auto& bucket = tileRef.get().tile.getBucket(*this);
+        const auto& bucket = tileRef.get().tile.getBucket(impl());
         if (bucket && bucket->needsUpload()) {
             bucket->upload(context);
         }
@@ -64,7 +64,7 @@ void RenderFillLayer::uploadBuckets(gl::Context& context, RenderSource*) {
 void RenderFillLayer::render(Painter& painter, PaintParameters& parameters, RenderSource*) {
     for (auto& tileRef : renderTiles) {
         auto& tile = tileRef.get();
-        auto bucket = tile.tile.getBucket(*this);
+        auto bucket = tile.tile.getBucket(impl());
         bucket->render(painter, parameters, *this, tile);
     }
 }
diff --git a/src/mbgl/renderer/layers/render_line_layer.cpp b/src/mbgl/renderer/layers/render_line_layer.cpp
index fe09a7441e..e1fb6a0f1a 100644
--- a/src/mbgl/renderer/layers/render_line_layer.cpp
+++ b/src/mbgl/renderer/layers/render_line_layer.cpp
@@ -46,7 +46,7 @@ bool RenderLineLayer::hasTransition() const {
 
 void RenderLineLayer::uploadBuckets(gl::Context& context, RenderSource*) {
     for (const auto& tileRef : renderTiles) {
-        const auto& bucket = tileRef.get().tile.getBucket(*this);
+        const auto& bucket = tileRef.get().tile.getBucket(impl());
         if (bucket && bucket->needsUpload()) {
             bucket->upload(context);
         }
@@ -56,7 +56,7 @@ void RenderLineLayer::uploadBuckets(gl::Context& context, RenderSource*) {
 void RenderLineLayer::render(Painter& painter, PaintParameters& parameters, RenderSource*) {
     for (auto& tileRef : renderTiles) {
         auto& tile = tileRef.get();
-        auto bucket = tile.tile.getBucket(*this);
+        auto bucket = tile.tile.getBucket(impl());
         bucket->render(painter, parameters, *this, tile);
     }
 }
diff --git a/src/mbgl/renderer/layers/render_raster_layer.cpp b/src/mbgl/renderer/layers/render_raster_layer.cpp
index c42eb5b68e..500a167432 100644
--- a/src/mbgl/renderer/layers/render_raster_layer.cpp
+++ b/src/mbgl/renderer/layers/render_raster_layer.cpp
@@ -4,6 +4,9 @@
 #include <mbgl/gl/context.hpp>
 #include <mbgl/renderer/render_tile.hpp>
 #include <mbgl/tile/tile.hpp>
+#include <mbgl/renderer/sources/render_image_source.hpp>
+#include <mbgl/renderer/painter.hpp>
+#include <mbgl/renderer/buckets/raster_bucket.hpp>
 
 namespace mbgl {
 
@@ -34,23 +37,35 @@ bool RenderRasterLayer::hasTransition() const {
     return unevaluated.hasTransition();
 }
 
-void RenderRasterLayer::uploadBuckets(gl::Context& context) {
-    for (const auto& tileRef : renderTiles) {
-        const auto& bucket = tileRef.get().tile.getBucket(*this);
-        if (bucket && bucket->needsUpload()) {
-            bucket->upload(context);
+void RenderRasterLayer::uploadBuckets(gl::Context& context, RenderSource* source) {
+    if (renderTiles.size() > 0) {
+        for (const auto& tileRef : renderTiles) {
+            const auto& bucket = tileRef.get().tile.getBucket(impl());
+            if (bucket && bucket->needsUpload()) {
+                bucket->upload(context);
+            }
+        }
+    } else {
+        RenderImageSource * imageSource = dynamic_cast<RenderImageSource*>(source);
+        if (imageSource) {
+            imageSource->upload(context);
         }
     }
 }
 
-void RenderRasterLayer::render(Painter& painter, PaintParameters& parameters, const RenderSource*) {
-    for (auto& tileRef : renderTiles) {
-        auto& tile = tileRef.get();
-//        MBGL_DEBUG_GROUP(context, getID() + " - " + util::toString(tile.id));
-        auto bucket = tile.tile.getBucket(*this);
-        bucket->render(painter, parameters, *this, tile);
+void RenderRasterLayer::render(Painter& painter, PaintParameters& parameters, RenderSource* source) {
+    if (renderTiles.size() > 0) {
+        for (auto& tileRef : renderTiles) {
+            auto& tile = tileRef.get();
+            auto bucket = tile.tile.getBucket(impl());
+            bucket->render(painter, parameters, *this, tile);
+        }
+    } else {
+        RenderImageSource * imageSource = dynamic_cast<RenderImageSource*>(source);
+        if (imageSource) {
+            imageSource->render(painter, parameters, *this);
+        }
     }
 }
 
-
 } // namespace mbgl
diff --git a/src/mbgl/renderer/layers/render_symbol_layer.cpp b/src/mbgl/renderer/layers/render_symbol_layer.cpp
index c89de0cbdc..0e5246a5ff 100644
--- a/src/mbgl/renderer/layers/render_symbol_layer.cpp
+++ b/src/mbgl/renderer/layers/render_symbol_layer.cpp
@@ -114,7 +114,7 @@ style::SymbolPropertyValues RenderSymbolLayer::textPropertyValues(const style::S
 
 void RenderSymbolLayer::uploadBuckets(gl::Context& context, RenderSource* ) {
     for (const auto& tileRef : renderTiles) {
-        const auto& bucket = tileRef.get().tile.getBucket(*this);
+        const auto& bucket = tileRef.get().tile.getBucket(impl());
         if (bucket && bucket->needsUpload()) {
             bucket->upload(context);
         }
@@ -124,7 +124,7 @@ void RenderSymbolLayer::uploadBuckets(gl::Context& context, RenderSource* ) {
 void RenderSymbolLayer::render(Painter& painter, PaintParameters& parameters, RenderSource*) {
     for (auto& tileRef : renderTiles) {
         auto& tile = tileRef.get();
-        auto bucket = tile.tile.getBucket(*this);
+        auto bucket = tile.tile.getBucket(impl());
         bucket->render(painter, parameters, *this, tile);
     }
 }
diff --git a/src/mbgl/renderer/painters/painter_debug.cpp b/src/mbgl/renderer/painters/painter_debug.cpp
index c7177f66d8..9197b15cf2 100644
--- a/src/mbgl/renderer/painters/painter_debug.cpp
+++ b/src/mbgl/renderer/painters/painter_debug.cpp
@@ -81,7 +81,7 @@ void Painter::renderTileDebug(mat4& matrix) {
     if (frame.debugOptions == MapDebugOptions::NoDebug)
         return;
 
-    static const style::PaintProperties<>::Evaluated properties {};
+    static const style::Properties<>::PossiblyEvaluated properties {};
     static const DebugProgram::PaintPropertyBinders paintAttibuteData(properties, 0);
 
     if (frame.debugOptions & MapDebugOptions::TileBorders) {
diff --git a/src/mbgl/renderer/render_source.cpp b/src/mbgl/renderer/render_source.cpp
index 4b411aa703..c59f767d26 100644
--- a/src/mbgl/renderer/render_source.cpp
+++ b/src/mbgl/renderer/render_source.cpp
@@ -4,6 +4,7 @@
 #include <mbgl/renderer/sources/render_raster_source.hpp>
 #include <mbgl/renderer/sources/render_vector_source.hpp>
 #include <mbgl/annotation/render_annotation_source.hpp>
+#include <mbgl/renderer/sources/render_image_source.hpp>
 #include <mbgl/tile/tile.hpp>
 
 namespace mbgl {
@@ -23,6 +24,8 @@ std::unique_ptr<RenderSource> RenderSource::create(Immutable<Source::Impl> impl)
         return nullptr;
     case SourceType::Annotations:
         return std::make_unique<RenderAnnotationSource>(staticImmutableCast<AnnotationSource::Impl>(impl));
+    case SourceType::Image:
+        return std::make_unique<RenderImageSource>(staticImmutableCast<ImageSource::Impl>(impl));
     }
 
     // Not reachable, but placate GCC.
diff --git a/src/mbgl/renderer/sources/render_image_source.cpp b/src/mbgl/renderer/sources/render_image_source.cpp
index 0f3cc2459a..8fbd6041ed 100644
--- a/src/mbgl/renderer/sources/render_image_source.cpp
+++ b/src/mbgl/renderer/sources/render_image_source.cpp
@@ -12,9 +12,12 @@ namespace mbgl {
 
 using namespace style;
 
-RenderImageSource::RenderImageSource(const style::ImageSource::Impl& impl_)
-: RenderSource(impl_),
- impl(impl_) {
+RenderImageSource::RenderImageSource(Immutable<style::ImageSource::Impl> impl_)
+: RenderSource(impl_) {
+}
+
+const style::ImageSource::Impl& RenderImageSource::impl() const {
+    return static_cast<const style::ImageSource::Impl&>(*baseImpl);
 }
 
 bool RenderImageSource::isLoaded() const {
@@ -59,14 +62,14 @@ void RenderImageSource::upload(gl::Context& context) {
 }
 
 void RenderImageSource::updateTiles(const TileParameters& parameters) {
-    if(!impl.loaded || isLoaded()) {
+    if(isLoaded()) {
         return;
     }
     auto transformState = parameters.transformState;
     auto size = transformState.getSize();
     double viewportHeight = size.height;
 
-    auto coords = impl.getCoordinates();
+    auto coords = impl().getCoordinates();
 
     ScreenCoordinate nePixel = {-INFINITY, -INFINITY};
     ScreenCoordinate swPixel = {INFINITY, INFINITY};
@@ -108,7 +111,7 @@ void RenderImageSource::updateTiles(const TileParameters& parameters) {
 }
 
 void RenderImageSource::setupBucket(GeometryCoordinates& geomCoords) {
-    UnassociatedImage img = impl.getData().clone();
+    UnassociatedImage img = impl().getImage().clone();
     if (!img.valid()) {
         return;
     }
@@ -133,7 +136,7 @@ void RenderImageSource::render(Painter& painter, PaintParameters& parameters, co
 }
 
 void RenderImageSource::dumpDebugLogs() const {
-    Log::Info(Event::General, "RenderImageSource::id: %s", baseImpl.id.c_str());
+    Log::Info(Event::General, "RenderImageSource::id: %s", impl().id.c_str());
     Log::Info(Event::General, "RenderImageSource::loaded: %s", isLoaded() ? "yes" : "no");
 }
 
diff --git a/src/mbgl/renderer/sources/render_image_source.hpp b/src/mbgl/renderer/sources/render_image_source.hpp
index f2835d0925..6d3a0ce660 100644
--- a/src/mbgl/renderer/sources/render_image_source.hpp
+++ b/src/mbgl/renderer/sources/render_image_source.hpp
@@ -4,11 +4,12 @@
 #include <mbgl/style/sources/image_source_impl.hpp>
 #include <mbgl/tile/geometry_tile_data.hpp>
 #include <mbgl/util/optional.hpp>
+#include <mbgl/renderer/render_tile.hpp>
+#include <mbgl/renderer/buckets/raster_bucket.hpp>
 
 namespace mbgl {
 class RenderLayer;
 class PaintParameters;
-class RasterBucket;
 
 namespace gl {
     class Context;
@@ -16,7 +17,7 @@ namespace gl {
 
 class RenderImageSource : public RenderSource {
 public:
-    RenderImageSource(const style::ImageSource::Impl&);
+    RenderImageSource(Immutable<style::ImageSource::Impl>);
     
     bool isLoaded() const final;
     void upload(gl::Context&) ;
@@ -52,9 +53,9 @@ public:
     void dumpDebugLogs() const final;
 
 private:
+    const style::ImageSource::Impl& impl() const;
 
     void setupBucket(GeometryCoordinates& coordiantes);
-    const style::ImageSource::Impl& impl;
     std::map<UnwrappedTileID, RenderTile> tiles;
 
     std::unique_ptr<UnwrappedTileID> tileId;
diff --git a/src/mbgl/style/sources/image_source.cpp b/src/mbgl/style/sources/image_source.cpp
index d2f26bc8d1..8e6ca673f6 100644
--- a/src/mbgl/style/sources/image_source.cpp
+++ b/src/mbgl/style/sources/image_source.cpp
@@ -1,30 +1,84 @@
 #include <mbgl/style/sources/image_source.hpp>
 #include <mbgl/style/sources/image_source_impl.hpp>
 #include <mbgl/util/geo.hpp>
+#include <mbgl/style/source_observer.hpp>
+#include <mbgl/util/premultiply.hpp>
+#include <mbgl/storage/file_source.hpp>
 
 namespace mbgl {
 namespace style {
 
-ImageSource::ImageSource(std::string id, const std::vector<LatLng> coords)
-    : Source(SourceType::Image,
-     std::make_unique<ImageSource::Impl>(std::move(id), *this, coords)),
-     impl(static_cast<Impl*>(baseImpl.get())) {
+ImageSource::ImageSource(std::string id, const std::vector<LatLng> coords_)
+    : Source(makeMutable<Impl>(std::move(id), coords_)) {
 }
 
-void ImageSource::setCoordinates(const std::vector<LatLng> coords) {
-    impl->setCoordinates(coords);
+ImageSource::~ImageSource() = default;
+
+const ImageSource::Impl& ImageSource::impl() const {
+    return static_cast<const Impl&>(*baseImpl);
+}
+
+void ImageSource::setCoordinates(const std::vector<LatLng> coords_) {
+    baseImpl = makeMutable<Impl>(impl(), coords_);
+    observer->onSourceChanged(*this);
+}
+
+std::vector<LatLng> ImageSource::getCoordinates() const {
+    return impl().getCoordinates();
 }
 
-void ImageSource::setURL(const std::string& url) {
-    impl->setURL(url);
+void ImageSource::setURL(const std::string& url_) {
+    url = std::move(url_);
+    // Signal that the source description needs a reload
+    if (loaded || req) {
+        loaded = false;
+        req.reset();
+        observer->onSourceDescriptionChanged(*this);
+    }
 }
 
-void ImageSource::setImage(mbgl::UnassociatedImage image) {
-    impl->setImage(std::move(image));
+void ImageSource::setImage(mbgl::UnassociatedImage image_) {
+    url = {};
+    if (req) {
+        req.reset();
+    }
+    loaded = true;
+    baseImpl = makeMutable<Impl>(impl(), std::move(image_));
+    observer->onSourceChanged(*this);
 }
 
 const std::string& ImageSource::getURL() const {
-     return impl->getURL();
+    return *url;
+}
+
+void ImageSource::loadDescription(FileSource& fileSource) {
+    if (!url) {
+        loaded = true;
+    }
+
+    if (req ||  loaded) {
+        return;
+    }
+    const Resource imageResource { Resource::Unknown, *url, {}, Resource::Necessity::Required };
+
+    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) {
+            return;
+        } else if (res.noContent) {
+            observer->onSourceError(*this, std::make_exception_ptr(std::runtime_error("unexpectedly empty image url")));
+        } else {
+            try {
+                UnassociatedImage image = util::unpremultiply(decodeImage(*res.data));
+                baseImpl = makeMutable<Impl>(impl(), std::move(image));
+            } catch (...) {
+                observer->onSourceError(*this, std::current_exception());
+            }
+            loaded = true;
+            observer->onSourceLoaded(*this);
+        }
+    });
 }
 
 } // namespace style
diff --git a/src/mbgl/style/sources/image_source_impl.cpp b/src/mbgl/style/sources/image_source_impl.cpp
index 6268f8d068..e16b33b4ca 100644
--- a/src/mbgl/style/sources/image_source_impl.cpp
+++ b/src/mbgl/style/sources/image_source_impl.cpp
@@ -1,91 +1,41 @@
-#include <mbgl/util/logging.hpp>
-#include <mbgl/storage/file_source.hpp>
-#include <mbgl/style/source_observer.hpp>
 #include <mbgl/style/sources/image_source_impl.hpp>
-#include <mbgl/renderer/buckets/raster_bucket.hpp>
-#include <mbgl/util/premultiply.hpp>
-#include <mbgl/renderer/sources/render_image_source.hpp>
-#include <mbgl/renderer/render_tile.hpp>
-
-#include <sstream>
+#include <mbgl/util/geo.hpp>
 
 namespace mbgl {
 namespace style {
 
-ImageSource::Impl::Impl(std::string id_, Source& base_, const std::vector<LatLng>& coords_)
-    : Source::Impl(SourceType::Image, std::move(id_), base_),
+ImageSource::Impl::Impl(std::string id_, std::vector<LatLng> coords_)
+    : Source::Impl(SourceType::Image, std::move(id_)),
     coords(std::move(coords_)) {
 }
 
-ImageSource::Impl::~Impl() = default;
-
-void ImageSource::Impl::setURL(std::string url_) {
-    url = std::move(url_);
-    // Signal that the source description needs a reload
-    if (loaded || req) {
-        loaded = false;
-        req.reset();
-        observer->onSourceDescriptionChanged(base);
-    }
-}
-
-const std::string& ImageSource::Impl::getURL() const {
-    return url;
+ImageSource::Impl::Impl(const Impl& other, std::vector<LatLng> coords_)
+    : Source::Impl(other),
+    coords(std::move(coords_)),
+    image(other.image.clone()) {
 }
 
-void ImageSource::Impl::setCoordinates(const std::vector<LatLng> coords_) {
-    coords = std::move(coords_);
-    observer->onSourceChanged(base);
-}
-
-std::vector<LatLng> ImageSource::Impl::getCoordinates() const {
-    return coords;
+ImageSource::Impl::Impl(const Impl& rhs, UnassociatedImage image_)
+    : Source::Impl(rhs),
+    coords(rhs.coords),
+    image(std::move(image_)) {
 }
+ImageSource::Impl::~Impl() = default;
 
-void ImageSource::Impl::setImage(mbgl::UnassociatedImage image_) {
+void ImageSource::Impl::setImage(UnassociatedImage image_) {
     image = std::move(image_);
-    if (req) {
-        req.reset();
-    }
-    observer->onSourceChanged(base);
 }
 
-std::unique_ptr<RenderSource> ImageSource::Impl::createRenderSource() const {
-    return std::make_unique<RenderImageSource>(*this);
+const UnassociatedImage& ImageSource::Impl::getImage() const {
+    return image;
 }
 
-
-void ImageSource::Impl::loadDescription(FileSource& fileSource) {
-    if (url.empty()) {
-        loaded = true;
-    }
-
-    if (req ||  loaded) {
-        return;
-    }
-    const Resource imageResource { Resource::Unknown, url, {}, Resource::Necessity::Required };
-
-    req = fileSource.request(imageResource, [this](Response res) {
-        if (res.error) {
-            observer->onSourceError(base, std::make_exception_ptr(std::runtime_error(res.error->message)));
-        } else if (res.notModified) {
-            return;
-        } else if (res.noContent) {
-            observer->onSourceError(base, std::make_exception_ptr(std::runtime_error("unexpectedly empty image url")));
-        } else {
-            try {
-                image = util::unpremultiply(decodeImage(*res.data));
-            } catch (...) {
-                observer->onSourceError(base, std::current_exception());
-            }
-            loaded = true;
-            observer->onSourceLoaded(base);
-        }
-    });
+std::vector<LatLng> ImageSource::Impl::getCoordinates() const {
+    return coords;
 }
 
-const mbgl::UnassociatedImage& ImageSource::Impl::getData() const {
-    return image;
+optional<std::string> ImageSource::Impl::getAttribution() const {
+    return {};
 }
 
 } // namespace style
diff --git a/src/mbgl/style/sources/image_source_impl.hpp b/src/mbgl/style/sources/image_source_impl.hpp
index a7ae53d2f6..439db4fa64 100644
--- a/src/mbgl/style/sources/image_source_impl.hpp
+++ b/src/mbgl/style/sources/image_source_impl.hpp
@@ -5,35 +5,25 @@
 #include <mbgl/util/image.hpp>
 
 namespace mbgl {
-
-class AsyncRequest;
-class RenderSource;
+class LatLng;
 
 namespace style {
 
 class ImageSource::Impl : public Source::Impl {
 public:
-    Impl(std::string id, Source&, const std::vector<LatLng>& coords);
+    Impl(std::string id, std::vector<LatLng> coords);
+    Impl(const Impl& rhs, std::vector<LatLng> coords);
+    Impl(const Impl& rhs, UnassociatedImage image);
 
     ~Impl() final;
 
-    void setImage(mbgl::UnassociatedImage);
-
-    void setURL(std::string);
-    const std::string& getURL() const;
-    void setCoordinates(const std::vector<LatLng> coords);
+    void setImage(UnassociatedImage );
+    const mbgl::UnassociatedImage& getImage() const;
     std::vector<LatLng> getCoordinates() const;
 
-    const mbgl::UnassociatedImage& getData() const;
-
-    void loadDescription(FileSource&) final;
-
-    std::unique_ptr<RenderSource> createRenderSource() const final;
-
+    optional<std::string> getAttribution() const final;
 private:
-    std::string url;
     std::vector<LatLng> coords;
-    std::unique_ptr<AsyncRequest> req;
     mbgl::UnassociatedImage image;
 };
 
diff --git a/src/mbgl/style/style.cpp b/src/mbgl/style/style.cpp
index 2008f0b5be..f707d4b502 100644
--- a/src/mbgl/style/style.cpp
+++ b/src/mbgl/style/style.cpp
@@ -533,8 +533,8 @@ RenderData Style::getRenderData(MapDebugOptions debugOptions, float angle) const
         }
     }
 
-    for (const auto& layerImpl : layerImpls) {
-        const RenderLayer* layer = getRenderLayer(layerImpl->id);
+    for (auto& layerImpl : layerImpls) {
+        RenderLayer* layer = getRenderLayer(layerImpl->id);
         assert(layer);
 
         if (!layer->needsRendering(zoomHistory.lastZoom)) {
diff --git a/test/style/source.test.cpp b/test/style/source.test.cpp
index 5327ee245c..75fc74ec0c 100644
--- a/test/style/source.test.cpp
+++ b/test/style/source.test.cpp
@@ -458,10 +458,10 @@ TEST(Source, ImageSourceImageUpdate) {
 
     ImageSource source("source", coords);
     source.setURL("http://url");
-    source.baseImpl->setObserver(&test.styleObserver);
+    source.setObserver(&test.styleObserver);
 
     // Load initial, so the source state will be loaded=true
-    source.baseImpl->loadDescription(test.fileSource);
+    source.loadDescription(test.fileSource);
     UnassociatedImage rgba({ 1, 1 });
     rgba.data[0] = 255;
     rgba.data[1] = 254;