For MacOS, rasterizer will only use the compositor if there is a platform view

in the layer tree.

Otherwise the current render path will be used.

This is to avoid regression as Compositor currently doesn't
fully support resizing.

Author: RichardJCai

flow/layers/container_layer.cc

@@ -96,6 +96,19 @@ void ContainerLayer::TryToPrepareRasterCache(PrerollContext* context,
   }
 }
 
+#if defined(OS_MACOSX)
+bool ContainerLayer::HasPlatformView() {
+  bool hasPlatformView = false;
+  for (auto& layer : layers_) {
+    if (layer->HasPlatformView()) {
+      hasPlatformView = true;
+    }
+  }
+
+  return hasPlatformView;
+}
+#endif
+
 #if defined(LEGACY_FUCHSIA_EMBEDDER)
 
 void ContainerLayer::CheckForChildLayerBelow(PrerollContext* context) {

flow/layers/container_layer.h

@@ -19,6 +19,9 @@ class ContainerLayer : public Layer {
 
   void Preroll(PrerollContext* context, const SkMatrix& matrix) override;
   void Paint(PaintContext& context) const override;
+#if defined(OS_MACOSX)
+  bool HasPlatformView() override;
+#endif
 #if defined(LEGACY_FUCHSIA_EMBEDDER)
   void CheckForChildLayerBelow(PrerollContext* context) override;
   void UpdateScene(std::shared_ptr<SceneUpdateContext> context) override;

flow/layers/layer.cc

@@ -27,6 +27,12 @@ uint64_t Layer::NextUniqueID() {
 
 void Layer::Preroll(PrerollContext* context, const SkMatrix& matrix) {}
 
+#if defined(OS_MACOSX)
+bool Layer::HasPlatformView() {
+  return false;
+}
+#endif
+
 Layer::AutoPrerollSaveLayerState::AutoPrerollSaveLayerState(
     PrerollContext* preroll_context,
     bool save_layer_is_active,

flow/layers/layer.h

@@ -75,6 +75,10 @@ class Layer {
 
   virtual void Preroll(PrerollContext* context, const SkMatrix& matrix);
 
+#if defined(OS_MACOSX)
+  virtual bool HasPlatformView();
+#endif
+
   // Used during Preroll by layers that employ a saveLayer to manage the
   // PrerollContext settings with values affected by the saveLayer mechanism.
   // This object must be created before calling Preroll on the children to

flow/layers/layer_tree.cc

@@ -60,6 +60,11 @@ bool LayerTree::Preroll(CompositorContext::ScopedFrame& frame,
   root_layer_->Preroll(&context, frame.root_surface_transformation());
   return context.surface_needs_readback;
 }
+#if defined(OS_MACOSX)
+bool LayerTree::HasPlatformView() {
+  return root_layer_->HasPlatformView();
+}
+#endif
 
 #if defined(LEGACY_FUCHSIA_EMBEDDER)
 void LayerTree::UpdateScene(std::shared_ptr<SceneUpdateContext> context) {

flow/layers/layer_tree.h

@@ -31,6 +31,13 @@ class LayerTree {
   bool Preroll(CompositorContext::ScopedFrame& frame,
                bool ignore_raster_cache = false);
 
+  // Used to check before Prerolling to see if the layer tree
+  // contains a platform view.
+  // Specifically used for MacOS to determine if the compositor
+  // should be used.
+#if defined(OS_MACOSX)
+  bool HasPlatformView();
+#endif
 #if defined(LEGACY_FUCHSIA_EMBEDDER)
   void UpdateScene(std::shared_ptr<SceneUpdateContext> context);
 #endif

flow/layers/platform_view_layer.cc

@@ -34,6 +34,12 @@ void PlatformViewLayer::Preroll(PrerollContext* context,
                                                        std::move(params));
 }
 
+#if defined(OS_MACOSX)
+bool PlatformViewLayer::HasPlatformView() {
+  return true;
+}
+#endif
+
 void PlatformViewLayer::Paint(PaintContext& context) const {
   if (context.view_embedder == nullptr) {
 #if !defined(LEGACY_FUCHSIA_EMBEDDER)

flow/layers/platform_view_layer.h

@@ -17,6 +17,9 @@ class PlatformViewLayer : public Layer {
 
   void Preroll(PrerollContext* context, const SkMatrix& matrix) override;
   void Paint(PaintContext& context) const override;
+#if defined(OS_MACOSX)
+  bool HasPlatformView() override;
+#endif
 #if defined(LEGACY_FUCHSIA_EMBEDDER)
   // Updates the system composited scene.
   void UpdateScene(std::shared_ptr<SceneUpdateContext> context) override;

flow/surface.cc

@@ -18,4 +18,6 @@ bool Surface::ClearRenderContext() {
   return false;
 }
 
+void Surface::SetRenderToSurface(bool render_to_surface) {}
+
 }  // namespace flutter

flow/surface.h

@@ -33,6 +33,11 @@ class Surface {
 
   virtual bool ClearRenderContext();
 
+  // SetRenderToSurface sets whether or not the surface should be rendered to.
+  // This is needed for MacOS as we want to render scenes without platform views
+  // to the surface even in the existence of a external_view_embedder.
+  virtual void SetRenderToSurface(bool render_to_surface);
+
  private:
   FML_DISALLOW_COPY_AND_ASSIGN(Surface);
 };

shell/common/rasterizer.cc

@@ -424,13 +424,30 @@ RasterStatus Rasterizer::DrawToSurface(flutter::LayerTree& layer_tree) {
   compositor_context_->ui_time().SetLapTime(layer_tree.build_time());
 
   SkCanvas* embedder_root_canvas = nullptr;
+#if defined(OS_MACOSX)
+  // For MacOS, we only want to use the external_view_embedder / compositor
+  // if there is a platform view in the layer tree.
+  // TODO(richardjcai): Remove branching logic for using external_view_embedder
+  // once the compositor supports smooth resizing.
+  // https://github.com/flutter/flutter/issues/70848.
+  bool hasPlatformView = layer_tree.HasPlatformView();
+  if (external_view_embedder_ && hasPlatformView) {
+#else
   if (external_view_embedder_) {
+#endif
     external_view_embedder_->BeginFrame(
         layer_tree.frame_size(), surface_->GetContext(),
         layer_tree.device_pixel_ratio(), raster_thread_merger_);
     embedder_root_canvas = external_view_embedder_->GetRootCanvas();
   }
 
+#if defined(OS_MACOSX)
+  if (external_view_embedder_ && hasPlatformView) {
+    surface_->SetRenderToSurface(false);
+  } else {
+    surface_->SetRenderToSurface(true);
+  }
+#endif
   // On Android, the external view embedder deletes surfaces in `BeginFrame`.
   //
   // Deleting a surface also clears the GL context. Therefore, acquire the
@@ -450,14 +467,23 @@ RasterStatus Rasterizer::DrawToSurface(flutter::LayerTree& layer_tree) {
   auto root_surface_canvas =
       embedder_root_canvas ? embedder_root_canvas : frame->SkiaCanvas();
 
+#if defined(OS_MACOSX)
+  auto external_view_embedder =
+      hasPlatformView ? external_view_embedder_.get() : nullptr;
+  auto raster_thread_merger = hasPlatformView ? raster_thread_merger_ : nullptr;
+#else
+  auto external_view_embedder = external_view_embedder_.get();
+  auto raster_thread_merger = raster_thread_merger_;
+#endif
+
   auto compositor_frame = compositor_context_->AcquireFrame(
-      surface_->GetContext(),         // skia GrContext
-      root_surface_canvas,            // root surface canvas
-      external_view_embedder_.get(),  // external view embedder
-      root_surface_transformation,    // root surface transformation
-      true,                           // instrumentation enabled
-      frame->supports_readback(),     // surface supports pixel reads
-      raster_thread_merger_           // thread merger
+      surface_->GetContext(),       // skia GrContext
+      root_surface_canvas,          // root surface canvas
+      external_view_embedder,       // external view embedder
+      root_surface_transformation,  // root surface transformation
+      true,                         // instrumentation enabled
+      frame->supports_readback(),   // surface supports pixel reads
+      raster_thread_merger          // thread merger
   );
 
   if (compositor_frame) {
@@ -466,8 +492,14 @@ RasterStatus Rasterizer::DrawToSurface(flutter::LayerTree& layer_tree) {
         raster_status == RasterStatus::kSkipAndRetry) {
       return raster_status;
     }
+#if defined(OS_MACOSX)
+    if (external_view_embedder_ &&
+        (!raster_thread_merger_ || raster_thread_merger_->IsMerged()) &&
+        hasPlatformView) {
+#else
     if (external_view_embedder_ &&
         (!raster_thread_merger_ || raster_thread_merger_->IsMerged())) {
+#endif
       FML_DCHECK(!frame->IsSubmitted());
       external_view_embedder_->SubmitFrame(surface_->GetContext(),
                                            std::move(frame));

shell/gpu/gpu_surface_gl.cc

@@ -343,4 +343,9 @@ bool GPUSurfaceGL::ClearRenderContext() {
   return delegate_->GLContextClearCurrent();
 }
 
+// |Surface|
+void GPUSurfaceGL::SetRenderToSurface(bool render_to_surface) {
+  render_to_surface_ = render_to_surface;
+}
+
 }  // namespace flutter

shell/gpu/gpu_surface_gl.h

@@ -48,6 +48,9 @@ class GPUSurfaceGL : public Surface {
   // |Surface|
   bool ClearRenderContext() override;
 
+  // |Surface|
+  void SetRenderToSurface(bool render_to_surface) override;
+
  private:
   GPUSurfaceGLDelegate* delegate_;
   sk_sp<GrDirectContext> context_;
@@ -59,7 +62,7 @@ class GPUSurfaceGL : public Surface {
   // external view embedder may want to render to the root surface. This is a
   // hack to make avoid allocating resources for the root surface when an
   // external view embedder is present.
-  const bool render_to_surface_;
+  bool render_to_surface_;
   bool valid_ = false;
   fml::TaskRunnerAffineWeakPtrFactory<GPUSurfaceGL> weak_factory_;
 

shell/gpu/gpu_surface_software.h

@@ -37,7 +37,7 @@ class GPUSurfaceSoftware : public Surface {
   // external view embedder may want to render to the root surface. This is a
   // hack to make avoid allocating resources for the root surface when an
   // external view embedder is present.
-  const bool render_to_surface_;
+  bool render_to_surface_;
   fml::TaskRunnerAffineWeakPtrFactory<GPUSurfaceSoftware> weak_factory_;
 
   FML_DISALLOW_COPY_AND_ASSIGN(GPUSurfaceSoftware);

shell/platform/darwin/macos/framework/Source/FlutterMacOSGLCompositor.h

@@ -15,14 +15,14 @@ namespace flutter {
 // FlutterMacOSGLCompositor creates and manages the backing stores used for
 // rendering Flutter content and presents Flutter content and Platform views.
 // Platform views are not yet supported.
-// FlutterMacOSGLCompositor is created and destroyed by FlutterEngine. 
+// FlutterMacOSGLCompositor is created and destroyed by FlutterEngine.
 class FlutterMacOSGLCompositor {
  public:
   FlutterMacOSGLCompositor(FlutterViewController* view_controller);
 
   // Creates a FlutterSurfaceManager and uses the FlutterSurfaceManager's
   // underlying FBO and texture in the backing store.
-  // Any additional state allocated for the backing store and 
+  // Any additional state allocated for the backing store and
   // saved as user_data in the backing store must be collected
   // in the backing_store's desctruction_callback field which will
   // be called when the embedder collects the backing store.