Merge remote-tracking branch 'origin/main' into mv-pipeline

flow/layers/layer_tree.h

@@ -96,18 +96,23 @@ class 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 drawn to.
+
+  /// 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

shell/common/animator.cc

@@ -177,8 +177,8 @@ void Animator::Render(int64_t view_id,
   delegate_.OnAnimatorUpdateLatestFrameTargetTime(
       frame_timings_recorder_->GetVsyncTargetTime());
 
-  layer_trees_tasks_.emplace_back(view_id, std::move(layer_tree),
-                                  device_pixel_ratio);
+  layer_trees_tasks_.push_back(std::make_unique<LayerTreeTask>(
+      view_id, std::move(layer_tree), device_pixel_ratio));
 }
 
 const std::weak_ptr<VsyncWaiter> Animator::GetVsyncWaiter() const {

shell/common/animator.h

@@ -100,13 +100,13 @@ class Animator final {
   std::shared_ptr<VsyncWaiter> waiter_;
 
   std::unique_ptr<FrameTimingsRecorder> frame_timings_recorder_;
-  std::list<LayerTreeTask> layer_trees_tasks_;
+  std::vector<std::unique_ptr<LayerTreeTask>> layer_trees_tasks_;
   uint64_t frame_request_number_ = 1;
   fml::TimeDelta dart_frame_deadline_;
   std::shared_ptr<FramePipeline> layer_tree_pipeline_;
   fml::Semaphore pending_frame_semaphore_;
   FramePipeline::ProducerContinuation producer_continuation_;
-  bool regenerate_layer_tree_ = false;
+  bool regenerate_layer_trees_ = false;
   bool frame_scheduled_ = false;
   std::deque<uint64_t> trace_flow_ids_;
   bool has_rendered_ = false;

shell/common/rasterizer.cc

@@ -227,7 +227,7 @@ void Rasterizer::DrawLastLayerTrees(
   }
 }
 
-RasterStatus Rasterizer::Draw(const std::shared_ptr<FramePipeline>& pipeline) {
+DrawStatus Rasterizer::Draw(const std::shared_ptr<FramePipeline>& pipeline) {
   TRACE_EVENT0("flutter", "GPURasterizer::Draw");
   if (raster_thread_merger_ &&
       !raster_thread_merger_->IsOnRasterizingThread()) {
@@ -239,29 +239,11 @@ RasterStatus Rasterizer::Draw(const std::shared_ptr<FramePipeline>& pipeline) {
                  ->RunsTasksOnCurrentThread());
 
   DoDrawResult draw_result;
-  FramePipeline::Consumer consumer =
-      [&draw_result, this,
-       &delegate = delegate_](std::unique_ptr<FrameItem> item) {
-        // TODO(dkwingsmt): The rasterizer only supports rendering a single view
-        // and that view must be the implicit view. Properly support multi-view
-        // in the future.
-        FML_DCHECK(item->layer_tree_tasks.size() <= 1u);
-        if (item->layer_tree_tasks.empty()) {
-          return;
-        }
-        auto& task = item->layer_tree_tasks.front();
-        FML_DCHECK(task.view_id == kFlutterImplicitViewId);
-        std::unique_ptr<LayerTree> layer_tree = std::move(task.layer_tree);
-        std::unique_ptr<FrameTimingsRecorder> frame_timings_recorder =
-            std::move(item->frame_timings_recorder);
-        float device_pixel_ratio = task.device_pixel_ratio;
-        if (delegate.ShouldDiscardLayerTree(task.view_id, *layer_tree.get())) {
-          draw_result.raster_status = RasterStatus::kDiscarded;
-        } else {
-          draw_result = DoDraw(std::move(frame_timings_recorder),
-                               std::move(layer_tree), device_pixel_ratio);
-        }
-      };
+  FramePipeline::Consumer consumer = [&draw_result,
+                                      this](std::unique_ptr<FrameItem> item) {
+    draw_result = DoDraw(std::move(item->frame_timings_recorder),
+                         std::move(item->layer_tree_tasks));
+  };
 
   PipelineConsumeResult consume_result = pipeline->Consume(consumer);
   if (consume_result == PipelineConsumeResult::NoneAvailable) {
@@ -465,26 +447,12 @@ Rasterizer::DoDrawResult Rasterizer::DoDraw(
   PersistentCache* persistent_cache = PersistentCache::GetCacheForProcess();
   persistent_cache->ResetStoredNewShaders();
 
-  RasterStatus raster_status =
-      DrawToSurface(*frame_timings_recorder, *layer_tree, device_pixel_ratio);
-  if (raster_status == RasterStatus::kSuccess) {
-    last_layer_tree_ = std::move(layer_tree);
-    last_device_pixel_ratio_ = device_pixel_ratio;
-  } else if (ShouldResubmitFrame(raster_status)) {
-    std::list<LayerTreeTask> resubmitted_tasks;
-    resubmitted_tasks.emplace_back(kFlutterImplicitViewId,
-                                   std::move(layer_tree), device_pixel_ratio);
-    return DoDrawResult{
-        .raster_status = raster_status,
-        .resubmitted_item = std::make_unique<FrameItem>(
-            std::move(resubmitted_tasks),
-            frame_timings_recorder->CloneUntil(
-                FrameTimingsRecorder::State::kBuildEnd)),
-    };
-  } else if (raster_status == RasterStatus::kDiscarded) {
-    return DoDrawResult{
-        .raster_status = raster_status,
-    };
+  DoDrawResult result =
+      DrawToSurfaces(*frame_timings_recorder, std::move(tasks));
+
+  FML_DCHECK(result.status != DoDrawStatus::kEnqueuePipeline);
+  if (result.status == DoDrawStatus::kGpuUnavailable) {
+    return DoDrawResult{DoDrawStatus::kGpuUnavailable};
   }
 
   if (persistent_cache->IsDumpingSkp() &&

shell/common/rasterizer.h

@@ -49,13 +49,49 @@ class AiksContext;
 
 namespace flutter {
 
+// The result status of Rasterizer::Draw. This is only used for unit tests.
+enum class DrawStatus {
+  // The drawing was done without any specified status.
+  kDone,
+  // Failed to rasterize the frame because the Rasterizer is not set up.
+  kNotSetUp,
+  // Nothing was done, because the call was not on the raster thread. Yielded to
+  // let this frame be serviced on the right thread.
+  kYielded,
+  // Nothing was done, because the pipeline was empty.
+  kPipelineEmpty,
+  // Nothing was done, because the GPU was unavailable.
+  kGpuUnavailable,
+};
+
+// The result status of drawing to a view. This is only used for unit tests.
+enum class DrawSurfaceStatus {
+  // The layer tree was successfully rasterized.
+  kSuccess,
+  // The layer tree must be submitted again.
+  //
+  // This can occur 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
+  //
+  // This can also occur when the frame is dropped to wait for the thread
+  // merger to merge the raster and platform threads.
+  kRetry,
+  // Failed to rasterize the frame.
+  kFailed,
+  // Layer tree was discarded because its size does not match the view size.
+  // This typically occurs during resizing.
+  kDiscarded,
+};
+
 // The information to draw to all views of a frame.
 struct FrameItem {
-  FrameItem(std::list<LayerTreeTask> tasks,
+  FrameItem(std::vector<std::unique_ptr<LayerTreeTask>> tasks,
             std::unique_ptr<FrameTimingsRecorder> frame_timings_recorder)
       : layer_tree_tasks(std::move(tasks)),
         frame_timings_recorder(std::move(frame_timings_recorder)) {}
-  std::list<LayerTreeTask> layer_tree_tasks;
+  std::vector<std::unique_ptr<LayerTreeTask>> layer_tree_tasks;
   std::unique_ptr<FrameTimingsRecorder> frame_timings_recorder;
 };
 
@@ -301,7 +337,7 @@ class Rasterizer final : public SnapshotDelegate,
   /// @param[in]  pipeline  The layer tree pipeline to take the next layer tree
   ///                       to render from.
   ///
-  RasterStatus Draw(const std::shared_ptr<FramePipeline>& pipeline);
+  DrawStatus Draw(const std::shared_ptr<FramePipeline>& pipeline);
 
   //----------------------------------------------------------------------------
   /// @brief      The type of the screenshot to obtain of the previously
@@ -533,9 +569,49 @@ class Rasterizer final : public SnapshotDelegate,
   ///
   bool IsTornDown();
 
+  //----------------------------------------------------------------------------
+  /// @brief      Returns the last status of drawing the specific view.
+  ///
+  ///             This method is used only in unit tests.
+  ///
+  std::optional<DrawSurfaceStatus> GetLastDrawStatus(int64_t view_id);
+
+ private:
+  // The result status of DoDraw, DrawToSurfaces, and DrawToSurfacesUnsafe.
+  enum class DoDrawStatus {
+    // The drawing was done without any specified status.
+    kDone,
+    // 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 because the Rasterizer is not set up.
+    kNotSetUp,
+    // Nothing was done, because GPU was unavailable.
+    kGpuUnavailable,
+  };
+
+  // The result of DoDraw.
+  struct DoDrawResult {
+    // The overall status of the drawing process.
+    //
+    // The status of drawing a specific view is available at GetLastDrawStatus.
+    DoDrawStatus status = DoDrawStatus::kDone;
+
+    // The frame item that needs to be submitted again.
+    //
+    // See RasterStatus::kResubmit and kSkipAndRetry for when it happens.
+    //
+    // If `resubmitted_item` is not null, its `tasks` is guaranteed to be
+    // non-empty.
     std::unique_ptr<FrameItem> resubmitted_item;
   };
 
+  struct ViewRecord {
+    std::unique_ptr<LayerTreeTask> last_successful_task;
+    std::optional<DrawSurfaceStatus> last_draw_status;
+  };
+
   // |SnapshotDelegate|
   std::unique_ptr<GpuImageResult> MakeSkiaGpuImage(
       sk_sp<DisplayList> display_list,

shell/common/rasterizer_unittests.cc

@@ -34,12 +34,13 @@ namespace {
 constexpr float kDevicePixelRatio = 2.0f;
 constexpr int64_t kImplicitViewId = 0;
 
-std::list<LayerTreeTask> SingleLayerTreeList(
+std::vector<std::unique_ptr<LayerTreeTask>> SingleLayerTreeList(
     int64_t view_id,
     std::unique_ptr<LayerTree> layer_tree,
     float pixel_ratio) {
-  std::list<LayerTreeTask> tasks;
-  tasks.emplace_back(view_id, std::move(layer_tree), pixel_ratio);
+  std::vector<std::unique_ptr<LayerTreeTask>> tasks;
+  tasks.push_back(std::make_unique<LayerTreeTask>(
+      view_id, std::move(layer_tree), pixel_ratio));
   return tasks;
 }