Manage resource and onscreen contexts using separate IOSGLContext objects (#12277)

Manage resource and onscreen contexts using separate IOSGLContext objects.

FlutterView owns the onscreen context, and PlatformViewIOS owns the resource context.

shell/platform/darwin/ios/framework/Source/FlutterOverlayView.h

@@ -24,8 +24,9 @@
 
 - (instancetype)init NS_DESIGNATED_INITIALIZER;
 - (instancetype)initWithContentsScale:(CGFloat)contentsScale;
-- (std::unique_ptr<flutter::IOSSurface>)createSurface:
-    (std::shared_ptr<flutter::IOSGLContext>)gl_context;
+- (std::unique_ptr<flutter::IOSSurface>)
+    createSurfaceWithOnscreenGLContext:(fml::WeakPtr<flutter::IOSGLContext>)onscreenGLContext
+                     resourceGLContext:(fml::WeakPtr<flutter::IOSGLContext>)resourceGLContext;
 
 @end
 

shell/platform/darwin/ios/framework/Source/FlutterOverlayView.mm

@@ -78,15 +78,17 @@
 #endif  // TARGET_IPHONE_SIMULATOR
 }
 
-- (std::unique_ptr<flutter::IOSSurface>)createSurface:
-    (std::shared_ptr<flutter::IOSGLContext>)gl_context {
+- (std::unique_ptr<flutter::IOSSurface>)
+    createSurfaceWithOnscreenGLContext:(fml::WeakPtr<flutter::IOSGLContext>)onscreenGLContext
+                     resourceGLContext:(fml::WeakPtr<flutter::IOSGLContext>)resourceGLContext {
   if ([self.layer isKindOfClass:[CAEAGLLayer class]]) {
     fml::scoped_nsobject<CAEAGLLayer> eagl_layer(
         reinterpret_cast<CAEAGLLayer*>([self.layer retain]));
     if (@available(iOS 9.0, *)) {
       eagl_layer.get().presentsWithTransaction = YES;
     }
-    return std::make_unique<flutter::IOSSurfaceGL>(std::move(eagl_layer), gl_context);
+    return std::make_unique<flutter::IOSSurfaceGL>(std::move(eagl_layer), onscreenGLContext,
+                                                   resourceGLContext);
 #if FLUTTER_SHELL_ENABLE_METAL
   } else if ([self.layer isKindOfClass:[CAMetalLayer class]]) {
     fml::scoped_nsobject<CAMetalLayer> metalLayer(

shell/platform/darwin/ios/framework/Source/FlutterPlatformViews.mm

@@ -362,12 +362,13 @@ void FlutterPlatformViewsController::Reset() {
 }
 
 bool FlutterPlatformViewsController::SubmitFrame(GrContext* gr_context,
-                                                 std::shared_ptr<IOSGLContext> gl_context) {
+                                                 fml::WeakPtr<IOSGLContext> onscreen_gl_context,
+                                                 fml::WeakPtr<IOSGLContext> resource_gl_context) {
   DisposeViews();
 
   bool did_submit = true;
   for (int64_t view_id : composition_order_) {
-    EnsureOverlayInitialized(view_id, std::move(gl_context), gr_context);
+    EnsureOverlayInitialized(view_id, onscreen_gl_context, resource_gl_context, gr_context);
     auto frame = overlays_[view_id]->surface->AcquireFrame(frame_size_);
     SkCanvas* canvas = frame->SkiaCanvas();
     canvas->drawPicture(picture_recorders_[view_id]->finishRecordingAsPicture());
@@ -451,7 +452,8 @@ void FlutterPlatformViewsController::DisposeViews() {
 
 void FlutterPlatformViewsController::EnsureOverlayInitialized(
     int64_t overlay_id,
-    std::shared_ptr<IOSGLContext> gl_context,
+    fml::WeakPtr<IOSGLContext> onscreen_gl_context,
+    fml::WeakPtr<IOSGLContext> resource_gl_context,
     GrContext* gr_context) {
   FML_DCHECK(flutter_view_);
 
@@ -467,7 +469,9 @@ void FlutterPlatformViewsController::EnsureOverlayInitialized(
     overlay_view.get().frame = flutter_view_.get().bounds;
     overlay_view.get().autoresizingMask =
         (UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight);
-    std::unique_ptr<IOSSurface> ios_surface = [overlay_view.get() createSurface:nil];
+    std::unique_ptr<IOSSurface> ios_surface = [overlay_view.get()
+        createSurfaceWithOnscreenGLContext:fml::WeakPtr<flutter::IOSGLContext>()
+                         resourceGLContext:fml::WeakPtr<flutter::IOSGLContext>()];
     std::unique_ptr<Surface> surface = ios_surface->CreateGPUSurface();
     overlays_[overlay_id] = std::make_unique<FlutterPlatformViewLayer>(
         std::move(overlay_view), std::move(ios_surface), std::move(surface));
@@ -492,7 +496,8 @@ void FlutterPlatformViewsController::EnsureOverlayInitialized(
   overlay_view.get().autoresizingMask =
       (UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight);
   std::unique_ptr<IOSSurface> ios_surface =
-      [overlay_view.get() createSurface:std::move(gl_context)];
+      [overlay_view.get() createSurfaceWithOnscreenGLContext:std::move(onscreen_gl_context)
+                                           resourceGLContext:std::move(resource_gl_context)];
   std::unique_ptr<Surface> surface = ios_surface->CreateGPUSurface(gr_context);
   overlays_[overlay_id] = std::make_unique<FlutterPlatformViewLayer>(
       std::move(overlay_view), std::move(ios_surface), std::move(surface));

shell/platform/darwin/ios/framework/Source/FlutterPlatformViews_Internal.h

@@ -100,7 +100,9 @@ class FlutterPlatformViewsController {
   // Discards all platform views instances and auxiliary resources.
   void Reset();
 
-  bool SubmitFrame(GrContext* gr_context, std::shared_ptr<IOSGLContext> gl_context);
+  bool SubmitFrame(GrContext* gr_context,
+                   fml::WeakPtr<IOSGLContext> onscreen_gl_context,
+                   fml::WeakPtr<IOSGLContext> resource_gl_context);
 
   void OnMethodCall(FlutterMethodCall* call, FlutterResult& result);
 
@@ -162,7 +164,8 @@ class FlutterPlatformViewsController {
   // Dispose the views in `views_to_dispose_`.
   void DisposeViews();
   void EnsureOverlayInitialized(int64_t overlay_id,
-                                std::shared_ptr<IOSGLContext> gl_context,
+                                fml::WeakPtr<IOSGLContext> onscreen_gl_context,
+                                fml::WeakPtr<IOSGLContext> resource_gl_context,
                                 GrContext* gr_context);
 
   // This will return true after pre-roll if any of the embedded views

shell/platform/darwin/ios/framework/Source/FlutterView.h

@@ -33,8 +33,8 @@
 
 - (instancetype)initWithDelegate:(id<FlutterViewEngineDelegate>)delegate
                           opaque:(BOOL)opaque NS_DESIGNATED_INITIALIZER;
-- (std::unique_ptr<flutter::IOSSurface>)createSurface:
-    (std::shared_ptr<flutter::IOSGLContext>)context;
+- (std::unique_ptr<flutter::IOSSurface>)createSurfaceWithResourceGLContext:
+    (fml::WeakPtr<flutter::IOSGLContext>)resourceGLContext;
 
 @end
 

shell/platform/darwin/ios/framework/Source/FlutterView.mm

@@ -13,6 +13,7 @@
 #include "flutter/shell/common/platform_view.h"
 #include "flutter/shell/common/rasterizer.h"
 #include "flutter/shell/platform/darwin/ios/framework/Source/FlutterViewController_Internal.h"
+#include "flutter/shell/platform/darwin/ios/ios_gl_context.h"
 #include "flutter/shell/platform/darwin/ios/ios_surface_gl.h"
 #include "flutter/shell/platform/darwin/ios/ios_surface_software.h"
 #include "third_party/skia/include/utils/mac/SkCGUtils.h"
@@ -21,9 +22,10 @@
 #include "flutter/shell/platform/darwin/ios/ios_surface_metal.h"
 #endif  //  FLUTTER_SHELL_ENABLE_METAL
 
-@implementation FlutterView
-
-id<FlutterViewEngineDelegate> _delegate;
+@implementation FlutterView {
+  id<FlutterViewEngineDelegate> _delegate;
+  std::unique_ptr<flutter::IOSGLContext> _onscreenGLContext;
+}
 
 - (instancetype)init {
   @throw([NSException exceptionWithName:@"FlutterView must initWithDelegate"
@@ -93,8 +95,14 @@ id<FlutterViewEngineDelegate> _delegate;
 #endif  // TARGET_IPHONE_SIMULATOR
 }
 
-- (std::unique_ptr<flutter::IOSSurface>)createSurface:
-    (std::shared_ptr<flutter::IOSGLContext>)context {
+- (std::unique_ptr<flutter::IOSSurface>)createSurfaceWithResourceGLContext:
+    (fml::WeakPtr<flutter::IOSGLContext>)resourceGLContext {
+#if !TARGET_IPHONE_SIMULATOR
+  if (!_onscreenGLContext) {
+    _onscreenGLContext = resourceGLContext->MakeSharedContext();
+  }
+#endif  // !TARGET_IPHONE_SIMULATOR
+
   if ([self.layer isKindOfClass:[CAEAGLLayer class]]) {
     fml::scoped_nsobject<CAEAGLLayer> eagl_layer(
         reinterpret_cast<CAEAGLLayer*>([self.layer retain]));
@@ -105,8 +113,9 @@ id<FlutterViewEngineDelegate> _delegate;
         eagl_layer.get().presentsWithTransaction = YES;
       }
     }
-    return std::make_unique<flutter::IOSSurfaceGL>(context, std::move(eagl_layer),
-                                                   [_delegate platformViewsController]);
+    return std::make_unique<flutter::IOSSurfaceGL>(
+        _onscreenGLContext->GetWeakPtr(), std::move(resourceGLContext), std::move(eagl_layer),
+        [_delegate platformViewsController]);
 #if FLUTTER_SHELL_ENABLE_METAL
   } else if ([self.layer isKindOfClass:[CAMetalLayer class]]) {
     fml::scoped_nsobject<CAMetalLayer> metalLayer(

shell/platform/darwin/ios/ios_gl_context.h

@@ -13,30 +13,32 @@
 #include "flutter/fml/macros.h"
 #include "flutter/fml/platform/darwin/scoped_nsobject.h"
 #include "flutter/shell/common/platform_view.h"
-#include "ios_gl_render_target.h"
 
 namespace flutter {
 
 class IOSGLContext {
  public:
   IOSGLContext();
+  IOSGLContext(EAGLSharegroup* sharegroup);
 
   ~IOSGLContext();
 
-  std::unique_ptr<IOSGLRenderTarget> CreateRenderTarget(
-      fml::scoped_nsobject<CAEAGLLayer> layer);
-
   bool MakeCurrent();
 
-  bool ResourceMakeCurrent();
+  bool BindRenderbufferStorage(fml::scoped_nsobject<CAEAGLLayer> layer);
 
   sk_sp<SkColorSpace> ColorSpace() const { return color_space_; }
 
+  std::unique_ptr<IOSGLContext> MakeSharedContext();
+
+  fml::WeakPtr<IOSGLContext> GetWeakPtr();
+
  private:
   fml::scoped_nsobject<EAGLContext> context_;
-  fml::scoped_nsobject<EAGLContext> resource_context_;
   sk_sp<SkColorSpace> color_space_;
 
+  std::unique_ptr<fml::WeakPtrFactory<IOSGLContext>> weak_factory_;
+
   FML_DISALLOW_COPY_AND_ASSIGN(IOSGLContext);
 };
 

shell/platform/darwin/ios/ios_gl_context.mm

@@ -12,15 +12,16 @@
 
 namespace flutter {
 
-IOSGLContext::IOSGLContext() {
-  resource_context_.reset([[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES3]);
-  if (resource_context_ != nullptr) {
-    context_.reset([[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES3
-                                         sharegroup:resource_context_.get().sharegroup]);
-  } else {
-    resource_context_.reset([[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES2]);
+IOSGLContext::IOSGLContext() : IOSGLContext(nullptr) {}
+
+IOSGLContext::IOSGLContext(EAGLSharegroup* sharegroup)
+    : weak_factory_(std::make_unique<fml::WeakPtrFactory<IOSGLContext>>(this)) {
+  context_.reset([[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES3
+                                       sharegroup:sharegroup]);
+
+  if (!context_) {
     context_.reset([[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES2
-                                         sharegroup:resource_context_.get().sharegroup]);
+                                         sharegroup:sharegroup]);
   }
 
   // TODO:
@@ -44,20 +45,22 @@ IOSGLContext::IOSGLContext() {
   }
 }
 
-IOSGLContext::~IOSGLContext() = default;
+fml::WeakPtr<IOSGLContext> IOSGLContext::GetWeakPtr() {
+  return weak_factory_->GetWeakPtr();
+}
 
-std::unique_ptr<IOSGLRenderTarget> IOSGLContext::CreateRenderTarget(
-    fml::scoped_nsobject<CAEAGLLayer> layer) {
-  return std::make_unique<IOSGLRenderTarget>(std::move(layer), context_.get(),
-                                             resource_context_.get());
+bool IOSGLContext::BindRenderbufferStorage(fml::scoped_nsobject<CAEAGLLayer> layer) {
+  return [context_.get() renderbufferStorage:GL_RENDERBUFFER fromDrawable:layer.get()];
 }
 
+IOSGLContext::~IOSGLContext() = default;
+
 bool IOSGLContext::MakeCurrent() {
   return [EAGLContext setCurrentContext:context_.get()];
 }
 
-bool IOSGLContext::ResourceMakeCurrent() {
-  return [EAGLContext setCurrentContext:resource_context_.get()];
+std::unique_ptr<IOSGLContext> IOSGLContext::MakeSharedContext() {
+  return std::make_unique<IOSGLContext>(context_.get().sharegroup);
 }
 
 }  // namespace flutter

shell/platform/darwin/ios/ios_gl_render_target.h

@@ -13,14 +13,15 @@
 #include "flutter/fml/macros.h"
 #include "flutter/fml/platform/darwin/scoped_nsobject.h"
 #include "flutter/shell/common/platform_view.h"
+#include "flutter/shell/platform/darwin/ios/ios_gl_context.h"
 
 namespace flutter {
 
 class IOSGLRenderTarget {
  public:
   IOSGLRenderTarget(fml::scoped_nsobject<CAEAGLLayer> layer,
-                    EAGLContext* context,
-                    EAGLContext* resource_context);
+                    fml::WeakPtr<IOSGLContext> onscreen_context,
+                    fml::WeakPtr<IOSGLContext> resource_context);
 
   ~IOSGLRenderTarget();
 
@@ -40,8 +41,8 @@ class IOSGLRenderTarget {
 
  private:
   fml::scoped_nsobject<CAEAGLLayer> layer_;
-  fml::scoped_nsobject<EAGLContext> context_;
-  fml::scoped_nsobject<EAGLContext> resource_context_;
+  fml::WeakPtr<IOSGLContext> onscreen_gl_context_;
+  fml::WeakPtr<IOSGLContext> resource_gl_context_;
   GLuint framebuffer_;
   GLuint colorbuffer_;
   GLint storage_size_width_;

shell/platform/darwin/ios/ios_gl_render_target.mm

@@ -11,23 +11,22 @@
 #include "third_party/skia/include/gpu/gl/GrGLInterface.h"
 
 namespace flutter {
-
 IOSGLRenderTarget::IOSGLRenderTarget(fml::scoped_nsobject<CAEAGLLayer> layer,
-                                     EAGLContext* context,
-                                     EAGLContext* resource_context)
+                                     fml::WeakPtr<IOSGLContext> onscreen_gl_context,
+                                     fml::WeakPtr<IOSGLContext> resource_gl_context)
     : layer_(std::move(layer)),
-      context_([context retain]),
-      resource_context_([resource_context retain]),
+      onscreen_gl_context_(std::move(onscreen_gl_context)),
+      resource_gl_context_(std::move(resource_gl_context)),
       framebuffer_(GL_NONE),
       colorbuffer_(GL_NONE),
       storage_size_width_(0),
       storage_size_height_(0),
       valid_(false) {
   FML_DCHECK(layer_ != nullptr);
-  FML_DCHECK(context_ != nullptr);
-  FML_DCHECK(resource_context_ != nullptr);
+  FML_DCHECK(onscreen_gl_context_);
+  FML_DCHECK(resource_gl_context_);
 
-  bool context_current = [EAGLContext setCurrentContext:context_];
+  bool context_current = onscreen_gl_context_->MakeCurrent();
 
   FML_DCHECK(context_current);
   FML_DCHECK(glGetError() == GL_NO_ERROR);
@@ -63,7 +62,7 @@ IOSGLRenderTarget::IOSGLRenderTarget(fml::scoped_nsobject<CAEAGLLayer> layer,
 
 IOSGLRenderTarget::~IOSGLRenderTarget() {
   EAGLContext* context = EAGLContext.currentContext;
-  [EAGLContext setCurrentContext:context_];
+  onscreen_gl_context_->MakeCurrent();
   FML_DCHECK(glGetError() == GL_NO_ERROR);
 
   // Deletes on GL_NONEs are ignored
@@ -105,7 +104,7 @@ bool IOSGLRenderTarget::UpdateStorageSizeIfNecessary() {
 
   FML_DCHECK(glGetError() == GL_NO_ERROR);
 
-  if (![EAGLContext setCurrentContext:context_]) {
+  if (!onscreen_gl_context_->MakeCurrent()) {
     return false;
   }
 
@@ -116,7 +115,7 @@ bool IOSGLRenderTarget::UpdateStorageSizeIfNecessary() {
   glBindRenderbuffer(GL_RENDERBUFFER, colorbuffer_);
   FML_DCHECK(glGetError() == GL_NO_ERROR);
 
-  if (![context_.get() renderbufferStorage:GL_RENDERBUFFER fromDrawable:layer_.get()]) {
+  if (!onscreen_gl_context_->BindRenderbufferStorage(layer_)) {
     return false;
   }
 
@@ -133,11 +132,11 @@ bool IOSGLRenderTarget::UpdateStorageSizeIfNecessary() {
 }
 
 bool IOSGLRenderTarget::MakeCurrent() {
-  return UpdateStorageSizeIfNecessary() && [EAGLContext setCurrentContext:context_.get()];
+  return UpdateStorageSizeIfNecessary() && onscreen_gl_context_->MakeCurrent();
 }
 
 bool IOSGLRenderTarget::ResourceMakeCurrent() {
-  return [EAGLContext setCurrentContext:resource_context_.get()];
+  return resource_gl_context_->MakeCurrent();
 }
 
 }  // namespace flutter

shell/platform/darwin/ios/ios_surface_gl.h

@@ -20,11 +20,14 @@ class IOSSurfaceGL final : public IOSSurface,
                            public GPUSurfaceGLDelegate,
                            public ExternalViewEmbedder {
  public:
-  IOSSurfaceGL(std::shared_ptr<IOSGLContext> context,
+  IOSSurfaceGL(fml::WeakPtr<IOSGLContext> onscreen_gl_context,
+               fml::WeakPtr<IOSGLContext> resource_gl_context,
                fml::scoped_nsobject<CAEAGLLayer> layer,
                FlutterPlatformViewsController* platform_views_controller);
 
-  IOSSurfaceGL(fml::scoped_nsobject<CAEAGLLayer> layer, std::shared_ptr<IOSGLContext> context);
+  IOSSurfaceGL(fml::scoped_nsobject<CAEAGLLayer> layer,
+               fml::WeakPtr<IOSGLContext> onscreen_gl_context,
+               fml::WeakPtr<IOSGLContext> resource_gl_context);
 
   ~IOSSurfaceGL() override;
 
@@ -79,7 +82,10 @@ class IOSSurfaceGL final : public IOSSurface,
   bool SubmitFrame(GrContext* context) override;
 
  private:
-  std::shared_ptr<IOSGLContext> context_;
+  fml::WeakPtr<IOSGLContext> onscreen_gl_context_;
+
+  fml::WeakPtr<IOSGLContext> resource_gl_context_;
+
   std::unique_ptr<IOSGLRenderTarget> render_target_;
 
   FML_DISALLOW_COPY_AND_ASSIGN(IOSSurfaceGL);

shell/platform/darwin/ios/ios_surface_gl.mm

@@ -9,17 +9,25 @@
 
 namespace flutter {
 
-IOSSurfaceGL::IOSSurfaceGL(std::shared_ptr<IOSGLContext> context,
+IOSSurfaceGL::IOSSurfaceGL(fml::WeakPtr<IOSGLContext> onscreen_gl_context,
+                           fml::WeakPtr<IOSGLContext> resource_gl_context,
                            fml::scoped_nsobject<CAEAGLLayer> layer,
                            FlutterPlatformViewsController* platform_views_controller)
-    : IOSSurface(platform_views_controller), context_(context) {
-  render_target_ = context_->CreateRenderTarget(std::move(layer));
+    : IOSSurface(platform_views_controller),
+      onscreen_gl_context_(std::move(onscreen_gl_context)),
+      resource_gl_context_(std::move(resource_gl_context)) {
+  render_target_ = std::make_unique<IOSGLRenderTarget>(std::move(layer), onscreen_gl_context_,
+                                                       resource_gl_context_);
 }
 
 IOSSurfaceGL::IOSSurfaceGL(fml::scoped_nsobject<CAEAGLLayer> layer,
-                           std::shared_ptr<IOSGLContext> context)
-    : IOSSurface(nullptr), context_(context) {
-  render_target_ = context_->CreateRenderTarget(std::move(layer));
+                           fml::WeakPtr<IOSGLContext> onscreen_gl_context,
+                           fml::WeakPtr<IOSGLContext> resource_gl_context)
+    : IOSSurface(nullptr),
+      onscreen_gl_context_(std::move(onscreen_gl_context)),
+      resource_gl_context_(std::move(resource_gl_context)) {
+  render_target_ = std::make_unique<IOSGLRenderTarget>(std::move(layer), onscreen_gl_context_,
+                                                       resource_gl_context_);
 }
 
 IOSSurfaceGL::~IOSSurfaceGL() = default;
@@ -29,7 +37,7 @@ bool IOSSurfaceGL::IsValid() const {
 }
 
 bool IOSSurfaceGL::ResourceContextMakeCurrent() {
-  return context_->ResourceMakeCurrent();
+  return resource_gl_context_->MakeCurrent();
 }
 
 void IOSSurfaceGL::UpdateStorageSizeIfNecessary() {
@@ -60,7 +68,7 @@ bool IOSSurfaceGL::GLContextMakeCurrent() {
   if (!IsValid()) {
     return false;
   }
-  return render_target_->UpdateStorageSizeIfNecessary() && context_->MakeCurrent();
+  return render_target_->UpdateStorageSizeIfNecessary() && onscreen_gl_context_->MakeCurrent();
 }
 
 bool IOSSurfaceGL::GLContextClearCurrent() {
@@ -145,7 +153,8 @@ bool IOSSurfaceGL::SubmitFrame(GrContext* context) {
     return true;
   }
 
-  bool submitted = platform_views_controller->SubmitFrame(std::move(context), context_);
+  bool submitted = platform_views_controller->SubmitFrame(std::move(context), onscreen_gl_context_,
+                                                          resource_gl_context_);
   [CATransaction commit];
   return submitted;
 }

shell/platform/darwin/ios/ios_surface_software.mm

@@ -184,7 +184,8 @@ bool IOSSurfaceSoftware::SubmitFrame(GrContext* context) {
   if (platform_views_controller == nullptr) {
     return true;
   }
-  return platform_views_controller->SubmitFrame(nullptr, nullptr);
+  return platform_views_controller->SubmitFrame(nullptr, fml::WeakPtr<IOSGLContext>(),
+                                                fml::WeakPtr<IOSGLContext>());
 }
 
 }  // namespace flutter

shell/platform/darwin/ios/platform_view_ios.h

@@ -50,7 +50,7 @@ class PlatformViewIOS final : public PlatformView {
  private:
   fml::WeakPtr<FlutterViewController> owner_controller_;
   std::unique_ptr<IOSSurface> ios_surface_;
-  std::shared_ptr<IOSGLContext> gl_context_;
+  std::unique_ptr<IOSGLContext> resource_gl_context_;
   PlatformMessageRouter platform_message_router_;
   std::unique_ptr<AccessibilityBridge> accessibility_bridge_;
   fml::scoped_nsprotocol<FlutterTextInputPlugin*> text_input_plugin_;
@@ -79,6 +79,11 @@ class PlatformViewIOS final : public PlatformView {
   // |PlatformView|
   void OnPreEngineRestart() const override;
 
+  // |PlatformView|
+  void NotifyDestroyed() override;
+
+  std::unique_ptr<IOSSurface> CreateIOSSurface() const;
+
   FML_DISALLOW_COPY_AND_ASSIGN(PlatformViewIOS);
 };
 

shell/platform/darwin/ios/platform_view_ios.mm

@@ -23,7 +23,7 @@ PlatformViewIOS::PlatformViewIOS(PlatformView::Delegate& delegate,
                                  flutter::TaskRunners task_runners)
     : PlatformView(delegate, std::move(task_runners)) {
 #if !TARGET_IPHONE_SIMULATOR
-  gl_context_ = std::make_shared<IOSGLContext>();
+  resource_gl_context_ = std::make_unique<IOSGLContext>();
 #endif  // !TARGET_IPHONE_SIMULATOR
 }
 
@@ -42,10 +42,32 @@ fml::WeakPtr<FlutterViewController> PlatformViewIOS::GetOwnerViewController() co
   return owner_controller_;
 }
 
+std::unique_ptr<IOSSurface> PlatformViewIOS::CreateIOSSurface() const {
+  if (!owner_controller_) {
+    FML_DLOG(INFO) << "Could not CreateIOSSurface, this PlatformViewIOS "
+                      "has no ViewController.";
+    return nullptr;
+  }
+
+  fml::WeakPtr<IOSGLContext> weak_gl_context;
+  if (resource_gl_context_) {
+    weak_gl_context = resource_gl_context_->GetWeakPtr();
+  }
+
+  std::unique_ptr<IOSSurface> ios_surface = [static_cast<FlutterView*>(owner_controller_.get().view)
+      createSurfaceWithResourceGLContext:weak_gl_context];
+  FML_DCHECK(ios_surface != nullptr);
+  return ios_surface;
+}
+
+void PlatformViewIOS::NotifyDestroyed() {
+  PlatformView::NotifyDestroyed();
+  ios_surface_.reset();
+}
+
 void PlatformViewIOS::SetOwnerViewController(fml::WeakPtr<FlutterViewController> owner_controller) {
   if (ios_surface_ || !owner_controller) {
     NotifyDestroyed();
-    ios_surface_.reset();
     accessibility_bridge_.reset();
   }
   owner_controller_ = owner_controller;
@@ -63,10 +85,7 @@ void PlatformViewIOS::SetOwnerViewController(fml::WeakPtr<FlutterViewController>
               }]);
 
   if (owner_controller_) {
-    ios_surface_ =
-        [static_cast<FlutterView*>(owner_controller.get().view) createSurface:gl_context_];
-    FML_DCHECK(ios_surface_ != nullptr);
-
+    ios_surface_ = CreateIOSSurface();
     if (accessibility_bridge_) {
       accessibility_bridge_.reset(
           new AccessibilityBridge(static_cast<FlutterView*>(owner_controller_.get().view), this,
@@ -93,16 +112,18 @@ void PlatformViewIOS::RegisterExternalTexture(int64_t texture_id,
 // |PlatformView|
 std::unique_ptr<Surface> PlatformViewIOS::CreateRenderingSurface() {
   if (!ios_surface_) {
-    FML_DLOG(INFO) << "Could not CreateRenderingSurface, this PlatformViewIOS "
-                      "has no ViewController.";
-    return nullptr;
+    ios_surface_ = CreateIOSSurface();
+
+    if (!ios_surface_) {
+      return nullptr;
+    }
   }
   return ios_surface_->CreateGPUSurface();
 }
 
 // |PlatformView|
 sk_sp<GrContext> PlatformViewIOS::CreateResourceContext() const {
-  if (!gl_context_ || !gl_context_->ResourceMakeCurrent()) {
+  if (!resource_gl_context_ || !resource_gl_context_->MakeCurrent()) {
     FML_DLOG(INFO) << "Could not make resource context current on IO thread. "
                       "Async texture uploads will be disabled. On Simulators, "
                       "this is expected.";