fix fuchsia, fix test for AOT

Author: dnfield

flow/compositor_context.cc

@@ -9,9 +9,10 @@
 
 namespace flutter {
 
-CompositorContext::CompositorContext(Delegate& delegate,
-                                     fml::Milliseconds frame_budget)
-    : delegate_(delegate), raster_time_(frame_budget), ui_time_(frame_budget) {}
+CompositorContext::CompositorContext(Delegate& delegate)
+    : delegate_(delegate),
+      raster_time_(delegate.GetFrameBudget()),
+      ui_time_(delegate.GetFrameBudget()) {}
 
 CompositorContext::~CompositorContext() = default;
 

flow/compositor_context.h

@@ -39,7 +39,11 @@ class CompositorContext {
  public:
   class Delegate {
    public:
+    /// Called at the end of a frame with approximately how many bytes mightbe
+    /// freed if a GC ran now.
     virtual void OnCompositorEndFrame(size_t freed_hint) = 0;
+    /// Time limit for a smooth frame. See `Engine::GetDisplayRefreshRate`.
+    virtual fml::Milliseconds GetFrameBudget() = 0;
   };
 
   class ScopedFrame {
@@ -88,8 +92,7 @@ class CompositorContext {
     FML_DISALLOW_COPY_AND_ASSIGN(ScopedFrame);
   };
 
-  CompositorContext(Delegate& delegate,
-                    fml::Milliseconds frame_budget = fml::kDefaultFrameBudget);
+  explicit CompositorContext(Delegate& delegate);
 
   virtual ~CompositorContext();
 

flow/layers/layer_tree_unittests.cc

@@ -23,7 +23,7 @@ class LayerTreeTest : public CanvasTest, public CompositorContext::Delegate {
  public:
   LayerTreeTest()
       : layer_tree_(SkISize::Make(64, 64), 100.0f, 1.0f),
-        compositor_context_(*this, fml::kDefaultFrameBudget),
+        compositor_context_(*this),
         root_transform_(SkMatrix::Translate(1.0f, 1.0f)),
         scoped_frame_(compositor_context_.AcquireFrame(nullptr,
                                                        &mock_canvas(),
@@ -37,10 +37,15 @@ class LayerTreeTest : public CanvasTest, public CompositorContext::Delegate {
   CompositorContext::ScopedFrame& frame() { return *scoped_frame_.get(); }
   const SkMatrix& root_transform() { return root_transform_; }
 
+
   void OnCompositorEndFrame(size_t freed_hint) override {
     last_freed_hint_ = freed_hint;
   }
 
+  fml::Milliseconds GetFrameBudget() override {
+    return fml::kDefaultFrameBudget;
+  }
+
   size_t last_freed_hint() { return last_freed_hint_; }
 
  private:

lib/ui/painting/image_release_unittests.cc

@@ -43,11 +43,12 @@ TEST_F(ShellTest, ImageReleasedAfterFrame) {
   auto nativeDone = [&](Dart_NativeArguments args) { message_latch.Signal(); };
 
   Settings settings = CreateSettingsForFixture();
+  auto task_runner = CreateNewThread();
   TaskRunners task_runners("test",                  // label
                            GetCurrentTaskRunner(),  // platform
-                           CreateNewThread(),       // raster
-                           CreateNewThread(),       // ui
-                           CreateNewThread()        // io
+                           task_runner,             // raster
+                           task_runner,             // ui
+                           task_runner              // io
   );
 
   AddNativeCallback("CaptureImageAndPicture",
@@ -74,22 +75,19 @@ TEST_F(ShellTest, ImageReleasedAfterFrame) {
   ASSERT_TRUE(current_picture);
   ASSERT_TRUE(current_image);
 
-  ASSERT_FALSE(current_picture->unique());
-  ASSERT_FALSE(current_image->unique());
-
-  // Drain the raster task runner to get to the end of the frame.
-  fml::AutoResetWaitableEvent latch;
-  task_runners.GetRasterTaskRunner()->PostTask([&latch]() { latch.Signal(); });
-  latch.Wait();
-
-  // Tell the engine we're idle.
-  task_runners.GetUITaskRunner()->PostTask(
-      [&latch, engine = shell->GetEngine()]() {
-        ASSERT_TRUE(engine);
-        engine->NotifyIdle(Dart_TimelineGetMicros() + 10000);
-        latch.Signal();
-      });
-  latch.Wait();
+  // AOT modes are fast enough that we get here before the task runner has
+  // had a chance to drain. Make sure that if the picture or image are not
+  // already unique, at least one idle notification has a chance to process
+  // after rasterization has occurred.
+  if (!current_picture->unique() || !current_image->unique()) {
+    fml::AutoResetWaitableEvent latch;
+    task_runner->PostTask([&latch, engine = shell->GetEngine()]() {
+      ASSERT_TRUE(engine);
+      engine->NotifyIdle(Dart_TimelineGetMicros() + 10000);
+      latch.Signal();
+    });
+    latch.Wait();
+  }
 
   EXPECT_TRUE(current_picture->unique());
   current_picture.reset();

shell/common/rasterizer.cc

@@ -27,9 +27,7 @@ static constexpr std::chrono::milliseconds kSkiaCleanupExpiration(15000);
 
 Rasterizer::Rasterizer(Delegate& delegate)
     : Rasterizer(delegate,
-                 std::make_unique<flutter::CompositorContext>(
-                     *this,
-                     delegate.GetFrameBudget())) {}
+                 std::make_unique<flutter::CompositorContext>(delegate)) {}
 
 Rasterizer::Rasterizer(
     Delegate& delegate,
@@ -264,10 +262,6 @@ sk_sp<SkImage> Rasterizer::ConvertToRasterImage(sk_sp<SkImage> image) {
                               });
 }
 
-void Rasterizer::OnCompositorEndFrame(size_t freed_hint) {
-  delegate_.OnCompositorFrameEnd(freed_hint);
-}
-
 RasterStatus Rasterizer::DoDraw(
     std::unique_ptr<flutter::LayerTree> layer_tree) {
   FML_DCHECK(delegate_.GetTaskRunners()

shell/common/rasterizer.h

@@ -38,8 +38,7 @@ namespace flutter {
 /// and the on-screen render surface. The compositor context has all the GPU
 /// state necessary to render frames to the render surface.
 ///
-class Rasterizer final : public SnapshotDelegate,
-                         public CompositorContext::Delegate {
+class Rasterizer final : public SnapshotDelegate {
  public:
   //----------------------------------------------------------------------------
   /// @brief      Used to forward events from the rasterizer to interested
@@ -51,7 +50,7 @@ class Rasterizer final : public SnapshotDelegate,
   ///             are made on the GPU task runner. Any delegate must ensure that
   ///             they can handle the threading implications.
   ///
-  class Delegate {
+  class Delegate : public CompositorContext::Delegate {
    public:
     //--------------------------------------------------------------------------
     /// @brief      Notifies the delegate that a frame has been rendered. The
@@ -69,8 +68,6 @@ class Rasterizer final : public SnapshotDelegate,
     ///
     virtual void OnFrameRasterized(const FrameTiming& frame_timing) = 0;
 
-    virtual void OnCompositorFrameEnd(size_t freed_hint) = 0;
-
     /// Time limit for a smooth frame. See `Engine::GetDisplayRefreshRate`.
     virtual fml::Milliseconds GetFrameBudget() = 0;
 
@@ -415,9 +412,6 @@ class Rasterizer final : public SnapshotDelegate,
   // |SnapshotDelegate|
   sk_sp<SkImage> ConvertToRasterImage(sk_sp<SkImage> image) override;
 
-  // |CompositorContext::Delegate|
-  void OnCompositorEndFrame(size_t freed_hint) override;
-
   sk_sp<SkData> ScreenshotLayerTreeAsImage(
       flutter::LayerTree* tree,
       flutter::CompositorContext& compositor_context,

shell/common/shell.cc

@@ -1200,7 +1200,7 @@ void Shell::OnFrameRasterized(const FrameTiming& timing) {
   }
 }
 
-void Shell::OnCompositorFrameEnd(size_t freed_hint) {
+void Shell::OnCompositorEndFrame(size_t freed_hint) {
   if (engine_) {
     engine_->HintFreed(freed_hint);
   }

shell/common/shell.h

@@ -12,6 +12,7 @@
 
 #include "flutter/common/settings.h"
 #include "flutter/common/task_runners.h"
+#include "flutter/flow/compositor_context.h"
 #include "flutter/flow/surface.h"
 #include "flutter/flow/texture.h"
 #include "flutter/fml/closure.h"
@@ -528,13 +529,14 @@ class Shell final : public PlatformView::Delegate,
   void OnFrameRasterized(const FrameTiming&) override;
 
   // |Rasterizer::Delegate|
-  void OnCompositorFrameEnd(size_t freed_hint) override;
+  fml::TimePoint GetLatestFrameTargetTime() const override;
 
   // |Rasterizer::Delegate|
+  // |CompositorContext::Delegate|
   fml::Milliseconds GetFrameBudget() override;
 
-  // |Rasterizer::Delegate|
-  fml::TimePoint GetLatestFrameTargetTime() const override;
+  // |CompositorContext::Delegate|
+  void OnCompositorEndFrame(size_t freed_hint) override;
 
   // |ServiceProtocol::Handler|
   fml::RefPtr<fml::TaskRunner> GetServiceProtocolHandlerTaskRunner(

shell/platform/fuchsia/flutter/compositor_context.cc

@@ -65,13 +65,15 @@ class ScopedFrame final : public flutter::CompositorContext::ScopedFrame {
 };
 
 CompositorContext::CompositorContext(
+    flutter::CompositorContext::Delegate& delegate,
     std::string debug_label,
     fuchsia::ui::views::ViewToken view_token,
     scenic::ViewRefPair view_ref_pair,
     fidl::InterfaceHandle<fuchsia::ui::scenic::Session> session,
     fml::closure session_error_callback,
     zx_handle_t vsync_event_handle)
-    : debug_label_(std::move(debug_label)),
+    : flutter::CompositorContext(delegate),
+      debug_label_(std::move(debug_label)),
       session_connection_(
           debug_label_,
           std::move(view_token),

shell/platform/fuchsia/flutter/compositor_context.h

@@ -21,7 +21,8 @@ namespace flutter_runner {
 // Fuchsia.
 class CompositorContext final : public flutter::CompositorContext {
  public:
-  CompositorContext(std::string debug_label,
+  CompositorContext(CompositorContext::Delegate& delegate,
+                    std::string debug_label,
                     fuchsia::ui::views::ViewToken view_token,
                     scenic::ViewRefPair view_ref_pair,
                     fidl::InterfaceHandle<fuchsia::ui::scenic::Session> session,

shell/platform/fuchsia/flutter/engine.cc

@@ -221,6 +221,7 @@ Engine::Engine(Delegate& delegate,
           TRACE_DURATION("flutter", "CreateCompositorContext");
           compositor_context =
               std::make_unique<flutter_runner::CompositorContext>(
+                  shell,
                   thread_label,           // debug label
                   std::move(view_token),  // scenic view we attach our tree to
                   std::move(view_ref_pair),  // scenic view ref/view ref control