Multi-view Rasterizer

flow/compositor_context.h

@@ -23,18 +23,19 @@ namespace flutter {
 
 class LayerTree;
 
+// The result status of CompositorContext::ScopedFrame::Raster.
 enum class RasterStatus {
   // Frame has been successfully rasterized.
   kSuccess,
-  // Frame is submitted twice. This is only used on Android when
-  // switching the background surface to FlutterImageView.
+  // Frame has been submited, but must be submitted again. This is only used
+  // on Android when switching the background surface to FlutterImageView.
   //
   // On Android, the first frame doesn't make the image available
   // to the ImageReader right away. The second frame does.
   //
   // TODO(egarciad): https://github.com/flutter/flutter/issues/65652
   kResubmit,
-  // Frame is dropped and a new frame with the same layer tree is
+  // Frame has be dropped and a new frame with the same layer tree must be
   // attempted.
   //
   // This is currently used to wait for the thread merger to merge
@@ -44,18 +45,6 @@ enum class RasterStatus {
   // with separate threads for rasterization and platform tasks,
   // potentially leading to different performance characteristics.
   kSkipAndRetry,
-  // Frame has been successfully rasterized, but there are additional items in
-  // the pipeline waiting to be consumed. This is currently
-  // only used when thread configuration change occurs.
-  kEnqueuePipeline,
-  // Failed to rasterize the frame.
-  kFailed,
-  // Layer tree was discarded due to LayerTreeDiscardCallback or inability to
-  // access the GPU.
-  kDiscarded,
-  // Drawing was yielded to allow the correct thread to draw as a result of the
-  // RasterThreadMerger.
-  kYielded,
 };
 
 class FrameDamage {

flow/frame_timings.cc

@@ -254,4 +254,8 @@ const char* FrameTimingsRecorder::GetFrameNumberTraceArg() const {
   return frame_number_trace_arg_val_.c_str();
 }
 
+void FrameTimingsRecorder::AssertInState(State state) const {
+  FML_DCHECK(state_ == state);
+}
+
 }  // namespace flutter

flow/frame_timings.h

@@ -116,6 +116,13 @@ class FrameTimingsRecorder {
   /// Returns the recorded time from when `RecordRasterEnd` is called.
   FrameTiming GetRecordedTime() const;
 
+  /// Asserts in unopt builds that the recorder is current at the specified
+  /// state.
+  ///
+  /// Instead of adding a `GetState` method and asserting on the result, this
+  /// method prevents other logic from relying on the state.
+  void AssertInState(State state) const;
+
  private:
   FML_FRIEND_TEST(FrameTimingsRecorderTest, ThrowWhenRecordBuildBeforeVsync);
   FML_FRIEND_TEST(FrameTimingsRecorderTest,

flow/layers/layer_tree.h

@@ -94,6 +94,27 @@ class LayerTree {
   FML_DISALLOW_COPY_AND_ASSIGN(LayerTree);
 };
 
+// The information to draw a layer tree to a specified view.
+struct LayerTreeTask {
+ public:
+  LayerTreeTask(int64_t view_id,
+                std::unique_ptr<LayerTree> layer_tree,
+                float device_pixel_ratio)
+      : view_id(view_id),
+        layer_tree(std::move(layer_tree)),
+        device_pixel_ratio(device_pixel_ratio) {}
+
+  /// The target view to draw to.
+  int64_t view_id;
+  /// The target layer tree to be drawn.
+  std::unique_ptr<LayerTree> layer_tree;
+  /// The pixel ratio of the target view.
+  float device_pixel_ratio;
+
+ private:
+  FML_DISALLOW_COPY_AND_ASSIGN(LayerTreeTask);
+};
+
 }  // namespace flutter
 
 #endif  // FLUTTER_FLOW_LAYERS_LAYER_TREE_H_

runtime/runtime_delegate.h

@@ -23,7 +23,7 @@ class RuntimeDelegate {
  public:
   virtual std::string DefaultRouteName() = 0;
 
-  virtual void ScheduleFrame(bool regenerate_layer_tree = true) = 0;
+  virtual void ScheduleFrame(bool regenerate_layer_trees = true) = 0;
 
   virtual void Render(std::unique_ptr<flutter::LayerTree> layer_tree,
                       float device_pixel_ratio) = 0;

shell/common/animator.cc

@@ -4,6 +4,7 @@
 
 #include "flutter/shell/common/animator.h"
 
+#include "flutter/common/constants.h"
 #include "flutter/flow/frame_timings.h"
 #include "flutter/fml/time/time_point.h"
 #include "flutter/fml/trace_event.h"
@@ -28,12 +29,12 @@ Animator::Animator(Delegate& delegate,
       task_runners_(task_runners),
       waiter_(std::move(waiter)),
 #if SHELL_ENABLE_METAL
-      layer_tree_pipeline_(std::make_shared<LayerTreePipeline>(2)),
+      layer_tree_pipeline_(std::make_shared<FramePipeline>(2)),
 #else   // SHELL_ENABLE_METAL
       // TODO(dnfield): We should remove this logic and set the pipeline depth
       // back to 2 in this case. See
       // https://github.com/flutter/engine/pull/9132 for discussion.
-      layer_tree_pipeline_(std::make_shared<LayerTreePipeline>(
+      layer_tree_pipeline_(std::make_shared<FramePipeline>(
           task_runners.GetPlatformTaskRunner() ==
                   task_runners.GetRasterTaskRunner()
               ? 1
@@ -84,7 +85,7 @@ void Animator::BeginFrame(
   }
 
   frame_scheduled_ = false;
-  regenerate_layer_tree_ = false;
+  regenerate_layer_trees_ = false;
   pending_frame_semaphore_.Signal();
 
   if (!producer_continuation_) {
@@ -143,7 +144,6 @@ void Animator::BeginFrame(
 void Animator::Render(std::unique_ptr<flutter::LayerTree> layer_tree,
                       float device_pixel_ratio) {
   has_rendered_ = true;
-  last_layer_tree_size_ = layer_tree->frame_size();
 
   if (!frame_timings_recorder_) {
     // Framework can directly call render with a built scene.
@@ -161,12 +161,16 @@ void Animator::Render(std::unique_ptr<flutter::LayerTree> layer_tree,
   delegate_.OnAnimatorUpdateLatestFrameTargetTime(
       frame_timings_recorder_->GetVsyncTargetTime());
 
-  auto layer_tree_item = std::make_unique<LayerTreeItem>(
-      std::move(layer_tree), std::move(frame_timings_recorder_),
-      device_pixel_ratio);
+  // TODO(dkwingsmt): Currently only supports a single window.
+  // See https://github.com/flutter/flutter/issues/135530, item 2.
+  int64_t view_id = kFlutterImplicitViewId;
+  std::vector<std::unique_ptr<LayerTreeTask>> layer_trees_tasks;
+  layer_trees_tasks.push_back(std::make_unique<LayerTreeTask>(
+      view_id, std::move(layer_tree), device_pixel_ratio));
   // Commit the pending continuation.
   PipelineProduceResult result =
-      producer_continuation_.Complete(std::move(layer_tree_item));
+      producer_continuation_.Complete(std::make_unique<FrameItem>(
+          std::move(layer_trees_tasks), std::move(frame_timings_recorder_)));
 
   if (!result.success) {
     FML_DLOG(INFO) << "No pending continuation to commit";
@@ -188,15 +192,15 @@ const std::weak_ptr<VsyncWaiter> Animator::GetVsyncWaiter() const {
   return weak;
 }
 
-bool Animator::CanReuseLastLayerTree() {
-  return !regenerate_layer_tree_;
+bool Animator::CanReuseLastLayerTrees() {
+  return !regenerate_layer_trees_;
 }
 
-void Animator::DrawLastLayerTree(
+void Animator::DrawLastLayerTrees(
     std::unique_ptr<FrameTimingsRecorder> frame_timings_recorder) {
   // This method is very cheap, but this makes it explicitly clear in trace
   // files.
-  TRACE_EVENT0("flutter", "Animator::DrawLastLayerTree");
+  TRACE_EVENT0("flutter", "Animator::DrawLastLayerTrees");
 
   pending_frame_semaphore_.Signal();
   // In this case BeginFrame doesn't get called, we need to
@@ -206,18 +210,18 @@ void Animator::DrawLastLayerTree(
   const auto now = fml::TimePoint::Now();
   frame_timings_recorder->RecordBuildStart(now);
   frame_timings_recorder->RecordBuildEnd(now);
-  delegate_.OnAnimatorDrawLastLayerTree(std::move(frame_timings_recorder));
+  delegate_.OnAnimatorDrawLastLayerTrees(std::move(frame_timings_recorder));
 }
 
-void Animator::RequestFrame(bool regenerate_layer_tree) {
-  if (regenerate_layer_tree) {
+void Animator::RequestFrame(bool regenerate_layer_trees) {
+  if (regenerate_layer_trees) {
     // This event will be closed by BeginFrame. BeginFrame will only be called
-    // if regenerating the layer tree. If a frame has been requested to update
+    // if regenerating the layer trees. If a frame has been requested to update
     // an external texture, this will be false and no BeginFrame call will
     // happen.
     TRACE_EVENT_ASYNC_BEGIN0("flutter", "Frame Request Pending",
                              frame_request_number_);
-    regenerate_layer_tree_ = true;
+    regenerate_layer_trees_ = true;
   }
 
   if (!pending_frame_semaphore_.TryWait()) {
@@ -248,8 +252,8 @@ void Animator::AwaitVSync() {
       [self = weak_factory_.GetWeakPtr()](
           std::unique_ptr<FrameTimingsRecorder> frame_timings_recorder) {
         if (self) {
-          if (self->CanReuseLastLayerTree()) {
-            self->DrawLastLayerTree(std::move(frame_timings_recorder));
+          if (self->CanReuseLastLayerTrees()) {
+            self->DrawLastLayerTrees(std::move(frame_timings_recorder));
           } else {
             self->BeginFrame(std::move(frame_timings_recorder));
           }

shell/common/animator.h

@@ -39,10 +39,9 @@ class Animator final {
     virtual void OnAnimatorUpdateLatestFrameTargetTime(
         fml::TimePoint frame_target_time) = 0;
 
-    virtual void OnAnimatorDraw(
-        std::shared_ptr<LayerTreePipeline> pipeline) = 0;
+    virtual void OnAnimatorDraw(std::shared_ptr<FramePipeline> pipeline) = 0;
 
-    virtual void OnAnimatorDrawLastLayerTree(
+    virtual void OnAnimatorDrawLastLayerTrees(
         std::unique_ptr<FrameTimingsRecorder> frame_timings_recorder) = 0;
   };
 
@@ -52,7 +51,7 @@ class Animator final {
 
   ~Animator();
 
-  void RequestFrame(bool regenerate_layer_tree = true);
+  void RequestFrame(bool regenerate_layer_trees = true);
 
   void Render(std::unique_ptr<flutter::LayerTree> layer_tree,
               float device_pixel_ratio);
@@ -85,9 +84,9 @@ class Animator final {
  private:
   void BeginFrame(std::unique_ptr<FrameTimingsRecorder> frame_timings_recorder);
 
-  bool CanReuseLastLayerTree();
+  bool CanReuseLastLayerTrees();
 
-  void DrawLastLayerTree(
+  void DrawLastLayerTrees(
       std::unique_ptr<FrameTimingsRecorder> frame_timings_recorder);
 
   void AwaitVSync();
@@ -102,12 +101,11 @@ class Animator final {
   std::unique_ptr<FrameTimingsRecorder> frame_timings_recorder_;
   uint64_t frame_request_number_ = 1;
   fml::TimeDelta dart_frame_deadline_;
-  std::shared_ptr<LayerTreePipeline> layer_tree_pipeline_;
+  std::shared_ptr<FramePipeline> layer_tree_pipeline_;
   fml::Semaphore pending_frame_semaphore_;
-  LayerTreePipeline::ProducerContinuation producer_continuation_;
-  bool regenerate_layer_tree_ = false;
+  FramePipeline::ProducerContinuation producer_continuation_;
+  bool regenerate_layer_trees_ = false;
   bool frame_scheduled_ = false;
-  SkISize last_layer_tree_size_ = {0, 0};
   std::deque<uint64_t> trace_flow_ids_;
   bool has_rendered_ = false;
 

shell/common/animator_unittests.cc

@@ -41,10 +41,10 @@ class FakeAnimatorDelegate : public Animator::Delegate {
 
   MOCK_METHOD(void,
               OnAnimatorDraw,
-              (std::shared_ptr<LayerTreePipeline> pipeline),
+              (std::shared_ptr<FramePipeline> pipeline),
               (override));
 
-  void OnAnimatorDrawLastLayerTree(
+  void OnAnimatorDrawLastLayerTrees(
       std::unique_ptr<FrameTimingsRecorder> frame_timings_recorder) override {}
 
   bool notify_idle_called_ = false;

shell/common/engine.cc

@@ -455,8 +455,8 @@ std::string Engine::DefaultRouteName() {
   return "/";
 }
 
-void Engine::ScheduleFrame(bool regenerate_layer_tree) {
-  animator_->RequestFrame(regenerate_layer_tree);
+void Engine::ScheduleFrame(bool regenerate_layer_trees) {
+  animator_->RequestFrame(regenerate_layer_trees);
 }
 
 void Engine::Render(std::unique_ptr<flutter::LayerTree> layer_tree,

shell/common/engine.h

@@ -29,7 +29,6 @@
 #include "flutter/shell/common/display_manager.h"
 #include "flutter/shell/common/platform_view.h"
 #include "flutter/shell/common/pointer_data_dispatcher.h"
-#include "flutter/shell/common/rasterizer.h"
 #include "flutter/shell/common/run_configuration.h"
 #include "flutter/shell/common/shell_io_manager.h"
 
@@ -828,7 +827,7 @@ class Engine final : public RuntimeDelegate, PointerDataDispatcher::Delegate {
   void SetAccessibilityFeatures(int32_t flags);
 
   // |RuntimeDelegate|
-  void ScheduleFrame(bool regenerate_layer_tree) override;
+  void ScheduleFrame(bool regenerate_layer_trees) override;
 
   /// Schedule a frame with the default parameter of regenerating the layer
   /// tree.

shell/common/pipeline.h

@@ -253,20 +253,6 @@ class Pipeline {
   FML_DISALLOW_COPY_AND_ASSIGN(Pipeline);
 };
 
-struct LayerTreeItem {
-  LayerTreeItem(std::unique_ptr<LayerTree> layer_tree,
-                std::unique_ptr<FrameTimingsRecorder> frame_timings_recorder,
-                float device_pixel_ratio)
-      : layer_tree(std::move(layer_tree)),
-        frame_timings_recorder(std::move(frame_timings_recorder)),
-        device_pixel_ratio(device_pixel_ratio) {}
-  std::unique_ptr<LayerTree> layer_tree;
-  std::unique_ptr<FrameTimingsRecorder> frame_timings_recorder;
-  float device_pixel_ratio;
-};
-
-using LayerTreePipeline = Pipeline<LayerTreeItem>;
-
 }  // namespace flutter
 
 #endif  // FLUTTER_SHELL_COMMON_PIPELINE_H_