[WIP]Fix OpenGL leak on Android and iOS

shell/common/platform_view.cc

@@ -141,6 +141,10 @@ std::unique_ptr<Surface> PlatformView::CreateRenderingSurface() {
   return nullptr;
 }
 
+void PlatformView::ReleaseSurfaceContext() {
+  // Do nothing by default
+}
+
 std::shared_ptr<ExternalViewEmbedder>
 PlatformView::CreateExternalViewEmbedder() {
   FML_DLOG(WARNING)

shell/common/platform_view.h

@@ -812,6 +812,16 @@ class PlatformView {
   virtual std::unique_ptr<SnapshotSurfaceProducer>
   CreateSnapshotSurfaceProducer();
 
+  //----------------------------------------------------------------------------
+  /// @brief      Used by the shell to notify the embedder that all the
+  ///             rendering surface previously obtained via a call to
+  ///             `CreateRenderingSurface()` are being collected. The embedder
+  ///             should collect the shared context of surfaces
+  ///
+  /// @attention  This should be called on the rasterizer task runner.
+  ///
+  virtual void ReleaseSurfaceContext();
+
  protected:
   PlatformView::Delegate& delegate_;
   const TaskRunners task_runners_;

shell/common/shell.cc

@@ -443,12 +443,16 @@ Shell::~Shell() {
 
   fml::TaskRunner::RunNowOrPostTask(
       task_runners_.GetRasterTaskRunner(),
-      fml::MakeCopyable(
-          [this, rasterizer = std::move(rasterizer_), &gpu_latch]() mutable {
-            rasterizer.reset();
-            this->weak_factory_gpu_.reset();
-            gpu_latch.Signal();
-          }));
+      fml::MakeCopyable([this, rasterizer = std::move(rasterizer_),
+                         platform_view = platform_view_.get(),
+                         &gpu_latch]() mutable {
+        rasterizer.reset();
+        this->weak_factory_gpu_.reset();
+        if (platform_view) {
+          platform_view->ReleaseSurfaceContext();
+        }
+        gpu_latch.Signal();
+      }));
   gpu_latch.Wait();
 
   fml::TaskRunner::RunNowOrPostTask(

shell/platform/android/platform_view_android.cc

@@ -35,9 +35,11 @@ AndroidSurfaceFactoryImpl::~AndroidSurfaceFactoryImpl() = default;
 std::unique_ptr<AndroidSurface> AndroidSurfaceFactoryImpl::CreateSurface() {
   switch (android_context_->RenderingApi()) {
     case AndroidRenderingAPI::kSoftware:
+      FML_DCHECK(android_context_);
       return std::make_unique<AndroidSurfaceSoftware>(android_context_,
                                                       jni_facade_);
     case AndroidRenderingAPI::kOpenGLES:
+      FML_DCHECK(android_context_);
       return std::make_unique<AndroidSurfaceGL>(android_context_, jni_facade_);
     default:
       FML_DCHECK(false);
@@ -290,16 +292,25 @@ std::unique_ptr<VsyncWaiter> PlatformViewAndroid::CreateVSyncWaiter() {
 
 // |PlatformView|
 std::unique_ptr<Surface> PlatformViewAndroid::CreateRenderingSurface() {
-  if (!android_surface_) {
+  if (!android_surface_ || !android_context_) {
     return nullptr;
   }
   return android_surface_->CreateGPUSurface(
       android_context_->GetMainSkiaContext().get());
 }
 
+// |PlatformView|
+void PlatformViewAndroid::ReleaseSurfaceContext() {
+  FML_DCHECK(task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread());
+  if (android_context_) {
+    android_context_.reset();
+  }
+}
+
 // |PlatformView|
 std::shared_ptr<ExternalViewEmbedder>
 PlatformViewAndroid::CreateExternalViewEmbedder() {
+  FML_DCHECK(android_context_);
   return std::make_shared<AndroidExternalViewEmbedder>(
       *android_context_, jni_facade_, surface_factory_);
 }

shell/platform/android/platform_view_android.h

@@ -149,6 +149,9 @@ class PlatformViewAndroid final : public PlatformView {
   // |PlatformView|
   std::unique_ptr<Surface> CreateRenderingSurface() override;
 
+  // |PlatformView|
+  void ReleaseSurfaceContext() override;
+
   // |PlatformView|
   std::shared_ptr<ExternalViewEmbedder> CreateExternalViewEmbedder() override;
 

shell/platform/darwin/ios/platform_view_ios.h

@@ -152,6 +152,9 @@ class PlatformViewIOS final : public PlatformView {
   // |PlatformView|
   std::unique_ptr<Surface> CreateRenderingSurface() override;
 
+  // |PlatformView|
+  void ReleaseSurfaceContext() override;
+
   // |PlatformView|
   std::shared_ptr<ExternalViewEmbedder> CreateExternalViewEmbedder() override;
 

shell/platform/darwin/ios/platform_view_ios.mm

@@ -113,6 +113,7 @@
 
 void PlatformViewIOS::attachView() {
   FML_DCHECK(owner_controller_);
+  FML_DCHECK(ios_context_);
   FML_DCHECK(owner_controller_.get().isViewLoaded)
       << "FlutterViewController's view should be loaded "
          "before attaching to PlatformViewIOS.";
@@ -135,13 +136,15 @@
 
 void PlatformViewIOS::RegisterExternalTexture(int64_t texture_id,
                                               NSObject<FlutterTexture>* texture) {
+  FML_DCHECK(ios_context_);
   RegisterTexture(ios_context_->CreateExternalTexture(
       texture_id, fml::scoped_nsobject<NSObject<FlutterTexture>>{[texture retain]}));
 }
 
 // |PlatformView|
 std::unique_ptr<Surface> PlatformViewIOS::CreateRenderingSurface() {
   FML_DCHECK(task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread());
+  FML_DCHECK(ios_context_);
   std::lock_guard<std::mutex> guard(ios_surface_mutex_);
   if (!ios_surface_) {
     FML_DLOG(INFO) << "Could not CreateRenderingSurface, this PlatformViewIOS "
@@ -151,13 +154,23 @@
   return ios_surface_->CreateGPUSurface(ios_context_->GetMainContext().get());
 }
 
+// |PlatformView|
+void PlatformViewIOS::ReleaseSurfaceContext() {
+  FML_DCHECK(task_runners_.GetRasterTaskRunner()->RunsTasksOnCurrentThread());
+  if (ios_context_) {
+    ios_context_.reset();
+  }
+}
+
 // |PlatformView|
 std::shared_ptr<ExternalViewEmbedder> PlatformViewIOS::CreateExternalViewEmbedder() {
+  FML_DCHECK(ios_context_);
   return std::make_shared<IOSExternalViewEmbedder>(platform_views_controller_, ios_context_);
 }
 
 // |PlatformView|
 sk_sp<GrDirectContext> PlatformViewIOS::CreateResourceContext() const {
+  FML_DCHECK(ios_context_);
   return ios_context_->CreateResourceContext();
 }