7 files changed, 78 insertions, 39 deletions
diff --git a/platform/default/include/mbgl/gfx/headless_backend.hpp b/platform/default/include/mbgl/gfx/headless_backend.hpp
new file mode 100644
index 0000000000..de9283dcdf
--- /dev/null
+++ b/platform/default/include/mbgl/gfx/headless_backend.hpp
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <mbgl/gfx/renderable.hpp>
+#include <mbgl/gfx/renderer_backend.hpp>
+#include <mbgl/util/image.hpp>
+
+#include <memory>
+
+namespace mbgl {
+namespace gfx {
+
+// Common headless backend interface, provides HeadlessBackend backend factory
+// and enables extending gfx::Renderable with platform specific implementation
+// of readStillImage.
+class HeadlessBackend : public gfx::Renderable {
+public:
+    // Factory.
+    static std::unique_ptr<HeadlessBackend> make(Size = { 256, 256 }, gfx::ContextMode = gfx::ContextMode::Unique);
+    
+    virtual PremultipliedImage readStillImage() = 0;
+    virtual RendererBackend* getRendererBackend() = 0;
+    void setSize(Size);
+
+protected:
+    HeadlessBackend(Size);
+};
+
+} // namespace gfx
+} // namespace mbgl
diff --git a/platform/default/include/mbgl/gl/headless_frontend.hpp b/platform/default/include/mbgl/gfx/headless_frontend.hpp
index 1e693bdef1..7f937b34b8 100644
--- a/platform/default/include/mbgl/gl/headless_frontend.hpp
+++ b/platform/default/include/mbgl/gfx/headless_frontend.hpp
@@ -2,7 +2,7 @@
 
 #include <mbgl/map/camera.hpp>
 #include <mbgl/renderer/renderer_frontend.hpp>
-#include <mbgl/gl/headless_backend.hpp>
+#include <mbgl/gfx/headless_backend.hpp>
 #include <mbgl/util/async_task.hpp>
 #include <mbgl/util/optional.hpp>
 
@@ -14,10 +14,6 @@ class Renderer;
 class Map;
 class TransformState;
 
-namespace gfx {
-class RendererBackend;
-} // namespace gfx
-
 class HeadlessFrontend : public RendererFrontend {
 public:
     HeadlessFrontend(float pixelRatio_,
@@ -58,7 +54,7 @@ private:
     Size size;
     float pixelRatio;
 
-    gl::HeadlessBackend backend;
+    std::unique_ptr<gfx::HeadlessBackend> backend;
     util::AsyncTask asyncInvalidate;
 
     std::unique_ptr<Renderer> renderer;
diff --git a/platform/default/include/mbgl/gl/headless_backend.hpp b/platform/default/include/mbgl/gl/headless_backend.hpp
index b2141e9540..8aefb5ff6c 100644
--- a/platform/default/include/mbgl/gl/headless_backend.hpp
+++ b/platform/default/include/mbgl/gl/headless_backend.hpp
@@ -1,26 +1,21 @@
 #pragma once
 
-#include <mbgl/gfx/renderable.hpp>
+#include <mbgl/gfx/headless_backend.hpp>
 #include <mbgl/gl/renderer_backend.hpp>
-
 #include <memory>
 #include <functional>
 
 namespace mbgl {
 namespace gl {
 
-class HeadlessBackend final : public gl::RendererBackend, public gfx::Renderable {
+class HeadlessBackend final : public gl::RendererBackend, public gfx::HeadlessBackend {
 public:
     HeadlessBackend(Size = { 256, 256 }, gfx::ContextMode = gfx::ContextMode::Unique);
     ~HeadlessBackend() override;
-
-    gfx::Renderable& getDefaultRenderable() override;
-
-    Size getFramebufferSize() const;
     void updateAssumedState() override;
-
-    void setSize(Size);
-    PremultipliedImage readStillImage();
+    gfx::Renderable& getDefaultRenderable() override;
+    PremultipliedImage readStillImage() override;
+    RendererBackend* getRendererBackend() override;
 
     class Impl {
     public:
@@ -41,8 +36,6 @@ private:
 
 private:
     std::unique_ptr<Impl> impl;
-
-    float pixelRatio;
     bool active = false;
 };
 
diff --git a/platform/default/src/mbgl/gfx/headless_backend.cpp b/platform/default/src/mbgl/gfx/headless_backend.cpp
new file mode 100644
index 0000000000..f3eded8dcb
--- /dev/null
+++ b/platform/default/src/mbgl/gfx/headless_backend.cpp
@@ -0,0 +1,16 @@
+#include <mbgl/gfx/headless_backend.hpp>
+
+namespace mbgl {
+namespace gfx {
+
+HeadlessBackend::HeadlessBackend(Size size_)
+    : mbgl::gfx::Renderable(size_, nullptr) {
+}
+
+void HeadlessBackend::setSize(Size size_) {
+    size = size_;
+    resource.reset();
+}
+
+} // namespace gfx
+} // namespace mbgl
diff --git a/platform/default/src/mbgl/gl/headless_frontend.cpp b/platform/default/src/mbgl/gfx/headless_frontend.cpp
index 101028b5c8..025abdd87a 100644
--- a/platform/default/src/mbgl/gl/headless_frontend.cpp
+++ b/platform/default/src/mbgl/gfx/headless_frontend.cpp
@@ -1,4 +1,4 @@
-#include <mbgl/gl/headless_frontend.hpp>
+#include <mbgl/gfx/headless_frontend.hpp>
 #include <mbgl/gfx/backend_scope.hpp>
 #include <mbgl/renderer/renderer.hpp>
 #include <mbgl/renderer/renderer_state.hpp>
@@ -24,11 +24,11 @@ HeadlessFrontend::HeadlessFrontend(Size size_,
                                    const optional<std::string> localFontFamily)
     : size(size_),
     pixelRatio(pixelRatio_),
-    backend({ static_cast<uint32_t>(size.width * pixelRatio),
-              static_cast<uint32_t>(size.height * pixelRatio) }, contextMode),
+    backend(gfx::HeadlessBackend::make( { static_cast<uint32_t>(size.width * pixelRatio),
+                                          static_cast<uint32_t>(size.height * pixelRatio) }, contextMode)),
     asyncInvalidate([this] {
         if (renderer && updateParameters) {
-            gfx::BackendScope guard { backend };
+            gfx::BackendScope guard { *getBackend() };
 
             // onStyleImageMissing might be called during a render. The user implemented method
             // could trigger a call to MGLRenderFrontend#update which overwrites `updateParameters`.
@@ -38,7 +38,7 @@ HeadlessFrontend::HeadlessFrontend(Size size_,
             renderer->render(*updateParameters_);
         }
     }),
-    renderer(std::make_unique<Renderer>(backend, pixelRatio, programCacheDir, localFontFamily)) {
+    renderer(std::make_unique<Renderer>(*getBackend(), pixelRatio, programCacheDir, localFontFamily)) {
 }
 
 HeadlessFrontend::~HeadlessFrontend() = default;
@@ -68,7 +68,7 @@ Renderer* HeadlessFrontend::getRenderer() {
 }
 
 gfx::RendererBackend* HeadlessFrontend::getBackend() {
-    return &backend;
+    return backend->getRendererBackend();
 }
 
 CameraOptions HeadlessFrontend::getCameraOptions() {
@@ -121,13 +121,13 @@ LatLng HeadlessFrontend::latLngForPixel(const ScreenCoordinate& point) {
 void HeadlessFrontend::setSize(Size size_) {
     if (size != size_) {
         size = size_;
-        backend.setSize({ static_cast<uint32_t>(size_.width * pixelRatio),
-                          static_cast<uint32_t>(size_.height * pixelRatio) });
+        backend->setSize({ static_cast<uint32_t>(size_.width * pixelRatio),
+                           static_cast<uint32_t>(size_.height * pixelRatio) });
     }
 }
 
 PremultipliedImage HeadlessFrontend::readStillImage() {
-    return backend.readStillImage();
+    return backend->readStillImage();
 }
 
 PremultipliedImage HeadlessFrontend::render(Map& map) {
@@ -137,7 +137,7 @@ PremultipliedImage HeadlessFrontend::render(Map& map) {
         if (error) {
             std::rethrow_exception(error);
         } else {
-            result = backend.readStillImage();
+            result = backend->readStillImage();
         }
     });
 
diff --git a/platform/default/src/mbgl/gl/headless_backend.cpp b/platform/default/src/mbgl/gl/headless_backend.cpp
index 7362adcb9e..c81952fadc 100644
--- a/platform/default/src/mbgl/gl/headless_backend.cpp
+++ b/platform/default/src/mbgl/gl/headless_backend.cpp
@@ -32,7 +32,7 @@ public:
 };
 
 HeadlessBackend::HeadlessBackend(const Size size_, const gfx::ContextMode contextMode_)
-    : mbgl::gl::RendererBackend(contextMode_), mbgl::gfx::Renderable(size_, nullptr) {
+    : mbgl::gl::RendererBackend(contextMode_), mbgl::gfx::HeadlessBackend(size_) {
 }
 
 HeadlessBackend::~HeadlessBackend() {
@@ -72,22 +72,27 @@ gfx::Renderable& HeadlessBackend::getDefaultRenderable() {
     return *this;
 }
 
-Size HeadlessBackend::getFramebufferSize() const {
-    return size;
-}
-
 void HeadlessBackend::updateAssumedState() {
     // no-op
 }
 
-void HeadlessBackend::setSize(Size size_) {
-    size = size_;
-    resource.reset();
-}
-
 PremultipliedImage HeadlessBackend::readStillImage() {
     return static_cast<gl::Context&>(getContext()).readFramebuffer<PremultipliedImage>(size);
 }
+    
+RendererBackend* HeadlessBackend::getRendererBackend() {
+    return this;
+}
 
 } // namespace gl
+
+#ifndef OVERRIDE_HEADLESS_BACKEND_FACTORY
+// Default factory implementation.
+std::unique_ptr<gfx::HeadlessBackend> gfx::HeadlessBackend::make(Size size, gfx::ContextMode contextMode) {
+    return std::make_unique<gl::HeadlessBackend>(size, contextMode);
+}
+#endif
+
 } // namespace mbgl
+
+
diff --git a/platform/default/src/mbgl/map/map_snapshotter.cpp b/platform/default/src/mbgl/map/map_snapshotter.cpp
index 7bfa2462a0..f0b107e77e 100644
--- a/platform/default/src/mbgl/map/map_snapshotter.cpp
+++ b/platform/default/src/mbgl/map/map_snapshotter.cpp
@@ -1,7 +1,7 @@
 #include <mbgl/map/map_snapshotter.hpp>
 
 #include <mbgl/actor/actor_ref.hpp>
-#include <mbgl/gl/headless_frontend.hpp>
+#include <mbgl/gfx/headless_frontend.hpp>
 #include <mbgl/map/map.hpp>
 #include <mbgl/map/map_options.hpp>
 #include <mbgl/map/transform_state.hpp>