Plumb the iOS PlatformViewsController into flow. (flutter#6603)

For flow to manipulate the embedded UIViews during the paint traversal
it needs some hook in PaintContext.
This PR introduces a ViewEmbeder interface that is implemented by the
iOS PlatformViewsController and plumbs it into PaintContext.

The ViewEmbedder interface is mainly a place holder at this point, as
this PR is focused on just the plumbing.

Author: amirh

ci/licenses_golden/licenses_flutter

@@ -11,6 +11,7 @@ ORIGIN: ../../../flutter/flow/layers/physical_shape_layer.cc + ../../../LICENSE
 TYPE: LicenseType.bsd
 FILE: ../../../flutter/flow/debug_print.cc
 FILE: ../../../flutter/flow/debug_print.h
+FILE: ../../../flutter/flow/embedded_views.h
 FILE: ../../../flutter/flow/export_node.h
 FILE: ../../../flutter/flow/layers/physical_shape_layer.cc
 FILE: ../../../flutter/flow/layers/physical_shape_layer.h

flow/BUILD.gn

@@ -8,6 +8,7 @@ source_set("flow") {
     "compositor_context.h",
     "debug_print.cc",
     "debug_print.h",
+    "embedded_views.h",
     "instrumentation.cc",
     "instrumentation.h",
     "layers/backdrop_filter_layer.cc",

flow/compositor_context.cc

@@ -32,25 +32,25 @@ void CompositorContext::EndFrame(ScopedFrame& frame,
 std::unique_ptr<CompositorContext::ScopedFrame> CompositorContext::AcquireFrame(
     GrContext* gr_context,
     SkCanvas* canvas,
+    ExternalViewEmbedder* view_embedder,
     const SkMatrix& root_surface_transformation,
     bool instrumentation_enabled) {
-  return std::make_unique<ScopedFrame>(*this,                        //
-                                       gr_context,                   //
-                                       canvas,                       //
-                                       root_surface_transformation,  //
-                                       instrumentation_enabled       //
-  );
+  return std::make_unique<ScopedFrame>(*this, gr_context, canvas, view_embedder,
+                                       root_surface_transformation,
+                                       instrumentation_enabled);
 }
 
 CompositorContext::ScopedFrame::ScopedFrame(
     CompositorContext& context,
     GrContext* gr_context,
     SkCanvas* canvas,
+    ExternalViewEmbedder* view_embedder,
     const SkMatrix& root_surface_transformation,
     bool instrumentation_enabled)
     : context_(context),
       gr_context_(gr_context),
       canvas_(canvas),
+      view_embedder_(view_embedder),
       root_surface_transformation_(root_surface_transformation),
       instrumentation_enabled_(instrumentation_enabled) {
   context_.BeginFrame(*this, instrumentation_enabled_);

flow/compositor_context.h

@@ -8,6 +8,7 @@
 #include <memory>
 #include <string>
 
+#include "flutter/flow/embedded_views.h"
 #include "flutter/flow/instrumentation.h"
 #include "flutter/flow/raster_cache.h"
 #include "flutter/flow/texture.h"
@@ -26,13 +27,16 @@ class CompositorContext {
     ScopedFrame(CompositorContext& context,
                 GrContext* gr_context,
                 SkCanvas* canvas,
+                ExternalViewEmbedder* view_embedder,
                 const SkMatrix& root_surface_transformation,
                 bool instrumentation_enabled);
 
     virtual ~ScopedFrame();
 
     SkCanvas* canvas() { return canvas_; }
 
+    ExternalViewEmbedder* view_embedder() { return view_embedder_; }
+
     CompositorContext& context() const { return context_; }
 
     const SkMatrix& root_surface_transformation() const {
@@ -47,6 +51,7 @@ class CompositorContext {
     CompositorContext& context_;
     GrContext* gr_context_;
     SkCanvas* canvas_;
+    ExternalViewEmbedder* view_embedder_;
     const SkMatrix& root_surface_transformation_;
     const bool instrumentation_enabled_;
 
@@ -60,6 +65,7 @@ class CompositorContext {
   virtual std::unique_ptr<ScopedFrame> AcquireFrame(
       GrContext* gr_context,
       SkCanvas* canvas,
+      ExternalViewEmbedder* view_embedder,
       const SkMatrix& root_surface_transformation,
       bool instrumentation_enabled);
 

flow/embedded_views.h

@@ -0,0 +1,34 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+#ifndef FLUTTER_FLOW_EMBEDDED_VIEWS_H_
+#define FLUTTER_FLOW_EMBEDDED_VIEWS_H_
+
+#include "flutter/fml/memory/ref_counted.h"
+
+namespace flow {
+
+class EmbeddedViewParams {
+ public:
+};
+
+// This is only used on iOS when running in a non headless mode,
+// in this case ViewEmbedded is a reference to the
+// FlutterPlatformViewsController which is owned by FlutterViewController.
+class ExternalViewEmbedder {
+ public:
+  ExternalViewEmbedder() = default;
+
+  // Must be called on the UI thread.
+  virtual void CompositeEmbeddedView(int view_id,
+                                     const EmbeddedViewParams& params) {}
+
+  virtual ~ExternalViewEmbedder() = default;
+
+  FML_DISALLOW_COPY_AND_ASSIGN(ExternalViewEmbedder);
+};
+
+}  // namespace flow
+
+#endif  // FLUTTER_FLOW_EMBEDDED_VIEWS_H_

flow/layers/layer.h

@@ -8,6 +8,7 @@
 #include <memory>
 #include <vector>
 
+#include "flutter/flow/embedded_views.h"
 #include "flutter/flow/instrumentation.h"
 #include "flutter/flow/raster_cache.h"
 #include "flutter/flow/texture.h"
@@ -64,6 +65,7 @@ class Layer {
 
   struct PaintContext {
     SkCanvas& canvas;
+    ExternalViewEmbedder* view_embedder;
     const Stopwatch& frame_time;
     const Stopwatch& engine_time;
     TextureRegistry& texture_registry;

flow/layers/layer_tree.cc

@@ -68,6 +68,7 @@ void LayerTree::Paint(CompositorContext::ScopedFrame& frame,
   TRACE_EVENT0("flutter", "LayerTree::Paint");
   Layer::PaintContext context = {
       *frame.canvas(),
+      frame.view_embedder(),
       frame.context().frame_time(),
       frame.context().engine_time(),
       frame.context().texture_registry(),
@@ -106,7 +107,8 @@ sk_sp<SkPicture> LayerTree::Flatten(const SkRect& bounds) {
   };
 
   Layer::PaintContext paint_context = {
-      *canvas,                  // canvas
+      *canvas,  // canvas
+      nullptr,
       unused_stopwatch,         // frame time (dont care)
       unused_stopwatch,         // engine time (dont care)
       unused_texture_registry,  // texture registry (not supported)

flow/layers/platform_view_layer.cc

@@ -16,6 +16,13 @@ void PlatformViewLayer::Preroll(PrerollContext* context,
                                     size_.height()));
 }
 
-void PlatformViewLayer::Paint(PaintContext& context) const {}
-
+void PlatformViewLayer::Paint(PaintContext& context) const {
+  if (context.view_embedder == nullptr) {
+    FML_LOG(ERROR) << "Trying to embed a platform view but the PaintContext "
+                      "does not support embedding";
+    return;
+  }
+  EmbeddedViewParams params;
+  context.view_embedder->CompositeEmbeddedView(view_id_, params);
+}
 }  // namespace flow

flow/raster_cache.cc

@@ -158,6 +158,7 @@ void RasterCache::Prepare(PrerollContext* context,
                             [layer, context](SkCanvas* canvas) {
                               Layer::PaintContext paintContext = {
                                   *canvas,
+                                  nullptr,
                                   context->frame_time,
                                   context->engine_time,
                                   context->texture_registry,

shell/common/rasterizer.cc

@@ -167,7 +167,8 @@ bool Rasterizer::DrawToSurface(flow::LayerTree& layer_tree) {
   auto canvas = frame->SkiaCanvas();
 
   auto compositor_frame = compositor_context_->AcquireFrame(
-      surface_->GetContext(), canvas, surface_->GetRootTransformation(), true);
+      surface_->GetContext(), canvas, surface_->GetExternalViewEmbedder(),
+      surface_->GetRootTransformation(), true);
 
   if (canvas) {
     canvas->clear(SK_ColorTRANSPARENT);
@@ -197,9 +198,11 @@ static sk_sp<SkData> ScreenshotLayerTreeAsPicture(
   SkMatrix root_surface_transformation;
   root_surface_transformation.reset();
 
-  auto frame =
-      compositor_context.AcquireFrame(nullptr, recorder.getRecordingCanvas(),
-                                      root_surface_transformation, false);
+  // TODO(amirh): figure out how to take a screenshot with embedded UIView.
+  // https://github.com/flutter/flutter/issues/23435
+  auto frame = compositor_context.AcquireFrame(
+      nullptr, recorder.getRecordingCanvas(), nullptr,
+      root_surface_transformation, false);
 
   frame->Raster(*tree, true);
 
@@ -249,7 +252,7 @@ static sk_sp<SkData> ScreenshotLayerTreeAsImage(
   root_surface_transformation.reset();
 
   auto frame = compositor_context.AcquireFrame(
-      surface_context, canvas, root_surface_transformation, false);
+      surface_context, canvas, nullptr, root_surface_transformation, false);
   canvas->clear(SK_ColorTRANSPARENT);
   frame->Raster(*tree, true);
   canvas->flush();