7 files changed, 202 insertions, 107 deletions

diff --git a/platform/default/mbgl/gl/headless_backend.cpp b/platform/default/mbgl/gl/headless_backend.cpp
index d2fbf4e4c7..edf637a560 100644
--- a/platform/default/mbgl/gl/headless_backend.cpp
+++ b/platform/default/mbgl/gl/headless_backend.cpp
@@ -1,7 +1,7 @@
 #include <mbgl/gl/headless_backend.hpp>
 #include <mbgl/gl/headless_display.hpp>
 #include <mbgl/gl/context.hpp>
-#include <mbgl/map/backend_scope.hpp>
+#include <mbgl/renderer/backend_scope.hpp>
 
 #include <cassert>
 #include <stdexcept>
@@ -9,15 +9,26 @@
 
 namespace mbgl {
 
-HeadlessBackend::HeadlessBackend() {
-}
+class HeadlessBackend::View {
+public:
+    View(gl::Context& context, Size size_)
+        : color(context.createRenderbuffer<gl::RenderbufferType::RGBA>(size_)),
+          depthStencil(context.createRenderbuffer<gl::RenderbufferType::DepthStencil>(size_)),
+          framebuffer(context.createFramebuffer(color, depthStencil)) {
+    }
+
+    gl::Renderbuffer<gl::RenderbufferType::RGBA> color;
+    gl::Renderbuffer<gl::RenderbufferType::DepthStencil> depthStencil;
+    gl::Framebuffer framebuffer;
+};
 
-HeadlessBackend::HeadlessBackend(std::shared_ptr<HeadlessDisplay> display_)
-        : display(std::move(display_)) {
+HeadlessBackend::HeadlessBackend(Size size_)
+    : size(size_) {
 }
 
 HeadlessBackend::~HeadlessBackend() {
-    BackendScope scope(*this);
+    BackendScope guard { *this };
+    view.reset();
     context.reset();
 }
 
@@ -41,12 +52,33 @@ void HeadlessBackend::deactivate() {
     active = false;
 }
 
+void HeadlessBackend::bind() {
+    gl::Context& context_ = getContext();
+
+    if (!view) {
+        view = std::make_unique<View>(context_, size);
+    }
+
+    context_.bindFramebuffer = view->framebuffer.framebuffer;
+    context_.scissorTest = false;
+    context_.viewport = { 0, 0, size };
+}
+
+Size HeadlessBackend::getFramebufferSize() const {
+    return size;
+}
+
 void HeadlessBackend::updateAssumedState() {
     // no-op
 }
 
-void HeadlessBackend::invalidate() {
-    assert(false);
+void HeadlessBackend::setSize(Size size_) {
+    size = size_;
+    view.reset();
+}
+
+PremultipliedImage HeadlessBackend::readStillImage() {
+    return getContext().readFramebuffer<PremultipliedImage>(size);
 }
 
 } // namespace mbgl
diff --git a/platform/default/mbgl/gl/headless_backend.hpp b/platform/default/mbgl/gl/headless_backend.hpp
index 128b579bd2..66f861e213 100644
--- a/platform/default/mbgl/gl/headless_backend.hpp
+++ b/platform/default/mbgl/gl/headless_backend.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <mbgl/map/backend.hpp>
+#include <mbgl/renderer/renderer_backend.hpp>
 
 #include <memory>
 #include <functional>
@@ -9,18 +9,20 @@ namespace mbgl {
 
 class HeadlessDisplay;
 
-class HeadlessBackend : public Backend {
+class HeadlessBackend : public RendererBackend {
 public:
-    HeadlessBackend();
-    HeadlessBackend(std::shared_ptr<HeadlessDisplay>);
+    HeadlessBackend(Size = { 256, 256 });
     ~HeadlessBackend() override;
 
+    void bind() override;
+    Size getFramebufferSize() const override;
     void updateAssumedState() override;
 
-    void invalidate() override;
+    void setSize(Size);
+    PremultipliedImage readStillImage();
 
     struct Impl {
-        virtual ~Impl() {}
+        virtual ~Impl() = default;
         virtual void activateContext() = 0;
         virtual void deactivateContext() {}
     };
@@ -40,7 +42,12 @@ private:
     std::shared_ptr<HeadlessDisplay> display;
     std::unique_ptr<Impl> impl;
 
+    Size size;
+    float pixelRatio;
     bool active = false;
+
+    class View;
+    std::unique_ptr<View> view;
 };
 
 } // namespace mbgl
diff --git a/platform/default/mbgl/gl/headless_display.hpp b/platform/default/mbgl/gl/headless_display.hpp
index a5c95085b8..8c294655e5 100644
--- a/platform/default/mbgl/gl/headless_display.hpp
+++ b/platform/default/mbgl/gl/headless_display.hpp
@@ -6,13 +6,27 @@ namespace mbgl {
 
 class HeadlessDisplay {
 public:
-    HeadlessDisplay();
+    static std::shared_ptr<HeadlessDisplay> create() {
+        static std::weak_ptr<HeadlessDisplay> instance;
+        
+        auto shared = instance.lock();
+        
+        if (!shared) {
+            instance = shared = std::shared_ptr<HeadlessDisplay>(new HeadlessDisplay());
+        }
+        
+        return shared;
+    }
+
+    
     ~HeadlessDisplay();
 
     template <typename DisplayAttribute>
     DisplayAttribute attribute() const;
 
 private:
+    HeadlessDisplay();
+    
     class Impl;
     std::unique_ptr<Impl>  impl;
 };
diff --git a/platform/default/mbgl/gl/headless_frontend.cpp b/platform/default/mbgl/gl/headless_frontend.cpp
new file mode 100644
index 0000000000..5d2932258a
--- /dev/null
+++ b/platform/default/mbgl/gl/headless_frontend.cpp
@@ -0,0 +1,86 @@
+#include <mbgl/gl/headless_frontend.hpp>
+#include <mbgl/renderer/renderer.hpp>
+#include <mbgl/map/map.hpp>
+#include <mbgl/util/run_loop.hpp>
+
+namespace mbgl {
+
+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, const optional<std::string> programCacheDir)
+    : size(size_),
+    pixelRatio(pixelRatio_),
+    backend({ static_cast<uint32_t>(size.width * pixelRatio),
+              static_cast<uint32_t>(size.height * pixelRatio) }),
+    asyncInvalidate([this] {
+        if (renderer && updateParameters) {
+            mbgl::BackendScope guard { backend };
+            renderer->render(*updateParameters);
+        }
+    }),
+    renderer(std::make_unique<Renderer>(backend, pixelRatio, fileSource, scheduler, GLContextMode::Unique, programCacheDir)) {
+}
+
+HeadlessFrontend::~HeadlessFrontend() = default;
+
+void HeadlessFrontend::reset() {
+    assert(renderer);
+    renderer.reset();
+}
+
+void HeadlessFrontend::update(std::shared_ptr<UpdateParameters> updateParameters_) {
+    updateParameters = updateParameters_;
+    asyncInvalidate.send();
+}
+
+void HeadlessFrontend::setObserver(RendererObserver& observer_) {
+    assert(renderer);
+    renderer->setObserver(&observer_);
+}
+
+Size HeadlessFrontend::getSize() const {
+    return size;
+}
+
+Renderer* HeadlessFrontend::getRenderer() {
+    assert(renderer);
+    return renderer.get();
+}
+
+RendererBackend* HeadlessFrontend::getBackend() {
+    return &backend;
+}
+
+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) });
+    }
+}
+
+PremultipliedImage HeadlessFrontend::readStillImage() {
+    return backend.readStillImage();
+}
+
+PremultipliedImage HeadlessFrontend::render(Map& map) {
+    PremultipliedImage result;
+
+    map.renderStill([&](std::exception_ptr error) {
+        if (error) {
+            std::rethrow_exception(error);
+        } else {
+            result = backend.readStillImage();
+        }
+    });
+
+    while (!result.valid()) {
+        util::RunLoop::Get()->runOnce();
+    }
+
+    return result;
+}
+
+} // namespace mbgl
diff --git a/platform/default/mbgl/gl/headless_frontend.hpp b/platform/default/mbgl/gl/headless_frontend.hpp
new file mode 100644
index 0000000000..33503bc13b
--- /dev/null
+++ b/platform/default/mbgl/gl/headless_frontend.hpp
@@ -0,0 +1,48 @@
+#pragma once
+
+#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>
+
+namespace mbgl {
+
+class FileSource;
+class Scheduler;
+class Renderer;
+class RendererBackend;
+class Map;
+
+class HeadlessFrontend : public RendererFrontend {
+public:
+    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;
+    void update(std::shared_ptr<UpdateParameters>) override;
+    void setObserver(RendererObserver&) override;
+
+    Size getSize() const;
+    void setSize(Size);
+
+    Renderer* getRenderer();
+    RendererBackend* getBackend();
+
+    PremultipliedImage readStillImage();
+    PremultipliedImage render(Map&);
+
+private:
+    Size size;
+    float pixelRatio;
+
+    HeadlessBackend backend;
+    util::AsyncTask asyncInvalidate;
+
+    std::unique_ptr<Renderer> renderer;
+    std::shared_ptr<UpdateParameters> updateParameters;
+};
+
+} // namespace mbgl
diff --git a/platform/default/mbgl/gl/offscreen_view.cpp b/platform/default/mbgl/gl/offscreen_view.cpp
deleted file mode 100644
index 5424e03c96..0000000000
--- a/platform/default/mbgl/gl/offscreen_view.cpp
+++ /dev/null
@@ -1,64 +0,0 @@
-#include <mbgl/gl/offscreen_view.hpp>
-#include <mbgl/gl/context.hpp>
-#include <mbgl/gl/framebuffer.hpp>
-#include <mbgl/gl/renderbuffer.hpp>
-#include <mbgl/util/optional.hpp>
-
-#include <cstring>
-#include <cassert>
-
-namespace mbgl {
-
-class OffscreenView::Impl {
-public:
-    Impl(gl::Context& context_, const Size size_) : context(context_), size(std::move(size_)) {
-        assert(!size.isEmpty());
-    }
-
-    void bind() {
-        if (!framebuffer) {
-            color = context.createRenderbuffer<gl::RenderbufferType::RGBA>(size);
-            depthStencil = context.createRenderbuffer<gl::RenderbufferType::DepthStencil>(size);
-            framebuffer = context.createFramebuffer(*color, *depthStencil);
-        } else {
-            context.bindFramebuffer = framebuffer->framebuffer;
-        }
-
-        context.viewport = { 0, 0, size };
-    }
-
-    PremultipliedImage readStillImage() {
-        return context.readFramebuffer<PremultipliedImage>(size);
-    }
-
-    const Size& getSize() const {
-        return size;
-    }
-
-private:
-    gl::Context& context;
-    const Size size;
-    optional<gl::Framebuffer> framebuffer;
-    optional<gl::Renderbuffer<gl::RenderbufferType::RGBA>> color;
-    optional<gl::Renderbuffer<gl::RenderbufferType::DepthStencil>> depthStencil;
-};
-
-OffscreenView::OffscreenView(gl::Context& context, const Size size)
-    : impl(std::make_unique<Impl>(context, std::move(size))) {
-}
-
-OffscreenView::~OffscreenView() = default;
-
-void OffscreenView::bind() {
-    impl->bind();
-}
-
-PremultipliedImage OffscreenView::readStillImage() {
-    return impl->readStillImage();
-}
-
-const Size& OffscreenView::getSize() const {
-    return impl->getSize();
-}
-
-} // namespace mbgl
diff --git a/platform/default/mbgl/gl/offscreen_view.hpp b/platform/default/mbgl/gl/offscreen_view.hpp
deleted file mode 100644
index bf1a9889cd..0000000000
--- a/platform/default/mbgl/gl/offscreen_view.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-#pragma once
-
-#include <mbgl/map/view.hpp>
-#include <mbgl/util/image.hpp>
-
-namespace mbgl {
-
-namespace gl {
-class Context;
-} // namespace gl
-
-class OffscreenView : public View {
-public:
-    OffscreenView(gl::Context&, Size size = { 256, 256 });
-    ~OffscreenView();
-
-    void bind() override;
-
-    PremultipliedImage readStillImage();
-
-    const Size& getSize() const;
-
-private:
-    class Impl;
-    const std::unique_ptr<Impl> impl;
-};
-
-} // namespace mbgl