Remove pipeline in favor of layer tree holder

go/flutter-pipeline-improvements for more details

Author: Kaushik Iska

ci/licenses_golden/licenses_flutter

@@ -576,9 +576,6 @@ FILE: ../../../flutter/shell/common/isolate_configuration.h
 FILE: ../../../flutter/shell/common/persistent_cache.cc
 FILE: ../../../flutter/shell/common/persistent_cache.h
 FILE: ../../../flutter/shell/common/persistent_cache_unittests.cc
-FILE: ../../../flutter/shell/common/pipeline.cc
-FILE: ../../../flutter/shell/common/pipeline.h
-FILE: ../../../flutter/shell/common/pipeline_unittests.cc
 FILE: ../../../flutter/shell/common/platform_view.cc
 FILE: ../../../flutter/shell/common/platform_view.h
 FILE: ../../../flutter/shell/common/pointer_data_dispatcher.cc

shell/common/BUILD.gn

@@ -87,10 +87,10 @@ source_set("common") {
     "engine.h",
     "isolate_configuration.cc",
     "isolate_configuration.h",
+    "layer_tree_holder.cc",
+    "layer_tree_holder.h",
     "persistent_cache.cc",
     "persistent_cache.h",
-    "pipeline.cc",
-    "pipeline.h",
     "platform_view.cc",
     "platform_view.h",
     "pointer_data_dispatcher.cc",
@@ -189,7 +189,6 @@ if (enable_unittests) {
       "canvas_spy_unittests.cc",
       "input_events_unittests.cc",
       "persistent_cache_unittests.cc",
-      "pipeline_unittests.cc",
       "shell_test.cc",
       "shell_test.h",
       "shell_test_external_view_embedder.cc",

shell/common/animator.cc

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "flutter/shell/common/animator.h"
+#include <memory>
 
 #include "flutter/fml/trace_event.h"
 #include "third_party/dart/runtime/include/dart_tools_api.h"
@@ -28,27 +29,15 @@ Animator::Animator(Delegate& delegate,
       last_frame_begin_time_(),
       last_frame_target_time_(),
       dart_frame_deadline_(0),
-#if FLUTTER_SHELL_ENABLE_METAL
-      layer_tree_pipeline_(fml::MakeRefCounted<LayerTreePipeline>(2)),
-#else   // FLUTTER_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_(fml::MakeRefCounted<LayerTreePipeline>(
-          task_runners.GetPlatformTaskRunner() ==
-                  task_runners.GetRasterTaskRunner()
-              ? 1
-              : 2)),
-#endif  // FLUTTER_SHELL_ENABLE_METAL
+      layer_tree_holder_(std::make_shared<LayerTreeHolder>()),
       pending_frame_semaphore_(1),
       frame_number_(1),
       paused_(false),
       regenerate_layer_tree_(false),
       frame_scheduled_(false),
       notify_idle_task_id_(0),
       dimension_change_pending_(false),
-      weak_factory_(this) {
-}
+      weak_factory_(this) {}
 
 Animator::~Animator() = default;
 
@@ -114,25 +103,6 @@ void Animator::BeginFrame(fml::TimePoint frame_start_time,
   regenerate_layer_tree_ = false;
   pending_frame_semaphore_.Signal();
 
-  if (!producer_continuation_) {
-    // We may already have a valid pipeline continuation in case a previous
-    // begin frame did not result in an Animation::Render. Simply reuse that
-    // instead of asking the pipeline for a fresh continuation.
-    producer_continuation_ = layer_tree_pipeline_->Produce();
-
-    if (!producer_continuation_) {
-      // If we still don't have valid continuation, the pipeline is currently
-      // full because the consumer is being too slow. Try again at the next
-      // frame interval.
-      RequestFrame();
-      return;
-    }
-  }
-
-  // We have acquired a valid continuation from the pipeline and are ready
-  // to service potential frame.
-  FML_DCHECK(producer_continuation_);
-
   last_frame_begin_time_ = frame_start_time;
   last_frame_target_time_ = frame_target_time;
   dart_frame_deadline_ = FxlToDartOrEarlier(frame_target_time);
@@ -184,13 +154,8 @@ void Animator::Render(std::unique_ptr<flutter::LayerTree> layer_tree) {
                                 last_frame_target_time_);
   }
 
-  // Commit the pending continuation.
-  bool result = producer_continuation_.Complete(std::move(layer_tree));
-  if (!result) {
-    FML_DLOG(INFO) << "No pending continuation to commit";
-  }
-
-  delegate_.OnAnimatorDraw(layer_tree_pipeline_);
+  layer_tree_holder_->ReplaceIfNewer(std::move(layer_tree));
+  delegate_.OnAnimatorDraw(layer_tree_holder_);
 }
 
 bool Animator::CanReuseLastLayerTree() {

shell/common/animator.h

@@ -6,13 +6,14 @@
 #define FLUTTER_SHELL_COMMON_ANIMATOR_H_
 
 #include <deque>
+#include <memory>
 
 #include "flutter/common/task_runners.h"
 #include "flutter/fml/memory/ref_ptr.h"
 #include "flutter/fml/memory/weak_ptr.h"
 #include "flutter/fml/synchronization/semaphore.h"
 #include "flutter/fml/time/time_point.h"
-#include "flutter/shell/common/pipeline.h"
+#include "flutter/shell/common/layer_tree_holder.h"
 #include "flutter/shell/common/rasterizer.h"
 #include "flutter/shell/common/vsync_waiter.h"
 
@@ -35,7 +36,7 @@ class Animator final {
     virtual void OnAnimatorNotifyIdle(int64_t deadline) = 0;
 
     virtual void OnAnimatorDraw(
-        fml::RefPtr<Pipeline<flutter::LayerTree>> pipeline) = 0;
+        std::shared_ptr<LayerTreeHolder> layer_tree_holder) = 0;
 
     virtual void OnAnimatorDrawLastLayerTree() = 0;
   };
@@ -80,8 +81,6 @@ class Animator final {
   void EnqueueTraceFlowId(uint64_t trace_flow_id);
 
  private:
-  using LayerTreePipeline = Pipeline<flutter::LayerTree>;
-
   void BeginFrame(fml::TimePoint frame_start_time,
                   fml::TimePoint frame_target_time);
 
@@ -99,9 +98,8 @@ class Animator final {
   fml::TimePoint last_frame_begin_time_;
   fml::TimePoint last_frame_target_time_;
   int64_t dart_frame_deadline_;
-  fml::RefPtr<LayerTreePipeline> layer_tree_pipeline_;
+  std::shared_ptr<LayerTreeHolder> layer_tree_holder_;
   fml::Semaphore pending_frame_semaphore_;
-  LayerTreePipeline::ProducerContinuation producer_continuation_;
   int64_t frame_number_;
   bool paused_;
   bool regenerate_layer_tree_;

shell/common/layer_tree_holder.cc

@@ -0,0 +1,28 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "flutter/shell/common/layer_tree_holder.h"
+
+namespace flutter {
+
+std::unique_ptr<LayerTree> LayerTreeHolder::Get() {
+  std::scoped_lock lock(layer_tree_mutex);
+  return std::move(layer_tree_);
+}
+
+void LayerTreeHolder::ReplaceIfNewer(std::unique_ptr<LayerTree> layer_tree) {
+  std::scoped_lock lock(layer_tree_mutex);
+  if (IsEmpty()) {
+    layer_tree_ = std::move(layer_tree);
+  } else if (layer_tree_->target_time() < layer_tree->target_time()) {
+    layer_tree_ = std::move(layer_tree);
+  }
+}
+
+bool LayerTreeHolder::IsEmpty() const {
+  std::scoped_lock lock(layer_tree_mutex);
+  return !layer_tree_;
+}
+
+};  // namespace flutter

shell/common/layer_tree_holder.h

@@ -0,0 +1,35 @@
+// Copyright 2013 The Flutter 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_SHELL_COMMON_LAYER_TREE_HOLDER_H_
+#define FLUTTER_SHELL_COMMON_LAYER_TREE_HOLDER_H_
+
+#include <memory>
+
+#include "flow/layers/layer_tree.h"
+
+namespace flutter {
+
+class LayerTreeHolder {
+ public:
+  LayerTreeHolder() = default;
+
+  ~LayerTreeHolder() = default;
+
+  bool IsEmpty() const;
+
+  std::unique_ptr<LayerTree> Get();
+
+  void ReplaceIfNewer(std::unique_ptr<LayerTree> layer_tree);
+
+ private:
+  mutable std::mutex layer_tree_mutex;
+  std::unique_ptr<LayerTree> layer_tree_;
+
+  FML_DISALLOW_COPY_AND_ASSIGN(LayerTreeHolder);
+};
+
+};  // namespace flutter
+
+#endif  // FLUTTER_SHELL_COMMON_LAYER_TREE_HOLDER_H_