[core] Immutable Impls

32 files changed, 235 insertions, 128 deletions

diff --git a/src/mbgl/renderer/group_by_layout.cpp b/src/mbgl/renderer/group_by_layout.cpp
index df1eb7c7dd..3b02727ff8 100644
--- a/src/mbgl/renderer/group_by_layout.cpp
+++ b/src/mbgl/renderer/group_by_layout.cpp
@@ -19,13 +19,13 @@ std::string layoutKey(const RenderLayer& layer) {
 
     writer.StartArray();
     writer.Uint(static_cast<uint32_t>(layer.type));
-    writer.String(layer.baseImpl.source);
-    writer.String(layer.baseImpl.sourceLayer);
-    writer.Double(layer.baseImpl.minZoom);
-    writer.Double(layer.baseImpl.maxZoom);
-    writer.Uint(static_cast<uint32_t>(layer.baseImpl.visibility));
-    stringify(writer, layer.baseImpl.filter);
-    layer.baseImpl.stringifyLayout(writer);
+    writer.String(layer.baseImpl->source);
+    writer.String(layer.baseImpl->sourceLayer);
+    writer.Double(layer.baseImpl->minZoom);
+    writer.Double(layer.baseImpl->maxZoom);
+    writer.Uint(static_cast<uint32_t>(layer.baseImpl->visibility));
+    stringify(writer, layer.baseImpl->filter);
+    layer.baseImpl->stringifyLayout(writer);
     writer.EndArray();
 
     return s.GetString();
diff --git a/src/mbgl/renderer/painter.cpp b/src/mbgl/renderer/painter.cpp
index eed3bfcd8b..51770b07b1 100644
--- a/src/mbgl/renderer/painter.cpp
+++ b/src/mbgl/renderer/painter.cpp
@@ -144,7 +144,7 @@ void Painter::render(const Style& style, const FrameData& frame_, View& view, Sp
     spriteAtlas = style.spriteAtlas.get();
     lineAtlas = style.lineAtlas.get();
 
-    evaluatedLight = style.getRenderLight()->getEvaluated();
+    evaluatedLight = style.getRenderLight().getEvaluated();
 
     RenderData renderData = style.getRenderData(frame.debugOptions, state.getAngle());
     const std::vector<RenderItem>& order = renderData.order;
@@ -180,7 +180,7 @@ void Painter::render(const Style& style, const FrameData& frame_, View& view, Sp
 
         for (const auto& item : order) {
             for (const auto& tileRef : item.tiles) {
-                const auto& bucket = tileRef.get().tile.getBucket(item.layer);
+                const auto& bucket = tileRef.get().tile.getBucket(*item.layer.baseImpl);
                 if (bucket && bucket->needsUpload()) {
                     bucket->upload(context);
                 }
@@ -309,7 +309,7 @@ void Painter::renderPass(PaintParameters& parameters,
             MBGL_DEBUG_GROUP(context, "background");
             renderBackground(parameters, *layer.as<RenderBackgroundLayer>());
         } else if (layer.is<RenderCustomLayer>()) {
-            MBGL_DEBUG_GROUP(context, layer.baseImpl.id + " - custom");
+            MBGL_DEBUG_GROUP(context, layer.baseImpl->id + " - custom");
 
             // Reset GL state to a known state so the CustomLayer always has a clean slate.
             context.vertexArrayObject = 0;
@@ -317,7 +317,7 @@ void Painter::renderPass(PaintParameters& parameters,
             context.setStencilMode(gl::StencilMode::disabled());
             context.setColorMode(colorModeForRenderPass());
 
-            layer.as<RenderCustomLayer>()->impl->render(state);
+            layer.as<RenderCustomLayer>()->impl().render(state);
 
             // Reset the view back to our original one, just in case the CustomLayer changed
             // the viewport or Framebuffer.
@@ -339,8 +339,8 @@ void Painter::renderPass(PaintParameters& parameters,
             for (auto& tileRef : item.tiles) {
                 auto& tile = tileRef.get();
 
-                MBGL_DEBUG_GROUP(context, layer.baseImpl.id + " - " + util::toString(tile.id));
-                auto bucket = tile.tile.getBucket(layer);
+                MBGL_DEBUG_GROUP(context, layer.baseImpl->id + " - " + util::toString(tile.id));
+                auto bucket = tile.tile.getBucket(*layer.baseImpl);
                 bucket->render(*this, parameters, layer, tile);
             }
 
@@ -366,8 +366,8 @@ void Painter::renderPass(PaintParameters& parameters,
         } else {
             for (auto& tileRef : item.tiles) {
                 auto& tile = tileRef.get();
-                MBGL_DEBUG_GROUP(context, layer.baseImpl.id + " - " + util::toString(tile.id));
-                auto bucket = tile.tile.getBucket(layer);
+                MBGL_DEBUG_GROUP(context, layer.baseImpl->id + " - " + util::toString(tile.id));
+                auto bucket = tile.tile.getBucket(*layer.baseImpl);
                 bucket->render(*this, parameters, layer, tile);
             }
         }
diff --git a/src/mbgl/renderer/render_background_layer.cpp b/src/mbgl/renderer/render_background_layer.cpp
index 8069209c71..f2e9c0cbaf 100644
--- a/src/mbgl/renderer/render_background_layer.cpp
+++ b/src/mbgl/renderer/render_background_layer.cpp
@@ -4,9 +4,12 @@
 
 namespace mbgl {
 
-RenderBackgroundLayer::RenderBackgroundLayer(const style::BackgroundLayer::Impl& _impl)
-        : RenderLayer(style::LayerType::Background, _impl),
-          impl(&_impl) {
+RenderBackgroundLayer::RenderBackgroundLayer(Immutable<style::BackgroundLayer::Impl> _impl)
+    : RenderLayer(style::LayerType::Background, _impl) {
+}
+
+const style::BackgroundLayer::Impl& RenderBackgroundLayer::impl() const {
+    return static_cast<const style::BackgroundLayer::Impl&>(*baseImpl);
 }
 
 std::unique_ptr<RenderLayer> RenderBackgroundLayer::clone() const {
@@ -20,7 +23,7 @@ std::unique_ptr<Bucket> RenderBackgroundLayer::createBucket(const BucketParamete
 }
 
 void RenderBackgroundLayer::cascade(const CascadeParameters &parameters) {
-    unevaluated = impl->cascading.cascade(parameters, std::move(unevaluated));
+    unevaluated = impl().cascading.cascade(parameters, std::move(unevaluated));
 }
 
 void RenderBackgroundLayer::evaluate(const PropertyEvaluationParameters &parameters) {
diff --git a/src/mbgl/renderer/render_background_layer.hpp b/src/mbgl/renderer/render_background_layer.hpp
index 9174664a70..6a98ff330c 100644
--- a/src/mbgl/renderer/render_background_layer.hpp
+++ b/src/mbgl/renderer/render_background_layer.hpp
@@ -8,8 +8,7 @@ namespace mbgl {
 
 class RenderBackgroundLayer: public RenderLayer {
 public:
-
-    RenderBackgroundLayer(const style::BackgroundLayer::Impl&);
+    RenderBackgroundLayer(Immutable<style::BackgroundLayer::Impl>);
     ~RenderBackgroundLayer() final = default;
 
     std::unique_ptr<RenderLayer> clone() const override;
@@ -24,7 +23,7 @@ public:
     style::BackgroundPaintProperties::Unevaluated unevaluated;
     style::BackgroundPaintProperties::Evaluated evaluated;
 
-    const style::BackgroundLayer::Impl* const impl;
+    const style::BackgroundLayer::Impl& impl() const;
 };
 
 template <>
diff --git a/src/mbgl/renderer/render_circle_layer.cpp b/src/mbgl/renderer/render_circle_layer.cpp
index e9ed465187..fb179082c9 100644
--- a/src/mbgl/renderer/render_circle_layer.cpp
+++ b/src/mbgl/renderer/render_circle_layer.cpp
@@ -7,9 +7,12 @@
 
 namespace mbgl {
 
-RenderCircleLayer::RenderCircleLayer(const style::CircleLayer::Impl& _impl)
-        : RenderLayer(style::LayerType::Circle, _impl),
-          impl(&_impl) {
+RenderCircleLayer::RenderCircleLayer(Immutable<style::CircleLayer::Impl> _impl)
+    : RenderLayer(style::LayerType::Circle, _impl) {
+}
+
+const style::CircleLayer::Impl& RenderCircleLayer::impl() const {
+    return static_cast<const style::CircleLayer::Impl&>(*baseImpl);
 }
 
 std::unique_ptr<RenderLayer> RenderCircleLayer::clone() const {
@@ -21,7 +24,7 @@ std::unique_ptr<Bucket> RenderCircleLayer::createBucket(const BucketParameters&
 }
 
 void RenderCircleLayer::cascade(const CascadeParameters& parameters) {
-    unevaluated = impl->cascading.cascade(parameters, std::move(unevaluated));
+    unevaluated = impl().cascading.cascade(parameters, std::move(unevaluated));
 }
 
 void RenderCircleLayer::evaluate(const PropertyEvaluationParameters& parameters) {
diff --git a/src/mbgl/renderer/render_circle_layer.hpp b/src/mbgl/renderer/render_circle_layer.hpp
index 60d600faca..7c411e80aa 100644
--- a/src/mbgl/renderer/render_circle_layer.hpp
+++ b/src/mbgl/renderer/render_circle_layer.hpp
@@ -8,8 +8,7 @@ namespace mbgl {
 
 class RenderCircleLayer: public RenderLayer {
 public:
-
-    RenderCircleLayer(const style::CircleLayer::Impl&);
+    RenderCircleLayer(Immutable<style::CircleLayer::Impl>);
     ~RenderCircleLayer() final = default;
 
     std::unique_ptr<RenderLayer> clone() const override;
@@ -31,7 +30,7 @@ public:
     style::CirclePaintProperties::Unevaluated unevaluated;
     style::CirclePaintProperties::Evaluated evaluated;
 
-    const style::CircleLayer::Impl* const impl;
+    const style::CircleLayer::Impl& impl() const;
 };
 
 template <>
diff --git a/src/mbgl/renderer/render_custom_layer.cpp b/src/mbgl/renderer/render_custom_layer.cpp
index d89fa7bba2..0f22bc8780 100644
--- a/src/mbgl/renderer/render_custom_layer.cpp
+++ b/src/mbgl/renderer/render_custom_layer.cpp
@@ -4,9 +4,12 @@
 
 namespace mbgl {
 
-RenderCustomLayer::RenderCustomLayer(const style::CustomLayer::Impl& _impl)
-        : RenderLayer(style::LayerType::Custom, _impl),
-          impl(&_impl) {
+RenderCustomLayer::RenderCustomLayer(Immutable<style::CustomLayer::Impl> _impl)
+    : RenderLayer(style::LayerType::Custom, _impl) {
+}
+
+const style::CustomLayer::Impl& RenderCustomLayer::impl() const {
+    return static_cast<const style::CustomLayer::Impl&>(*baseImpl);
 }
 
 std::unique_ptr<RenderLayer> RenderCustomLayer::clone() const {
diff --git a/src/mbgl/renderer/render_custom_layer.hpp b/src/mbgl/renderer/render_custom_layer.hpp
index f6ef253481..9b16928a58 100644
--- a/src/mbgl/renderer/render_custom_layer.hpp
+++ b/src/mbgl/renderer/render_custom_layer.hpp
@@ -7,8 +7,7 @@ namespace mbgl {
 
 class RenderCustomLayer: public RenderLayer {
 public:
-
-    RenderCustomLayer(const style::CustomLayer::Impl&);
+    RenderCustomLayer(Immutable<style::CustomLayer::Impl>);
     ~RenderCustomLayer() final = default;
 
     std::unique_ptr<RenderLayer> clone() const override;
@@ -19,7 +18,7 @@ public:
 
     std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const final;
 
-    const style::CustomLayer::Impl* const impl;
+    const style::CustomLayer::Impl& impl() const;
 };
 
 template <>
diff --git a/src/mbgl/renderer/render_fill_extrusion_layer.cpp b/src/mbgl/renderer/render_fill_extrusion_layer.cpp
index f6ba164d8c..8dc6e93a9e 100644
--- a/src/mbgl/renderer/render_fill_extrusion_layer.cpp
+++ b/src/mbgl/renderer/render_fill_extrusion_layer.cpp
@@ -7,9 +7,12 @@
 
 namespace mbgl {
 
-RenderFillExtrusionLayer::RenderFillExtrusionLayer(const style::FillExtrusionLayer::Impl& _impl)
-        : RenderLayer(style::LayerType::FillExtrusion, _impl),
-          impl(&_impl) {
+RenderFillExtrusionLayer::RenderFillExtrusionLayer(Immutable<style::FillExtrusionLayer::Impl> _impl)
+    : RenderLayer(style::LayerType::FillExtrusion, _impl) {
+}
+
+const style::FillExtrusionLayer::Impl& RenderFillExtrusionLayer::impl() const {
+    return static_cast<const style::FillExtrusionLayer::Impl&>(*baseImpl);
 }
 
 std::unique_ptr<RenderLayer> RenderFillExtrusionLayer::clone() const {
@@ -21,7 +24,7 @@ std::unique_ptr<Bucket> RenderFillExtrusionLayer::createBucket(const BucketParam
 }
 
 void RenderFillExtrusionLayer::cascade(const CascadeParameters& parameters) {
-    unevaluated = impl->cascading.cascade(parameters, std::move(unevaluated));
+    unevaluated = impl().cascading.cascade(parameters, std::move(unevaluated));
 }
 
 void RenderFillExtrusionLayer::evaluate(const PropertyEvaluationParameters& parameters) {
diff --git a/src/mbgl/renderer/render_fill_extrusion_layer.hpp b/src/mbgl/renderer/render_fill_extrusion_layer.hpp
index bd66d8e3b1..2bfbc296c1 100644
--- a/src/mbgl/renderer/render_fill_extrusion_layer.hpp
+++ b/src/mbgl/renderer/render_fill_extrusion_layer.hpp
@@ -8,8 +8,7 @@ namespace mbgl {
 
 class RenderFillExtrusionLayer: public RenderLayer {
 public:
-
-    RenderFillExtrusionLayer(const style::FillExtrusionLayer::Impl&);
+    RenderFillExtrusionLayer(Immutable<style::FillExtrusionLayer::Impl>);
     ~RenderFillExtrusionLayer() final = default;
 
     std::unique_ptr<RenderLayer> clone() const override;
@@ -31,7 +30,7 @@ public:
     style::FillExtrusionPaintProperties::Unevaluated unevaluated;
     style::FillExtrusionPaintProperties::Evaluated evaluated;
 
-    const style::FillExtrusionLayer::Impl* const impl;
+    const style::FillExtrusionLayer::Impl& impl() const;
 };
 
 template <>
diff --git a/src/mbgl/renderer/render_fill_layer.cpp b/src/mbgl/renderer/render_fill_layer.cpp
index 340ec85803..0de22b3ca8 100644
--- a/src/mbgl/renderer/render_fill_layer.cpp
+++ b/src/mbgl/renderer/render_fill_layer.cpp
@@ -7,9 +7,12 @@
 
 namespace mbgl {
 
-RenderFillLayer::RenderFillLayer(const style::FillLayer::Impl& _impl)
-        : RenderLayer(style::LayerType::Fill, _impl),
-          impl(&_impl) {
+RenderFillLayer::RenderFillLayer(Immutable<style::FillLayer::Impl> _impl)
+    : RenderLayer(style::LayerType::Fill, _impl) {
+}
+
+const style::FillLayer::Impl& RenderFillLayer::impl() const {
+    return static_cast<const style::FillLayer::Impl&>(*baseImpl);
 }
 
 std::unique_ptr<RenderLayer> RenderFillLayer::clone() const {
@@ -21,7 +24,7 @@ std::unique_ptr<Bucket> RenderFillLayer::createBucket(const BucketParameters& pa
 }
 
 void RenderFillLayer::cascade(const CascadeParameters& parameters) {
-    unevaluated = impl->cascading.cascade(parameters, std::move(unevaluated));
+    unevaluated = impl().cascading.cascade(parameters, std::move(unevaluated));
 }
 
 void RenderFillLayer::evaluate(const PropertyEvaluationParameters& parameters) {
diff --git a/src/mbgl/renderer/render_fill_layer.hpp b/src/mbgl/renderer/render_fill_layer.hpp
index 8080cf289b..7e23a61a00 100644
--- a/src/mbgl/renderer/render_fill_layer.hpp
+++ b/src/mbgl/renderer/render_fill_layer.hpp
@@ -8,8 +8,7 @@ namespace mbgl {
 
 class RenderFillLayer: public RenderLayer {
 public:
-
-    RenderFillLayer(const style::FillLayer::Impl&);
+    RenderFillLayer(Immutable<style::FillLayer::Impl>);
     ~RenderFillLayer() final = default;
 
     std::unique_ptr<RenderLayer> clone() const override;
@@ -31,7 +30,7 @@ public:
     style::FillPaintProperties::Unevaluated unevaluated;
     style::FillPaintProperties::Evaluated evaluated;
 
-    const style::FillLayer::Impl* const impl;
+    const style::FillLayer::Impl& impl() const;
 };
 
 template <>
diff --git a/src/mbgl/renderer/render_layer.cpp b/src/mbgl/renderer/render_layer.cpp
index ed8864149b..2f30b2ce21 100644
--- a/src/mbgl/renderer/render_layer.cpp
+++ b/src/mbgl/renderer/render_layer.cpp
@@ -3,12 +3,17 @@
 
 namespace mbgl {
 
-RenderLayer::RenderLayer(style::LayerType type_, const style::Layer::Impl& baseImpl_)
-        : type(type_), baseImpl(baseImpl_) {
+RenderLayer::RenderLayer(style::LayerType type_, Immutable<style::Layer::Impl> baseImpl_)
+        : type(type_),
+          baseImpl(baseImpl_) {
+}
+
+void RenderLayer::setImpl(Immutable<style::Layer::Impl> impl) {
+    baseImpl = impl;
 }
 
 const std::string& RenderLayer::getID() const {
-    return baseImpl.id;
+    return baseImpl->id;
 }
 
 bool RenderLayer::hasRenderPass(RenderPass pass) const {
@@ -17,9 +22,9 @@ bool RenderLayer::hasRenderPass(RenderPass pass) const {
 
 bool RenderLayer::needsRendering(float zoom) const {
     return passes != RenderPass::None
-           && baseImpl.visibility != style::VisibilityType::None
-           && baseImpl.minZoom <= zoom
-           && baseImpl.maxZoom >= zoom;
+           && baseImpl->visibility != style::VisibilityType::None
+           && baseImpl->minZoom <= zoom
+           && baseImpl->maxZoom >= zoom;
 }
 
 } // namespace mbgl
\ No newline at end of file
diff --git a/src/mbgl/renderer/render_layer.hpp b/src/mbgl/renderer/render_layer.hpp
index eea2ec1f61..a877405564 100644
--- a/src/mbgl/renderer/render_layer.hpp
+++ b/src/mbgl/renderer/render_layer.hpp
@@ -16,14 +16,12 @@ class CascadeParameters;
 class PropertyEvaluationParameters;
 
 class RenderLayer {
-
 protected:
-    RenderLayer(style::LayerType, const style::Layer::Impl&);
+    RenderLayer(style::LayerType, Immutable<style::Layer::Impl>);
 
     const style::LayerType type;
 
 public:
-
     virtual ~RenderLayer() = default;
 
     // Create an identical copy of this layer.
@@ -73,11 +71,12 @@ public:
     virtual std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const = 0;
 
     // Private implementation
-    const style::Layer::Impl& baseImpl;
+    Immutable<style::Layer::Impl> baseImpl;
+    void setImpl(Immutable<style::Layer::Impl>);
 
     friend std::string layoutKey(const RenderLayer&);
-protected:
 
+protected:
     // Stores what render passes this layer is currently enabled for. This depends on the
     // evaluated StyleProperties object and is updated accordingly.
     RenderPass passes = RenderPass::None;
diff --git a/src/mbgl/renderer/render_light.cpp b/src/mbgl/renderer/render_light.cpp
index 134e1829e0..1fc346fd26 100644
--- a/src/mbgl/renderer/render_light.cpp
+++ b/src/mbgl/renderer/render_light.cpp
@@ -2,17 +2,8 @@
 
 namespace mbgl {
 
-RenderLight::RenderLight(std::shared_ptr<const style::Light::Impl> impl_)
-        : impl(std::move(impl_)) {
-}
-
-RenderLight::RenderLight(std::shared_ptr<const style::Light::Impl> impl_, const TransitioningLight transitioning_)
-        : impl(std::move(impl_))
-        , transitioning(transitioning_) {
-}
-
-std::unique_ptr<RenderLight> RenderLight::copy(std::shared_ptr<const style::Light::Impl> impl_) const {
-    return std::make_unique<RenderLight>(std::move(impl_), transitioning);
+RenderLight::RenderLight(Immutable<style::Light::Impl> impl_)
+    : impl(std::move(impl_)) {
 }
 
 void RenderLight::transition(const CascadeParameters& parameters) {
diff --git a/src/mbgl/renderer/render_light.hpp b/src/mbgl/renderer/render_light.hpp
index 275f3ae8ba..ed8d8bf59c 100644
--- a/src/mbgl/renderer/render_light.hpp
+++ b/src/mbgl/renderer/render_light.hpp
@@ -74,14 +74,7 @@ using EvaluatedLight     = Evaluated<style::LightProperties>;
 
 class RenderLight {
 public:
-    RenderLight(std::shared_ptr<const style::Light::Impl>);
-
-    // Creates a copy intitalized with previous transitioning light
-    RenderLight(std::shared_ptr<const style::Light::Impl>, const TransitioningLight);
-
-    // creates a copy initialized with previous transitioning
-    // values
-    std::unique_ptr<RenderLight> copy(std::shared_ptr<const style::Light::Impl>) const;
+    RenderLight(Immutable<style::Light::Impl>);
 
     void transition(const CascadeParameters&);
     void evaluate(const PropertyEvaluationParameters&);
@@ -89,10 +82,9 @@ public:
 
     const EvaluatedLight& getEvaluated() const;
 
-    const std::shared_ptr<const style::Light::Impl> impl;
+    Immutable<style::Light::Impl> impl;
 
 private:
-
     TransitioningLight transitioning;
     EvaluatedLight evaluated;
 };
diff --git a/src/mbgl/renderer/render_line_layer.cpp b/src/mbgl/renderer/render_line_layer.cpp
index 06c2564516..6573118c3b 100644
--- a/src/mbgl/renderer/render_line_layer.cpp
+++ b/src/mbgl/renderer/render_line_layer.cpp
@@ -7,9 +7,12 @@
 
 namespace mbgl {
 
-RenderLineLayer::RenderLineLayer(const style::LineLayer::Impl& _impl)
-        : RenderLayer(style::LayerType::Line, _impl),
-          impl(&_impl) {
+RenderLineLayer::RenderLineLayer(Immutable<style::LineLayer::Impl> _impl)
+    : RenderLayer(style::LayerType::Line, _impl) {
+}
+
+const style::LineLayer::Impl& RenderLineLayer::impl() const {
+    return static_cast<const style::LineLayer::Impl&>(*baseImpl);
 }
 
 std::unique_ptr<RenderLayer> RenderLineLayer::clone() const {
@@ -17,11 +20,11 @@ std::unique_ptr<RenderLayer> RenderLineLayer::clone() const {
 }
 
 std::unique_ptr<Bucket> RenderLineLayer::createBucket(const BucketParameters& parameters, const std::vector<const RenderLayer*>& layers) const {
-    return std::make_unique<LineBucket>(parameters, layers, impl->layout);
+    return std::make_unique<LineBucket>(parameters, layers, impl().layout);
 }
 
 void RenderLineLayer::cascade(const CascadeParameters& parameters) {
-    unevaluated = impl->cascading.cascade(parameters, std::move(unevaluated));
+    unevaluated = impl().cascading.cascade(parameters, std::move(unevaluated));
 }
 
 void RenderLineLayer::evaluate(const PropertyEvaluationParameters& parameters) {
diff --git a/src/mbgl/renderer/render_line_layer.hpp b/src/mbgl/renderer/render_line_layer.hpp
index 6d6fecc227..dce4d07f18 100644
--- a/src/mbgl/renderer/render_line_layer.hpp
+++ b/src/mbgl/renderer/render_line_layer.hpp
@@ -8,8 +8,7 @@ namespace mbgl {
 
 class RenderLineLayer: public RenderLayer {
 public:
-
-    RenderLineLayer(const style::LineLayer::Impl&);
+    RenderLineLayer(Immutable<style::LineLayer::Impl>);
     ~RenderLineLayer() final = default;
 
     std::unique_ptr<RenderLayer> clone() const override;
@@ -31,14 +30,13 @@ public:
     style::LinePaintProperties::Unevaluated unevaluated;
     style::LinePaintProperties::Evaluated evaluated;
 
-    const style::LineLayer::Impl* const impl;
+    const style::LineLayer::Impl& impl() const;
 
     // Special case
     float dashLineWidth = 1;
 
 private:
     float getLineWidth(const GeometryTileFeature&, const float) const;
-
 };
 
 template <>
diff --git a/src/mbgl/renderer/render_raster_layer.cpp b/src/mbgl/renderer/render_raster_layer.cpp
index 5e664e6f58..2e79a785bc 100644
--- a/src/mbgl/renderer/render_raster_layer.cpp
+++ b/src/mbgl/renderer/render_raster_layer.cpp
@@ -4,9 +4,12 @@
 
 namespace mbgl {
 
-RenderRasterLayer::RenderRasterLayer(const style::RasterLayer::Impl& _impl)
-        : RenderLayer(style::LayerType::Raster, _impl),
-          impl(&_impl) {
+RenderRasterLayer::RenderRasterLayer(Immutable<style::RasterLayer::Impl> _impl)
+    : RenderLayer(style::LayerType::Raster, _impl) {
+}
+
+const style::RasterLayer::Impl& RenderRasterLayer::impl() const {
+    return static_cast<const style::RasterLayer::Impl&>(*baseImpl);
 }
 
 std::unique_ptr<RenderLayer> RenderRasterLayer::clone() const {
@@ -19,7 +22,7 @@ std::unique_ptr<Bucket> RenderRasterLayer::createBucket(const BucketParameters&,
 }
 
 void RenderRasterLayer::cascade(const CascadeParameters& parameters) {
-    unevaluated = impl->cascading.cascade(parameters, std::move(unevaluated));
+    unevaluated = impl().cascading.cascade(parameters, std::move(unevaluated));
 }
 
 void RenderRasterLayer::evaluate(const PropertyEvaluationParameters& parameters) {
diff --git a/src/mbgl/renderer/render_raster_layer.hpp b/src/mbgl/renderer/render_raster_layer.hpp
index 3ffeb8febf..f51d042d5f 100644
--- a/src/mbgl/renderer/render_raster_layer.hpp
+++ b/src/mbgl/renderer/render_raster_layer.hpp
@@ -8,8 +8,7 @@ namespace mbgl {
 
 class RenderRasterLayer: public RenderLayer {
 public:
-
-    RenderRasterLayer(const style::RasterLayer::Impl&);
+    RenderRasterLayer(Immutable<style::RasterLayer::Impl>);
     ~RenderRasterLayer() final = default;
 
     std::unique_ptr<RenderLayer> clone() const override;
@@ -24,7 +23,7 @@ public:
     style::RasterPaintProperties::Unevaluated unevaluated;
     style::RasterPaintProperties::Evaluated evaluated;
 
-    const style::RasterLayer::Impl* const impl;
+    const style::RasterLayer::Impl& impl() const;
 };
 
 template <>
diff --git a/src/mbgl/renderer/render_source.cpp b/src/mbgl/renderer/render_source.cpp
index 22043f9f3c..9eca54795a 100644
--- a/src/mbgl/renderer/render_source.cpp
+++ b/src/mbgl/renderer/render_source.cpp
@@ -6,7 +6,7 @@ namespace mbgl {
 
 static RenderSourceObserver nullObserver;
 
-RenderSource::RenderSource(const style::Source::Impl& impl)
+RenderSource::RenderSource(Immutable<style::Source::Impl> impl)
     : baseImpl(impl),
       observer(&nullObserver) {
 }
@@ -15,6 +15,10 @@ void RenderSource::setObserver(RenderSourceObserver* observer_) {
     observer = observer_;
 }
 
+void RenderSource::setImpl(Immutable<style::Source::Impl> impl) {
+    baseImpl = impl;
+}
+
 void RenderSource::onTileChanged(Tile& tile) {
     observer->onTileChanged(*this, tile.id);
 }
diff --git a/src/mbgl/renderer/render_source.hpp b/src/mbgl/renderer/render_source.hpp
index e682e4cd1a..178ee92f93 100644
--- a/src/mbgl/renderer/render_source.hpp
+++ b/src/mbgl/renderer/render_source.hpp
@@ -29,7 +29,7 @@ class ClipIDGenerator;
 
 class RenderSource : protected TileObserver {
 public:
-    RenderSource(const style::Source::Impl&);
+    RenderSource(Immutable<style::Source::Impl>);
     ~RenderSource() override = default;
 
     virtual bool isLoaded() const = 0;
@@ -71,7 +71,9 @@ public:
 
     void setObserver(RenderSourceObserver*);
 
-    const style::Source::Impl& baseImpl;
+    Immutable<style::Source::Impl> baseImpl;
+    void setImpl(Immutable<style::Source::Impl>);
+
     bool enabled = false;
 
 protected:
diff --git a/src/mbgl/renderer/render_symbol_layer.cpp b/src/mbgl/renderer/render_symbol_layer.cpp
index 30d769e032..7ea6190cb1 100644
--- a/src/mbgl/renderer/render_symbol_layer.cpp
+++ b/src/mbgl/renderer/render_symbol_layer.cpp
@@ -8,9 +8,12 @@
 
 namespace mbgl {
 
-RenderSymbolLayer::RenderSymbolLayer(const style::SymbolLayer::Impl& _impl)
-        : RenderLayer(style::LayerType::Symbol, _impl),
-          impl(&_impl) {
+RenderSymbolLayer::RenderSymbolLayer(Immutable<style::SymbolLayer::Impl> _impl)
+    : RenderLayer(style::LayerType::Symbol, _impl) {
+}
+
+const style::SymbolLayer::Impl& RenderSymbolLayer::impl() const {
+    return static_cast<const style::SymbolLayer::Impl&>(*baseImpl);
 }
 
 std::unique_ptr<RenderLayer> RenderSymbolLayer::clone() const {
@@ -35,7 +38,7 @@ std::unique_ptr<SymbolLayout> RenderSymbolLayer::createLayout(const BucketParame
 }
 
 void RenderSymbolLayer::cascade(const CascadeParameters& parameters) {
-    unevaluated = impl->cascading.cascade(parameters, std::move(unevaluated));
+    unevaluated = impl().cascading.cascade(parameters, std::move(unevaluated));
 }
 
 void RenderSymbolLayer::evaluate(const PropertyEvaluationParameters& parameters) {
diff --git a/src/mbgl/renderer/render_symbol_layer.hpp b/src/mbgl/renderer/render_symbol_layer.hpp
index 80ffd95a06..553deb8259 100644
--- a/src/mbgl/renderer/render_symbol_layer.hpp
+++ b/src/mbgl/renderer/render_symbol_layer.hpp
@@ -61,7 +61,7 @@ class GeometryTileLayer;
 
 class RenderSymbolLayer: public RenderLayer {
 public:
-    RenderSymbolLayer(const style::SymbolLayer::Impl&);
+    RenderSymbolLayer(Immutable<style::SymbolLayer::Impl>);
     ~RenderSymbolLayer() final = default;
 
     std::unique_ptr<RenderLayer> clone() const override;
@@ -87,7 +87,7 @@ public:
     float iconSize = 1.0f;
     float textSize = 16.0f;
 
-    const style::SymbolLayer::Impl* const impl;
+    const style::SymbolLayer::Impl& impl() const;
 };
 
 template <>
diff --git a/src/mbgl/renderer/sources/render_geojson_source.cpp b/src/mbgl/renderer/sources/render_geojson_source.cpp
index 2b1eeea73b..893f6a2ac6 100644
--- a/src/mbgl/renderer/sources/render_geojson_source.cpp
+++ b/src/mbgl/renderer/sources/render_geojson_source.cpp
@@ -9,12 +9,15 @@ namespace mbgl {
 
 using namespace style;
 
-RenderGeoJSONSource::RenderGeoJSONSource(const style::GeoJSONSource::Impl& impl_)
-    : RenderSource(impl_),
-      impl(impl_) {
+RenderGeoJSONSource::RenderGeoJSONSource(Immutable<style::GeoJSONSource::Impl> impl_)
+    : RenderSource(impl_) {
     tilePyramid.setObserver(this);
 }
 
+const style::GeoJSONSource::Impl& RenderGeoJSONSource::impl() const {
+    return static_cast<const style::GeoJSONSource::Impl&>(*baseImpl);
+}
+
 bool RenderGeoJSONSource::isLoaded() const {
     return tilePyramid.isLoaded();
 }
@@ -37,7 +40,7 @@ std::map<UnwrappedTileID, RenderTile>& RenderGeoJSONSource::getRenderTiles() {
 }
 
 void RenderGeoJSONSource::updateTiles(const TileParameters& parameters) {
-    GeoJSONData* data_ = impl.getData();
+    GeoJSONData* data_ = impl().getData();
 
     if (!data_) {
         return;
@@ -55,9 +58,9 @@ void RenderGeoJSONSource::updateTiles(const TileParameters& parameters) {
     tilePyramid.updateTiles(parameters,
                             SourceType::GeoJSON,
                             util::tileSize,
-                            impl.getZoomRange(),
+                            impl().getZoomRange(),
                             [&] (const OverscaledTileID& tileID) {
-                                return std::make_unique<GeoJSONTile>(tileID, impl.id, parameters, data->getTile(tileID.canonical));
+                                return std::make_unique<GeoJSONTile>(tileID, impl().id, parameters, data->getTile(tileID.canonical));
                             });
 }
 
diff --git a/src/mbgl/renderer/sources/render_geojson_source.hpp b/src/mbgl/renderer/sources/render_geojson_source.hpp
index 262ab29276..0f9379b9b6 100644
--- a/src/mbgl/renderer/sources/render_geojson_source.hpp
+++ b/src/mbgl/renderer/sources/render_geojson_source.hpp
@@ -12,7 +12,7 @@ class GeoJSONData;
 
 class RenderGeoJSONSource : public RenderSource {
 public:
-    RenderGeoJSONSource(const style::GeoJSONSource::Impl&);
+    RenderGeoJSONSource(Immutable<style::GeoJSONSource::Impl>);
 
     bool isLoaded() const final;
 
@@ -51,7 +51,8 @@ public:
     void dumpDebugLogs() const final;
 
 private:
-    const style::GeoJSONSource::Impl& impl;
+    const style::GeoJSONSource::Impl& impl() const;
+
     TilePyramid tilePyramid;
     style::GeoJSONData* data;
 };
diff --git a/src/mbgl/renderer/sources/render_raster_source.cpp b/src/mbgl/renderer/sources/render_raster_source.cpp
index c5a29eebf5..e2d641c4e4 100644
--- a/src/mbgl/renderer/sources/render_raster_source.cpp
+++ b/src/mbgl/renderer/sources/render_raster_source.cpp
@@ -6,12 +6,15 @@ namespace mbgl {
 
 using namespace style;
 
-RenderRasterSource::RenderRasterSource(const style::RasterSource::Impl& impl_)
-    : RenderSource(impl_),
-      impl(impl_) {
+RenderRasterSource::RenderRasterSource(Immutable<style::RasterSource::Impl> impl_)
+    : RenderSource(impl_) {
     tilePyramid.setObserver(this);
 }
 
+const style::RasterSource::Impl& RenderRasterSource::impl() const {
+    return static_cast<const style::RasterSource::Impl&>(*baseImpl);
+}
+
 bool RenderRasterSource::isLoaded() const {
     return tilePyramid.isLoaded();
 }
@@ -33,7 +36,7 @@ std::map<UnwrappedTileID, RenderTile>& RenderRasterSource::getRenderTiles() {
 }
 
 void RenderRasterSource::updateTiles(const TileParameters& parameters) {
-    optional<Tileset> tileset = impl.getTileset();
+    optional<Tileset> tileset = impl().getTileset();
 
     if (!tileset) {
         return;
@@ -46,7 +49,7 @@ void RenderRasterSource::updateTiles(const TileParameters& parameters) {
 
     tilePyramid.updateTiles(parameters,
                             SourceType::Raster,
-                            impl.getTileSize(),
+                            impl().getTileSize(),
                             tileset->zoomRange,
                             [&] (const OverscaledTileID& tileID) {
                                 return std::make_unique<RasterTile>(tileID, parameters, *tileset);
diff --git a/src/mbgl/renderer/sources/render_raster_source.hpp b/src/mbgl/renderer/sources/render_raster_source.hpp
index 5690ba80ea..9bf4436bc7 100644
--- a/src/mbgl/renderer/sources/render_raster_source.hpp
+++ b/src/mbgl/renderer/sources/render_raster_source.hpp
@@ -8,7 +8,7 @@ namespace mbgl {
 
 class RenderRasterSource : public RenderSource {
 public:
-    RenderRasterSource(const style::RasterSource::Impl&);
+    RenderRasterSource(Immutable<style::RasterSource::Impl>);
 
     bool isLoaded() const final;
 
@@ -47,7 +47,8 @@ public:
     void dumpDebugLogs() const final;
 
 private:
-    const style::RasterSource::Impl& impl;
+    const style::RasterSource::Impl& impl() const;
+
     TilePyramid tilePyramid;
     optional<std::vector<std::string>> tileURLTemplates;
 };
diff --git a/src/mbgl/renderer/sources/render_vector_source.cpp b/src/mbgl/renderer/sources/render_vector_source.cpp
index 0db4698a81..f88ca2beea 100644
--- a/src/mbgl/renderer/sources/render_vector_source.cpp
+++ b/src/mbgl/renderer/sources/render_vector_source.cpp
@@ -9,12 +9,15 @@ namespace mbgl {
 
 using namespace style;
 
-RenderVectorSource::RenderVectorSource(const style::VectorSource::Impl& impl_)
-    : RenderSource(impl_),
-      impl(impl_) {
+RenderVectorSource::RenderVectorSource(Immutable<style::VectorSource::Impl> impl_)
+    : RenderSource(impl_) {
     tilePyramid.setObserver(this);
 }
 
+const style::VectorSource::Impl& RenderVectorSource::impl() const {
+    return static_cast<const style::VectorSource::Impl&>(*baseImpl);
+}
+
 bool RenderVectorSource::isLoaded() const {
     return tilePyramid.isLoaded();
 }
@@ -37,7 +40,7 @@ std::map<UnwrappedTileID, RenderTile>& RenderVectorSource::getRenderTiles() {
 }
 
 void RenderVectorSource::updateTiles(const TileParameters& parameters) {
-    optional<Tileset> tileset = impl.getTileset();
+    optional<Tileset> tileset = impl().getTileset();
 
     if (!tileset) {
         return;
@@ -53,7 +56,7 @@ void RenderVectorSource::updateTiles(const TileParameters& parameters) {
                             util::tileSize,
                             tileset->zoomRange,
                             [&] (const OverscaledTileID& tileID) {
-                                return std::make_unique<VectorTile>(tileID, impl.id, parameters, *tileset);
+                                return std::make_unique<VectorTile>(tileID, impl().id, parameters, *tileset);
                             });
 }
 
diff --git a/src/mbgl/renderer/sources/render_vector_source.hpp b/src/mbgl/renderer/sources/render_vector_source.hpp
index 36d75e0982..b3704a1274 100644
--- a/src/mbgl/renderer/sources/render_vector_source.hpp
+++ b/src/mbgl/renderer/sources/render_vector_source.hpp
@@ -8,7 +8,7 @@ namespace mbgl {
 
 class RenderVectorSource : public RenderSource {
 public:
-    RenderVectorSource(const style::VectorSource::Impl&);
+    RenderVectorSource(Immutable<style::VectorSource::Impl>);
 
     bool isLoaded() const final;
 
@@ -47,7 +47,8 @@ public:
     void dumpDebugLogs() const final;
 
 private:
-    const style::VectorSource::Impl& impl;
+    const style::VectorSource::Impl& impl() const;
+
     TilePyramid tilePyramid;
     optional<std::vector<std::string>> tileURLTemplates;
 };
diff --git a/src/mbgl/renderer/style_diff.cpp b/src/mbgl/renderer/style_diff.cpp
new file mode 100644
index 0000000000..12000069ea
--- /dev/null
+++ b/src/mbgl/renderer/style_diff.cpp
@@ -0,0 +1,56 @@
+#include <mbgl/renderer/style_diff.hpp>
+#include <mbgl/style/layer_impl.hpp>
+#include <mbgl/util/immutable.hpp>
+#include <mbgl/util/variant.hpp>
+#include <mbgl/util/longest_common_subsequence.hpp>
+
+namespace mbgl {
+
+template <class T>
+StyleDifference<T> diff(const std::vector<T>& a, const std::vector<T>& b) {
+    std::vector<T> lcs;
+
+    auto eq = [] (const T& lhs, const T& rhs) {
+        return std::tie(lhs->id, lhs->type)
+            == std::tie(rhs->id, rhs->type);
+    };
+
+    longest_common_subsequence(a.begin(), a.end(), b.begin(), b.end(), std::back_inserter(lcs), eq);
+
+    auto aIt = a.begin();
+    auto bIt = b.begin();
+    auto lIt = lcs.begin();
+
+    StyleDifference<T> result;
+
+    while (aIt != a.end() || bIt != b.end()) {
+        if (aIt != a.end() && (lIt == lcs.end() || !eq(*lIt, *aIt))) {
+            result.removed.emplace((*aIt)->id, *aIt);
+            aIt++;
+        } else if (bIt != b.end() && (lIt == lcs.end() || !eq(*lIt, *bIt))) {
+            result.added.emplace((*bIt)->id, *bIt);
+            bIt++;
+        } else {
+            if (aIt->get() != bIt->get()) {
+                result.changed.emplace((*bIt)->id, *bIt);
+            }
+            aIt++;
+            bIt++;
+            lIt++;
+        }
+    }
+
+    return result;
+}
+
+SourceDifference diffSources(const std::vector<ImmutableSource>& a,
+                             const std::vector<ImmutableSource>& b) {
+    return diff(a, b);
+}
+
+LayerDifference diffLayers(const std::vector<ImmutableLayer>& a,
+                           const std::vector<ImmutableLayer>& b) {
+    return diff(a, b);
+}
+
+} // namespace mbgl
diff --git a/src/mbgl/renderer/style_diff.hpp b/src/mbgl/renderer/style_diff.hpp
new file mode 100644
index 0000000000..dc2ef95c6c
--- /dev/null
+++ b/src/mbgl/renderer/style_diff.hpp
@@ -0,0 +1,30 @@
+#include <mbgl/style/source_impl.hpp>
+#include <mbgl/style/layer_impl.hpp>
+#include <mbgl/util/immutable.hpp>
+#include <mbgl/util/variant.hpp>
+
+#include <unordered_map>
+
+namespace mbgl {
+
+template <class T>
+class StyleDifference {
+public:
+    std::unordered_map<std::string, T> added;
+    std::unordered_map<std::string, T> removed;
+    std::unordered_map<std::string, T> changed;
+};
+
+using ImmutableSource = Immutable<style::Source::Impl>;
+using SourceDifference = StyleDifference<ImmutableSource>;
+
+SourceDifference diffSources(const std::vector<ImmutableSource>&,
+                             const std::vector<ImmutableSource>&);
+
+using ImmutableLayer = Immutable<style::Layer::Impl>;
+using LayerDifference = StyleDifference<ImmutableLayer>;
+
+LayerDifference diffLayers(const std::vector<ImmutableLayer>&,
+                           const std::vector<ImmutableLayer>&);
+
+} // namespace mbgl