Test setting rendering context after map is loadedupstream/alexshalamov_test_contextless_map

Quick prototype. Proper interface setting backend and backend
lifecycle observer should be implemented.

11 files changed, 70 insertions, 31 deletions

diff --git a/include/mbgl/renderer/renderer.hpp b/include/mbgl/renderer/renderer.hpp
index 91f2b6146c..89dc617b00 100644
--- a/include/mbgl/renderer/renderer.hpp
+++ b/include/mbgl/renderer/renderer.hpp
@@ -23,13 +23,17 @@ class RendererBackend;
 
 class Renderer {
 public:
-    Renderer(gfx::RendererBackend&, float pixelRatio_,
+    Renderer(gfx::RendererBackend*, float pixelRatio_,
              const optional<std::string> localFontFamily = {});
+
+    Renderer(float pixelRatio_, bool sharedContext = false);
+
     ~Renderer();
 
     void markContextLost();
 
     void setObserver(RendererObserver*);
+    void setRendererBackend(gfx::RendererBackend*);
 
     void render(const std::shared_ptr<UpdateParameters>&);
 
diff --git a/platform/default/src/mbgl/gfx/headless_frontend.cpp b/platform/default/src/mbgl/gfx/headless_frontend.cpp
index 996006bfe2..a580647913 100644
--- a/platform/default/src/mbgl/gfx/headless_frontend.cpp
+++ b/platform/default/src/mbgl/gfx/headless_frontend.cpp
@@ -45,7 +45,7 @@ HeadlessFrontend::HeadlessFrontend(Size size_,
               frameTime = (endTime - startTime).count();
           }
       }),
-      renderer(std::make_unique<Renderer>(*getBackend(), pixelRatio, localFontFamily)) {}
+      renderer(std::make_unique<Renderer>(getBackend(), pixelRatio, localFontFamily)) {}
 
 HeadlessFrontend::~HeadlessFrontend() = default;
 
diff --git a/platform/glfw/glfw_backend.hpp b/platform/glfw/glfw_backend.hpp
index 867e60d79e..df803b2fd4 100644
--- a/platform/glfw/glfw_backend.hpp
+++ b/platform/glfw/glfw_backend.hpp
@@ -22,7 +22,7 @@ public:
         return mbgl::gfx::Backend::Create<GLFWBackend, GLFWwindow*, bool>(window, capFrameRate);
     }
 
-    virtual mbgl::gfx::RendererBackend& getRendererBackend() = 0;
+    virtual mbgl::gfx::RendererBackend* getRendererBackend() = 0;
     virtual mbgl::Size getSize() const = 0;
     virtual void setSize(mbgl::Size) = 0;
 };
diff --git a/platform/glfw/glfw_gl_backend.hpp b/platform/glfw/glfw_gl_backend.hpp
index 5971bbd0c5..b7a8221d94 100644
--- a/platform/glfw/glfw_gl_backend.hpp
+++ b/platform/glfw/glfw_gl_backend.hpp
@@ -18,8 +18,8 @@ public:
 
     // GLFWRendererBackend implementation
 public:
-    mbgl::gfx::RendererBackend& getRendererBackend() override {
-        return *this;
+    mbgl::gfx::RendererBackend* getRendererBackend() override {
+        return this;
     }
     mbgl::Size getSize() const override;
     void setSize(mbgl::Size) override;
diff --git a/platform/glfw/glfw_renderer_frontend.cpp b/platform/glfw/glfw_renderer_frontend.cpp
index 46f1309901..41d365e52c 100644
--- a/platform/glfw/glfw_renderer_frontend.cpp
+++ b/platform/glfw/glfw_renderer_frontend.cpp
@@ -28,10 +28,11 @@ void GLFWRendererFrontend::update(std::shared_ptr<mbgl::UpdateParameters> params
 
 void GLFWRendererFrontend::render() {
     assert(renderer);
+    assert(glfwView.getRendererBackend());
     
     if (!updateParameters) return;
     
-    mbgl::gfx::BackendScope guard { glfwView.getRendererBackend(), mbgl::gfx::BackendScope::ScopeType::Implicit };
+    mbgl::gfx::BackendScope guard { *glfwView.getRendererBackend(), mbgl::gfx::BackendScope::ScopeType::Implicit };
 
     // onStyleImageMissing might be called during a render. The user implemented method
     // could trigger a call to MGLRenderFrontend#update which overwrites `updateParameters`.
diff --git a/platform/glfw/glfw_view.cpp b/platform/glfw/glfw_view.cpp
index 3d10f2c654..1992268d75 100644
--- a/platform/glfw/glfw_view.cpp
+++ b/platform/glfw/glfw_view.cpp
@@ -168,7 +168,7 @@ void GLFWView::setRenderFrontend(GLFWRendererFrontend* rendererFrontend_) {
     rendererFrontend = rendererFrontend_;
 }
 
-mbgl::gfx::RendererBackend& GLFWView::getRendererBackend() {
+mbgl::gfx::RendererBackend* GLFWView::getRendererBackend() {
     return backend->getRendererBackend();
 }
 
@@ -180,6 +180,9 @@ void GLFWView::onKey(GLFWwindow *window, int key, int /*scancode*/, int action,
             view->animateRouteCallback = nullptr;
 
         switch (key) {
+        case GLFW_KEY_V:
+            view->rendererFrontend->getRenderer()->setRendererBackend(view->getRendererBackend());
+            break;
         case GLFW_KEY_ESCAPE:
             glfwSetWindowShouldClose(window, true);
             break;
@@ -709,13 +712,14 @@ void GLFWView::run() {
 
             updateAnimatedAnnotations();
 
-            mbgl::gfx::BackendScope scope { backend->getRendererBackend() };
-
-            rendererFrontend->render();
+            if (backend->getRendererBackend()) {
+                mbgl::gfx::BackendScope scope { *backend->getRendererBackend() };
+                rendererFrontend->render();
 
-            report(1000 * (glfwGetTime() - started));
-            if (benchmark) {
-                invalidate();
+                report(1000 * (glfwGetTime() - started));
+                if (benchmark) {
+                    invalidate();
+                }
             }
 
         }
diff --git a/platform/glfw/glfw_view.hpp b/platform/glfw/glfw_view.hpp
index e9867f14da..fe1d94de91 100644
--- a/platform/glfw/glfw_view.hpp
+++ b/platform/glfw/glfw_view.hpp
@@ -27,7 +27,7 @@ public:
     
     void setRenderFrontend(GLFWRendererFrontend*);
 
-    mbgl::gfx::RendererBackend& getRendererBackend();
+    mbgl::gfx::RendererBackend* getRendererBackend();
 
     void setTestDirectory(std::string dir) { testDirectory = std::move(dir); };
 
diff --git a/platform/glfw/main.cpp b/platform/glfw/main.cpp
index ded8ee3e1f..140e534955 100644
--- a/platform/glfw/main.cpp
+++ b/platform/glfw/main.cpp
@@ -119,7 +119,7 @@ int main(int argc, char *argv[]) {
         }
     }
 
-    GLFWRendererFrontend rendererFrontend { std::make_unique<mbgl::Renderer>(view->getRendererBackend(), view->getPixelRatio()), *view };
+    GLFWRendererFrontend rendererFrontend { std::make_unique<mbgl::Renderer>(view->getPixelRatio()) , *view };
 
     mbgl::Map map(rendererFrontend, *view,
                   mbgl::MapOptions().withSize(view->getSize()).withPixelRatio(view->getPixelRatio()), resourceOptions);
diff --git a/src/mbgl/renderer/renderer.cpp b/src/mbgl/renderer/renderer.cpp
index 5afbbbd47e..ec694356de 100644
--- a/src/mbgl/renderer/renderer.cpp
+++ b/src/mbgl/renderer/renderer.cpp
@@ -8,14 +8,25 @@
 
 namespace mbgl {
 
-Renderer::Renderer(gfx::RendererBackend& backend, float pixelRatio_, const optional<std::string> localFontFamily_)
+Renderer::Renderer(gfx::RendererBackend* backend, float pixelRatio_, const optional<std::string> localFontFamily_)
     : impl(std::make_unique<Impl>(backend, pixelRatio_, localFontFamily_)) {}
 
+
+Renderer::Renderer(float pixelRatio, bool sharedContext)
+  : impl(std::make_unique<Impl>(pixelRatio, sharedContext)) {
+}
+
 Renderer::~Renderer() {
-    gfx::BackendScope guard { impl->backend };
+    gfx::BackendScope guard { *impl->backend };
     impl.reset();
 }
 
+void Renderer::setRendererBackend(gfx::RendererBackend* backend) {
+    assert(backend);
+    impl->setRendererBackend(backend);
+    impl->observer->onInvalidate();
+}
+
 void Renderer::markContextLost() {
     impl->orchestrator.markContextLost();
 }
@@ -29,7 +40,7 @@ void Renderer::render(const std::shared_ptr<UpdateParameters>& updateParameters)
     assert(updateParameters);
     if (auto renderTree = impl->orchestrator.createRenderTree(updateParameters)) {
         renderTree->prepare();
-        impl->render(*renderTree);
+        if (impl->backend) impl->render(*renderTree);
     }
 }
 
@@ -126,8 +137,10 @@ void Renderer::dumpDebugLogs() {
 }
 
 void Renderer::reduceMemoryUse() {
-    gfx::BackendScope guard { impl->backend };
-    impl->reduceMemoryUse();
+    if (impl->backend) {
+        gfx::BackendScope guard { *impl->backend };
+        impl->reduceMemoryUse();
+    }
     impl->orchestrator.reduceMemoryUse();
 }
 
diff --git a/src/mbgl/renderer/renderer_impl.cpp b/src/mbgl/renderer/renderer_impl.cpp
index 113840d059..46a5ea7a5d 100644
--- a/src/mbgl/renderer/renderer_impl.cpp
+++ b/src/mbgl/renderer/renderer_impl.cpp
@@ -24,16 +24,24 @@ static RendererObserver& nullObserver() {
     return observer;
 }
 
-Renderer::Impl::Impl(gfx::RendererBackend& backend_,
+Renderer::Impl::Impl(gfx::RendererBackend* backend_,
                      float pixelRatio_,
                      optional<std::string> localFontFamily_)
-    : orchestrator(!backend_.contextIsShared(), std::move(localFontFamily_))
+    : orchestrator(!backend_->contextIsShared(), std::move(localFontFamily_))
     , backend(backend_)
     , observer(&nullObserver())
     , pixelRatio(pixelRatio_) {
 
 }
 
+Renderer::Impl::Impl(float pixelRatio_,
+                     bool sharedContext)
+    : orchestrator(sharedContext, nullopt)
+    , backend(nullptr)
+    , observer(&nullObserver())
+    , pixelRatio(pixelRatio_) {
+}
+
 Renderer::Impl::~Impl() {
     assert(gfx::BackendScope::exists());
 };
@@ -43,6 +51,7 @@ void Renderer::Impl::setObserver(RendererObserver* observer_) {
 }
 
 void Renderer::Impl::render(const RenderTree& renderTree) {
+    assert(backend);
     if (renderState == RenderState::Never) {
         observer->onWillStartRenderingMap();
     }
@@ -51,19 +60,19 @@ void Renderer::Impl::render(const RenderTree& renderTree) {
     const auto& renderTreeParameters = renderTree.getParameters();
 
     if (!staticData) {
-        staticData = std::make_unique<RenderStaticData>(backend.getContext(), pixelRatio);
+        staticData = std::make_unique<RenderStaticData>(backend->getContext(), pixelRatio);
     }
     staticData->has3D = renderTreeParameters.has3D;
 
-    auto& context = backend.getContext();
+    auto& context = backend->getContext();
 
     // Blocks execution until the renderable is available.
-    backend.getDefaultRenderable().wait();
+    backend->getDefaultRenderable().wait();
 
     PaintParameters parameters {
         context,
         pixelRatio,
-        backend,
+        *backend,
         renderTreeParameters.light,
         renderTreeParameters.mapMode,
         renderTreeParameters.debugOptions,
@@ -130,7 +139,7 @@ void Renderer::Impl::render(const RenderTree& renderTree) {
         optional<Color> color;
         if (parameters.debugOptions & MapDebugOptions::Overdraw) {
             color = Color::black();
-        } else if (!backend.contextIsShared()) {
+        } else if (!backend->contextIsShared()) {
             color = renderTreeParameters.backgroundColor;
         }
         parameters.renderPass = parameters.encoder->createRenderPass("main buffer", { parameters.backend.getDefaultRenderable(), color, 1, 0 });
@@ -223,8 +232,10 @@ void Renderer::Impl::render(const RenderTree& renderTree) {
 }
 
 void Renderer::Impl::reduceMemoryUse() {
-    assert(gfx::BackendScope::exists());
-    backend.getContext().reduceMemoryUsage();
+    if (backend) {
+        assert(gfx::BackendScope::exists());
+        backend->getContext().reduceMemoryUsage();
+    }
 }
 
 } // namespace mbgl
diff --git a/src/mbgl/renderer/renderer_impl.hpp b/src/mbgl/renderer/renderer_impl.hpp
index 5f04bfdfed..0c46f4ce83 100644
--- a/src/mbgl/renderer/renderer_impl.hpp
+++ b/src/mbgl/renderer/renderer_impl.hpp
@@ -17,9 +17,13 @@ class RendererBackend;
 
 class Renderer::Impl {
 public:
-    Impl(gfx::RendererBackend&,
+    Impl(gfx::RendererBackend*,
          float pixelRatio_,
          optional<std::string> localFontFamily_);
+
+    Impl(float pixelRatio_,
+         bool sharedContext);
+
     ~Impl();
 
 private:
@@ -27,6 +31,8 @@ private:
 
     void setObserver(RendererObserver*);
 
+    void setRendererBackend(gfx::RendererBackend* backend_) { backend = backend_; }
+
     void render(const RenderTree&);
 
     void reduceMemoryUse();
@@ -34,7 +40,7 @@ private:
     // TODO: Move orchestrator to Map::Impl.
     RenderOrchestrator orchestrator;
 
-    gfx::RendererBackend& backend;
+    gfx::RendererBackend* backend;
 
     RendererObserver* observer;