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 should 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 should be dropped and a new frame with the same layer tree should 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,12 @@ class FrameTimingsRecorder {
   /// Returns the recorded time from when `RecordRasterEnd` is called.
   FrameTiming GetRecordedTime() const;
 
+  /// Asserts in debug mode that the recorder is current at the specified state.
+  ///
+  /// A `GetState` method is not preferred to avoid other logic relying on this
+  /// state.
+  void AssertInState(State state) const;
+
  private:
   FML_FRIEND_TEST(FrameTimingsRecorderTest, ThrowWhenRecordBuildBeforeVsync);
   FML_FRIEND_TEST(FrameTimingsRecorderTest,

flow/layers/layer_tree.h

@@ -94,6 +94,22 @@ class LayerTree {
   FML_DISALLOW_COPY_AND_ASSIGN(LayerTree);
 };
 
+// The information to draw a layer tree to a specified view.
+struct LayerTreeTask {
+  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 drawn 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;
+};
+
 }  // namespace flutter
 
 #endif  // FLUTTER_FLOW_LAYERS_LAYER_TREE_H_

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
@@ -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,15 @@ 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.
+  int64_t view_id = kFlutterImplicitViewId;
+  std::list<LayerTreeTask> layer_trees_tasks;
+  layer_trees_tasks.emplace_back(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";

shell/common/animator.h

@@ -39,8 +39,7 @@ 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(
         std::unique_ptr<FrameTimingsRecorder> frame_timings_recorder) = 0;
@@ -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_;
+  FramePipeline::ProducerContinuation producer_continuation_;
   bool regenerate_layer_tree_ = 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,7 +41,7 @@ class FakeAnimatorDelegate : public Animator::Delegate {
 
   MOCK_METHOD(void,
               OnAnimatorDraw,
-              (std::shared_ptr<LayerTreePipeline> pipeline),
+              (std::shared_ptr<FramePipeline> pipeline),
               (override));
 
   void OnAnimatorDrawLastLayerTree(

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_