[ios,macos] refactor MGLMapViewImpl

7 files changed, 316 insertions, 199 deletions

diff --git a/platform/macos/src/MGLMapView+Impl.h b/platform/macos/src/MGLMapView+Impl.h
new file mode 100644
index 0000000000..19583c17e5
--- /dev/null
+++ b/platform/macos/src/MGLMapView+Impl.h
@@ -0,0 +1,43 @@
+#import <mbgl/gfx/renderer_backend.hpp>
+#import <mbgl/map/map_observer.hpp>
+#import <mbgl/util/image.hpp>
+
+@class MGLMapView;
+
+typedef struct _CGLContextObject* CGLContextObj;
+
+class MGLMapViewImpl : public mbgl::MapObserver {
+public:
+    static std::unique_ptr<MGLMapViewImpl> Create(MGLMapView*);
+
+    MGLMapViewImpl(MGLMapView*);
+    virtual ~MGLMapViewImpl() = default;
+
+    virtual mbgl::gfx::RendererBackend& getRendererBackend() = 0;
+
+    // We need a static image of what was rendered for printing.
+    virtual mbgl::PremultipliedImage readStillImage() = 0;
+
+    virtual CGLContextObj getCGLContextObj() {
+        return nullptr;
+    }
+
+    // mbgl::MapObserver implementation
+    void onCameraWillChange(mbgl::MapObserver::CameraChangeMode) override;
+    void onCameraIsChanging() override;
+    void onCameraDidChange(mbgl::MapObserver::CameraChangeMode) override;
+    void onWillStartLoadingMap() override;
+    void onDidFinishLoadingMap() override;
+    void onDidFailLoadingMap(mbgl::MapLoadError mapError, const std::string& what) override;
+    void onWillStartRenderingFrame() override;
+    void onDidFinishRenderingFrame(mbgl::MapObserver::RenderMode) override;
+    void onWillStartRenderingMap() override;
+    void onDidFinishRenderingMap(mbgl::MapObserver::RenderMode) override;
+    void onDidFinishLoadingStyle() override;
+    void onSourceChanged(mbgl::style::Source& source) override;
+    void onDidBecomeIdle() override;
+
+protected:
+    /// Cocoa map view that this adapter bridges to.
+    __weak MGLMapView *mapView = nullptr;
+};
diff --git a/platform/macos/src/MGLMapView+Impl.mm b/platform/macos/src/MGLMapView+Impl.mm
new file mode 100644
index 0000000000..7be5545671
--- /dev/null
+++ b/platform/macos/src/MGLMapView+Impl.mm
@@ -0,0 +1,96 @@
+#import "MGLMapView+Impl.h"
+#import "MGLMapView+OpenGL.h"
+#import "MGLStyle_Private.h"
+#import "NSBundle+MGLAdditions.h"
+
+#include <mbgl/map/map.hpp>
+#include <mbgl/style/style.hpp>
+
+std::unique_ptr<MGLMapViewImpl> MGLMapViewImpl::Create(MGLMapView* nativeView) {
+    return std::make_unique<MGLMapViewOpenGLImpl>(nativeView);
+}
+
+MGLMapViewImpl::MGLMapViewImpl(MGLMapView* nativeView_) : mapView(nativeView_) {
+}
+
+void MGLMapViewImpl::onCameraWillChange(mbgl::MapObserver::CameraChangeMode mode) {
+    bool animated = mode == mbgl::MapObserver::CameraChangeMode::Animated;
+    [mapView cameraWillChangeAnimated:animated];
+}
+
+void MGLMapViewImpl::onCameraIsChanging() {
+    [mapView cameraIsChanging];
+}
+
+void MGLMapViewImpl::onCameraDidChange(mbgl::MapObserver::CameraChangeMode mode) {
+    bool animated = mode == mbgl::MapObserver::CameraChangeMode::Animated;
+    [mapView cameraDidChangeAnimated:animated];
+}
+
+void MGLMapViewImpl::onWillStartLoadingMap() {
+    [mapView mapViewWillStartLoadingMap];
+}
+
+void MGLMapViewImpl::onDidFinishLoadingMap() {
+    [mapView mapViewDidFinishLoadingMap];
+}
+
+void MGLMapViewImpl::onDidFailLoadingMap(mbgl::MapLoadError mapError, const std::string& what) {
+    NSString *description;
+    MGLErrorCode code;
+    switch (mapError) {
+        case mbgl::MapLoadError::StyleParseError:
+            code = MGLErrorCodeParseStyleFailed;
+            description = NSLocalizedStringWithDefaultValue(@"PARSE_STYLE_FAILED_DESC", nil, nil, @"The map failed to load because the style is corrupted.", @"User-friendly error description");
+            break;
+        case mbgl::MapLoadError::StyleLoadError:
+            code = MGLErrorCodeLoadStyleFailed;
+            description = NSLocalizedStringWithDefaultValue(@"LOAD_STYLE_FAILED_DESC", nil, nil, @"The map failed to load because the style can't be loaded.", @"User-friendly error description");
+            break;
+        case mbgl::MapLoadError::NotFoundError:
+            code = MGLErrorCodeNotFound;
+            description = NSLocalizedStringWithDefaultValue(@"STYLE_NOT_FOUND_DESC", nil, nil, @"The map failed to load because the style can’t be found or is incompatible.", @"User-friendly error description");
+            break;
+        default:
+            code = MGLErrorCodeUnknown;
+            description = NSLocalizedStringWithDefaultValue(@"LOAD_MAP_FAILED_DESC", nil, nil, @"The map failed to load because an unknown error occurred.", @"User-friendly error description");
+    }
+    NSDictionary *userInfo = @{
+        NSLocalizedDescriptionKey: description,
+        NSLocalizedFailureReasonErrorKey: @(what.c_str()),
+    };
+    NSError *error = [NSError errorWithDomain:MGLErrorDomain code:code userInfo:userInfo];
+    [mapView mapViewDidFailLoadingMapWithError:error];
+}
+
+void MGLMapViewImpl::onWillStartRenderingFrame() {
+    [mapView mapViewWillStartRenderingFrame];
+}
+
+void MGLMapViewImpl::onDidFinishRenderingFrame(mbgl::MapObserver::RenderMode mode) {
+    bool fullyRendered = mode == mbgl::MapObserver::RenderMode::Full;
+    [mapView mapViewDidFinishRenderingFrameFullyRendered:fullyRendered];
+}
+
+void MGLMapViewImpl::onWillStartRenderingMap() {
+    [mapView mapViewWillStartRenderingMap];
+}
+
+void MGLMapViewImpl::onDidFinishRenderingMap(mbgl::MapObserver::RenderMode mode) {
+    bool fullyRendered = mode == mbgl::MapObserver::RenderMode::Full;
+    [mapView mapViewDidFinishRenderingMapFullyRendered:fullyRendered];
+}
+
+void MGLMapViewImpl::onDidBecomeIdle() {
+    [mapView mapViewDidBecomeIdle];
+}
+
+void MGLMapViewImpl::onDidFinishLoadingStyle() {
+    [mapView mapViewDidFinishLoadingStyle];
+}
+
+void MGLMapViewImpl::onSourceChanged(mbgl::style::Source& source) {
+    NSString *identifier = @(source.getID().c_str());
+    MGLSource * nativeSource = [mapView.style sourceWithIdentifier:identifier];
+    [mapView sourceDidChange:nativeSource];
+}
diff --git a/platform/macos/src/MGLMapView+OpenGL.h b/platform/macos/src/MGLMapView+OpenGL.h
new file mode 100644
index 0000000000..d4c6a448cd
--- /dev/null
+++ b/platform/macos/src/MGLMapView+OpenGL.h
@@ -0,0 +1,45 @@
+#import "MGLMapView+Impl.h"
+#import "MGLMapView_Private.h"
+
+#include <mbgl/gfx/renderable.hpp>
+#include <mbgl/gl/renderer_backend.hpp>
+
+/// Adapter responsible for bridging calls from mbgl to MGLMapView and Cocoa.
+class MGLMapViewOpenGLImpl final : public MGLMapViewImpl,
+                                   public mbgl::gl::RendererBackend,
+                                   public mbgl::gfx::Renderable {
+public:
+    MGLMapViewOpenGLImpl(MGLMapView*);
+    ~MGLMapViewOpenGLImpl() override = default;
+
+public:
+    void restoreFramebufferBinding();
+
+    // Implementation of mbgl::gfx::RendererBackend
+public:
+    mbgl::gfx::Renderable& getDefaultRenderable() override {
+        return *this;
+    }
+
+private:
+    void activate() override;
+    void deactivate() override;
+    // End implementation of mbgl::gfx::RendererBackend
+
+    // Implementation of mbgl::gl::RendererBackend
+public:
+    void updateAssumedState() override;
+
+private:
+    mbgl::gl::ProcAddress getExtensionFunctionPointer(const char* name) override;
+    // End implementation of mbgl::gl::Rendererbackend
+
+    // Implementation of MGLMapViewImpl
+public:
+    mbgl::gfx::RendererBackend& getRendererBackend() override {
+        return *this;
+    }
+
+    mbgl::PremultipliedImage readStillImage() override;
+    CGLContextObj getCGLContextObj() override;
+};
diff --git a/platform/macos/src/MGLMapView+OpenGL.mm b/platform/macos/src/MGLMapView+OpenGL.mm
new file mode 100644
index 0000000000..f6168a4b80
--- /dev/null
+++ b/platform/macos/src/MGLMapView+OpenGL.mm
@@ -0,0 +1,89 @@
+#import "MGLMapView+OpenGL.h"
+#import "MGLOpenGLLayer.h"
+
+#include <mbgl/gl/renderable_resource.hpp>
+
+#import <OpenGL/gl.h>
+
+class MGLMapViewOpenGLRenderableResource final : public mbgl::gl::RenderableResource {
+public:
+    MGLMapViewOpenGLRenderableResource(MGLMapViewOpenGLImpl& backend_) : backend(backend_) {
+    }
+
+    void bind() override {
+        backend.restoreFramebufferBinding();
+    }
+
+private:
+    MGLMapViewOpenGLImpl& backend;
+
+public:
+    // The current framebuffer of the NSOpenGLLayer we are painting to.
+    GLint fbo = 0;
+
+    // The reference counted count of activation calls
+    NSUInteger activationCount = 0;
+};
+
+MGLMapViewOpenGLImpl::MGLMapViewOpenGLImpl(MGLMapView* nativeView_)
+    : MGLMapViewImpl(nativeView_),
+      mbgl::gl::RendererBackend(mbgl::gfx::ContextMode::Unique),
+      mbgl::gfx::Renderable(mapView.framebufferSize,
+                            std::make_unique<MGLMapViewOpenGLRenderableResource>(*this)) {
+
+    // Install the OpenGL layer. Interface Builder’s synchronous drawing means
+    // we can’t display a map, so don’t even bother to have a map layer.
+    mapView.layer =
+        mapView.isTargetingInterfaceBuilder ? [CALayer layer] : [MGLOpenGLLayer layer];
+}
+
+mbgl::gl::ProcAddress MGLMapViewOpenGLImpl::getExtensionFunctionPointer(const char* name) {
+    static CFBundleRef framework = CFBundleGetBundleWithIdentifier(CFSTR("com.apple.opengl"));
+    if (!framework) {
+        throw std::runtime_error("Failed to load OpenGL framework.");
+    }
+
+    return reinterpret_cast<mbgl::gl::ProcAddress>(CFBundleGetFunctionPointerForName(
+        framework, (__bridge CFStringRef)[NSString stringWithUTF8String:name]));
+}
+
+void MGLMapViewOpenGLImpl::activate() {
+    auto& resource = getResource<MGLMapViewOpenGLRenderableResource>();
+    if (resource.activationCount++) {
+        return;
+    }
+
+    MGLOpenGLLayer* layer = (MGLOpenGLLayer*)mapView.layer;
+    [layer.openGLContext makeCurrentContext];
+}
+
+void MGLMapViewOpenGLImpl::deactivate() {
+    auto& resource = getResource<MGLMapViewOpenGLRenderableResource>();
+    if (--resource.activationCount) {
+        return;
+    }
+
+    [NSOpenGLContext clearCurrentContext];
+}
+
+void MGLMapViewOpenGLImpl::updateAssumedState() {
+    auto& resource = getResource<MGLMapViewOpenGLRenderableResource>();
+    glGetIntegerv(GL_FRAMEBUFFER_BINDING, &resource.fbo);
+    assumeFramebufferBinding(resource.fbo);
+    assumeViewport(0, 0, mapView.framebufferSize);
+}
+
+void MGLMapViewOpenGLImpl::restoreFramebufferBinding() {
+    auto& resource = getResource<MGLMapViewOpenGLRenderableResource>();
+    setFramebufferBinding(resource.fbo);
+    setViewport(0, 0, mapView.framebufferSize);
+}
+
+mbgl::PremultipliedImage MGLMapViewOpenGLImpl::readStillImage() {
+    return readFramebuffer(mapView.framebufferSize);
+}
+
+CGLContextObj MGLMapViewOpenGLImpl::getCGLContextObj() {
+    MGLOpenGLLayer* layer = (MGLOpenGLLayer*)mapView.layer;
+    return layer.openGLContext.CGLContextObj;
+}
diff --git a/platform/macos/src/MGLMapView.mm b/platform/macos/src/MGLMapView.mm
index 77eb300aef..589a39f0b3 100644
--- a/platform/macos/src/MGLMapView.mm
+++ b/platform/macos/src/MGLMapView.mm
@@ -2,7 +2,6 @@
 
 #import "MGLAttributionButton.h"
 #import "MGLCompassCell.h"
-#import "MGLOpenGLLayer.h"
 #import "MGLStyle.h"
 #import "MGLRendererFrontend.h"
 #import "MGLRendererConfiguration.h"
@@ -33,8 +32,6 @@
 #import <mbgl/storage/reachability.h>
 #import <mbgl/style/image.hpp>
 #import <mbgl/renderer/renderer.hpp>
-#import <mbgl/gl/renderer_backend.hpp>
-#import <mbgl/gl/renderable_resource.hpp>
 #import <mbgl/storage/network_status.hpp>
 #import <mbgl/storage/resource_options.hpp>
 #import <mbgl/math/wrap.hpp>
@@ -49,6 +46,7 @@
 #import <unordered_map>
 #import <unordered_set>
 
+#import "MGLMapView+Impl.h"
 #import "NSBundle+MGLAdditions.h"
 #import "NSDate+MGLAdditions.h"
 #import "NSProcessInfo+MGLAdditions.h"
@@ -60,10 +58,6 @@
 #import "NSPredicate+MGLPrivateAdditions.h"
 #import "MGLLoggingConfiguration_Private.h"
 
-#import <QuartzCore/QuartzCore.h>
-#import <OpenGL/gl.h>
-
-class MGLMapViewImpl;
 class MGLAnnotationContext;
 
 /// Distance from the edge of the view to ornament views (logo, attribution, etc.).
@@ -160,7 +154,7 @@ public:
 @implementation MGLMapView {
     /// Cross-platform map view controller.
     mbgl::Map *_mbglMap;
-    MGLMapViewImpl *_mbglView;
+    std::unique_ptr<MGLMapViewImpl> _mbglView;
     std::unique_ptr<MGLRenderFrontend> _rendererFrontend;
 
     NSPanGestureRecognizer *_panGestureRecognizer;
@@ -267,7 +261,7 @@ public:
     _isTargetingInterfaceBuilder = NSProcessInfo.processInfo.mgl_isInterfaceBuilderDesignablesAgent;
 
     // Set up cross-platform controllers and resources.
-    _mbglView = new MGLMapViewImpl(self);
+    _mbglView = MGLMapViewImpl::Create(self);
 
     // Delete the pre-offline ambient cache at
     // ~/Library/Caches/com.mapbox.MapboxGL/cache.db.
@@ -282,9 +276,9 @@ public:
 
     MGLRendererConfiguration *config = [MGLRendererConfiguration currentConfiguration];
 
-    auto renderer = std::make_unique<mbgl::Renderer>(*_mbglView, config.scaleFactor, config.cacheDir, config.localFontFamilyName);
+    auto renderer = std::make_unique<mbgl::Renderer>(_mbglView->getRendererBackend(), config.scaleFactor, config.cacheDir, config.localFontFamilyName);
     BOOL enableCrossSourceCollisions = !config.perSourceCollisions;
-    _rendererFrontend = std::make_unique<MGLRenderFrontend>(std::move(renderer), self, *_mbglView, true);
+    _rendererFrontend = std::make_unique<MGLRenderFrontend>(std::move(renderer), self, _mbglView->getRendererBackend(), true);
 
     mbgl::MapOptions mapOptions;
     mapOptions.withMapMode(mbgl::MapMode::Continuous)
@@ -300,10 +294,6 @@ public:
 
     _mbglMap = new mbgl::Map(*_rendererFrontend, *_mbglView, mapOptions, resourceOptions);
 
-    // Install the OpenGL layer. Interface Builder’s synchronous drawing means
-    // we can’t display a map, so don’t even bother to have a map layer.
-    self.layer = _isTargetingInterfaceBuilder ? [CALayer layer] : [MGLOpenGLLayer layer];
-
     // Notify map object when network reachability status changes.
     _reachability = [MGLReachability reachabilityForInternetConnection];
     _reachability.reachableBlock = ^(MGLReachability *) {
@@ -550,10 +540,7 @@ public:
         delete _mbglMap;
         _mbglMap = nullptr;
     }
-    if (_mbglView) {
-        delete _mbglView;
-        _mbglView = nullptr;
-    }
+    _mbglView.reset();
 }
 
 - (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(__unused NSDictionary *)change context:(void *)context {
@@ -718,8 +705,7 @@ public:
 }
 
 - (CGLContextObj)context {
-    MGLOpenGLLayer *layer = _isTargetingInterfaceBuilder ? nil : (MGLOpenGLLayer *)self.layer;
-    return layer.openGLContext.CGLContextObj;
+    return _mbglView->getCGLContextObj();
 }
 
 - (void)setFrame:(NSRect)frame {
@@ -820,7 +806,11 @@ public:
     }
 }
 
-- (void)setNeedsGLDisplay {
+- (BOOL)isTargetingInterfaceBuilder {
+    return _isTargetingInterfaceBuilder;
+}
+
+- (void)setNeedsRerender {
     MGLAssertIsMainThread();
 
     [self.layer setNeedsDisplay];
@@ -987,7 +977,7 @@ public:
 
 - (void)print:(__unused id)sender {
     _isPrinting = YES;
-    [self setNeedsGLDisplay];
+    [self setNeedsRerender];
 }
 
 - (void)printWithImage:(NSImage *)image {
@@ -3038,175 +3028,4 @@ public:
     _mbglMap->setDebug(options);
 }
 
-class MGLMapViewImpl;
-
-class MGLMapViewRenderable final : public mbgl::gl::RenderableResource {
-public:
-    MGLMapViewRenderable(MGLMapViewImpl& backend_) : backend(backend_) {
-    }
-
-    void bind() override;
-
-private:
-    MGLMapViewImpl& backend;
-};
-
-/// Adapter responsible for bridging calls from mbgl to MGLMapView and Cocoa.
-class MGLMapViewImpl : public mbgl::gl::RendererBackend,
-                       public mbgl::gfx::Renderable,
-                       public mbgl::MapObserver {
-public:
-    MGLMapViewImpl(MGLMapView* nativeView_)
-        : mbgl::gl::RendererBackend(mbgl::gfx::ContextMode::Unique),
-          mbgl::gfx::Renderable(nativeView_.framebufferSize,
-                                std::make_unique<MGLMapViewRenderable>(*this)),
-          nativeView(nativeView_) {
-    }
-
-    void onCameraWillChange(mbgl::MapObserver::CameraChangeMode mode) override {
-        bool animated = mode == mbgl::MapObserver::CameraChangeMode::Animated;
-        [nativeView cameraWillChangeAnimated:animated];
-    }
-
-    void onCameraIsChanging() override {
-        [nativeView cameraIsChanging];
-    }
-
-    void onCameraDidChange(mbgl::MapObserver::CameraChangeMode mode) override {
-        bool animated = mode == mbgl::MapObserver::CameraChangeMode::Animated;
-        [nativeView cameraDidChangeAnimated:animated];
-    }
-
-    void onWillStartLoadingMap() override {
-        [nativeView mapViewWillStartLoadingMap];
-    }
-
-    void onDidFinishLoadingMap() override {
-        [nativeView mapViewDidFinishLoadingMap];
-    }
-
-    void onDidFailLoadingMap(mbgl::MapLoadError mapError, const std::string& what) override {
-        NSString *description;
-        MGLErrorCode code;
-        switch (mapError) {
-            case mbgl::MapLoadError::StyleParseError:
-                code = MGLErrorCodeParseStyleFailed;
-                description = NSLocalizedStringWithDefaultValue(@"PARSE_STYLE_FAILED_DESC", nil, nil, @"The map failed to load because the style is corrupted.", @"User-friendly error description");
-                break;
-            case mbgl::MapLoadError::StyleLoadError:
-                code = MGLErrorCodeLoadStyleFailed;
-                description = NSLocalizedStringWithDefaultValue(@"LOAD_STYLE_FAILED_DESC", nil, nil, @"The map failed to load because the style can't be loaded.", @"User-friendly error description");
-                break;
-            case mbgl::MapLoadError::NotFoundError:
-                code = MGLErrorCodeNotFound;
-                description = NSLocalizedStringWithDefaultValue(@"STYLE_NOT_FOUND_DESC", nil, nil, @"The map failed to load because the style can’t be found or is incompatible.", @"User-friendly error description");
-                break;
-            default:
-                code = MGLErrorCodeUnknown;
-                description = NSLocalizedStringWithDefaultValue(@"LOAD_MAP_FAILED_DESC", nil, nil, @"The map failed to load because an unknown error occurred.", @"User-friendly error description");
-        }
-        NSDictionary *userInfo = @{
-            NSLocalizedDescriptionKey: description,
-            NSLocalizedFailureReasonErrorKey: @(what.c_str()),
-        };
-        NSError *error = [NSError errorWithDomain:MGLErrorDomain code:code userInfo:userInfo];
-        [nativeView mapViewDidFailLoadingMapWithError:error];
-    }
-
-    void onWillStartRenderingFrame() override {
-        [nativeView mapViewWillStartRenderingFrame];
-    }
-
-    void onDidFinishRenderingFrame(mbgl::MapObserver::RenderMode mode) override {
-        bool fullyRendered = mode == mbgl::MapObserver::RenderMode::Full;
-        [nativeView mapViewDidFinishRenderingFrameFullyRendered:fullyRendered];
-    }
-
-    void onWillStartRenderingMap() override {
-        [nativeView mapViewWillStartRenderingMap];
-    }
-
-    void onDidFinishRenderingMap(mbgl::MapObserver::RenderMode mode) override {
-        bool fullyRendered = mode == mbgl::MapObserver::RenderMode::Full;
-        [nativeView mapViewDidFinishRenderingMapFullyRendered:fullyRendered];
-    }
-    
-    void onDidBecomeIdle() override {
-        [nativeView mapViewDidBecomeIdle];
-    }
-
-    void onDidFinishLoadingStyle() override {
-        [nativeView mapViewDidFinishLoadingStyle];
-    }
-
-    void onSourceChanged(mbgl::style::Source& source) override {
-        NSString *identifier = @(source.getID().c_str());
-        MGLSource * nativeSource = [nativeView.style sourceWithIdentifier:identifier];
-        [nativeView sourceDidChange:nativeSource];
-    }
-
-    mbgl::gl::ProcAddress getExtensionFunctionPointer(const char* name) override {
-        static CFBundleRef framework = CFBundleGetBundleWithIdentifier(CFSTR("com.apple.opengl"));
-        if (!framework) {
-            throw std::runtime_error("Failed to load OpenGL framework.");
-        }
-
-        CFStringRef str = CFStringCreateWithCString(kCFAllocatorDefault, name, kCFStringEncodingASCII);
-        void *symbol = CFBundleGetFunctionPointerForName(framework, str);
-        CFRelease(str);
-
-        return reinterpret_cast<mbgl::gl::ProcAddress>(symbol);
-    }
-
-    mbgl::gfx::Renderable& getDefaultRenderable() override {
-        return *this;
-    }
-
-    void activate() override {
-        if (activationCount++) {
-            return;
-        }
-
-        MGLOpenGLLayer *layer = (MGLOpenGLLayer *)nativeView.layer;
-        [layer.openGLContext makeCurrentContext];
-    }
-
-    void deactivate() override {
-        if (--activationCount) {
-            return;
-        }
-
-        [NSOpenGLContext clearCurrentContext];
-    }
-
-    void updateAssumedState() override {
-        glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fbo);
-        assumeFramebufferBinding(fbo);
-        assumeViewport(0, 0, nativeView.framebufferSize);
-    }
-
-    void restoreFramebufferBinding() {
-        setFramebufferBinding(fbo);
-        setViewport(0, 0, nativeView.framebufferSize);
-    }
-
-    mbgl::PremultipliedImage readStillImage() {
-        return readFramebuffer(nativeView.framebufferSize);
-    }
-
-private:
-    /// Cocoa map view that this adapter bridges to.
-    __weak MGLMapView *nativeView = nullptr;
-
-    /// The current framebuffer of the NSOpenGLLayer we are painting to.
-    GLint fbo = 0;
-
-    /// The reference counted count of activation calls
-    NSUInteger activationCount = 0;
-};
-
-void MGLMapViewRenderable::bind() {
-    backend.restoreFramebufferBinding();
-}
-
 @end
diff --git a/platform/macos/src/MGLMapViewDelegate.h b/platform/macos/src/MGLMapViewDelegate.h
index c7d6786666..1de4b47eb7 100644
--- a/platform/macos/src/MGLMapViewDelegate.h
+++ b/platform/macos/src/MGLMapViewDelegate.h
@@ -181,6 +181,8 @@ NS_ASSUME_NONNULL_BEGIN
  */
 - (void)mapView:(MGLMapView *)mapView didFinishLoadingStyle:(MGLStyle *)style;
 
+- (nullable NSImage *)mapView:(MGLMapView *)mapView didFailToLoadImage:(NSString *)imageName;
+
 #pragma mark Managing the Appearance of Annotations
 
 /**
diff --git a/platform/macos/src/MGLMapView_Private.h b/platform/macos/src/MGLMapView_Private.h
index 986ae1143a..afd7cf2422 100644
--- a/platform/macos/src/MGLMapView_Private.h
+++ b/platform/macos/src/MGLMapView_Private.h
@@ -1,10 +1,14 @@
 #import "MGLMapView.h"
 
+#include <mbgl/util/size.hpp>
+
 namespace mbgl {
     class Map;
     class Renderer;
 }
 
+@class MGLSource;
+
 @interface MGLMapView (Private)
 
 /// True if the view or application is in a state where it is not expected to be
@@ -22,17 +26,36 @@ namespace mbgl {
 /// Center longitude set independently of the center latitude in an inspectable.
 @property (nonatomic) CLLocationDegrees pendingLongitude;
 
-/// The map view’s OpenGL rendering context.
-- (CGLContextObj)context;
+/// The map view’s OpenGL rendering context, if it is backed by an OpenGL based view.
+@property (readonly, nonatomic, nullable) CGLContextObj context;
+
+- (mbgl::Size)framebufferSize;
+
+/// Map observers
+- (void)cameraWillChangeAnimated:(BOOL)animated;
+- (void)cameraIsChanging;
+- (void)cameraDidChangeAnimated:(BOOL)animated;
+- (void)mapViewWillStartLoadingMap;
+- (void)mapViewDidFinishLoadingMap;
+- (void)mapViewDidFailLoadingMapWithError:(nonnull NSError *)error;
+- (void)mapViewWillStartRenderingFrame;
+- (void)mapViewDidFinishRenderingFrameFullyRendered:(BOOL)fullyRendered;
+- (void)mapViewWillStartRenderingMap;
+- (void)mapViewDidFinishRenderingMapFullyRendered:(BOOL)fullyRendered;
+- (void)mapViewDidBecomeIdle;
+- (void)mapViewDidFinishLoadingStyle;
+- (void)sourceDidChange:(nonnull MGLSource *)source;
 
 /// Asynchronously render a frame of the map.
-- (void)setNeedsGLDisplay;
+- (void)setNeedsRerender;
 
 /// Synchronously render a frame of the map.
 - (void)renderSync;
 
-- (mbgl::Map *)mbglMap;
+- (BOOL)isTargetingInterfaceBuilder;
+
+- (nonnull mbgl::Map *)mbglMap;
 
-- (mbgl::Renderer *)renderer;
+- (nonnull mbgl::Renderer *)renderer;
 
 @end