Reland "Improve iOS PlatformViews to better handle thread merging. flutter#16935" (flutter#17609)

Author: Chris Yang

ci/licenses_golden/licenses_flutter

@@ -592,6 +592,8 @@ FILE: ../../../flutter/shell/common/shell_io_manager.cc
 FILE: ../../../flutter/shell/common/shell_io_manager.h
 FILE: ../../../flutter/shell/common/shell_test.cc
 FILE: ../../../flutter/shell/common/shell_test.h
+FILE: ../../../flutter/shell/common/shell_test_external_view_embedder.cc
+FILE: ../../../flutter/shell/common/shell_test_external_view_embedder.h
 FILE: ../../../flutter/shell/common/shell_test_platform_view.cc
 FILE: ../../../flutter/shell/common/shell_test_platform_view.h
 FILE: ../../../flutter/shell/common/shell_test_platform_view_gl.cc

flow/embedded_views.h

@@ -253,6 +253,18 @@ class ExternalViewEmbedder {
   // This is called after submitting the embedder frame and the surface frame.
   virtual void FinishFrame();
 
+  // This should only be called after |SubmitFrame|.
+  // This method provides the embedder a way to do additional tasks after
+  // |SubmitFrame|. After invoking this method, the current task on the
+  // TaskRunner should end immediately.
+  //
+  // For example on the iOS embedder, threads are merged in this call.
+  // A new frame on the platform thread starts immediately. If the GPU thread
+  // still has some task running, there could be two frames being rendered
+  // concurrently, which causes undefined behaviors.
+  virtual void EndFrame(
+      fml::RefPtr<fml::RasterThreadMerger> raster_thread_merger) {}
+
   FML_DISALLOW_COPY_AND_ASSIGN(ExternalViewEmbedder);
 
 };  // ExternalViewEmbedder

shell/common/BUILD.gn

@@ -191,6 +191,8 @@ if (enable_unittests) {
       "pipeline_unittests.cc",
       "shell_test.cc",
       "shell_test.h",
+      "shell_test_external_view_embedder.cc",
+      "shell_test_external_view_embedder.h",
       "shell_test_platform_view.cc",
       "shell_test_platform_view.h",
       "shell_unittests.cc",

shell/common/animator_unittests.cc

@@ -55,7 +55,7 @@ TEST_F(ShellTest, VSyncTargetTime) {
           return ShellTestPlatformView::Create(
               shell, shell.GetTaskRunners(), vsync_clock,
               std::move(create_vsync_waiter),
-              ShellTestPlatformView::BackendType::kDefaultBackend);
+              ShellTestPlatformView::BackendType::kDefaultBackend, nullptr);
         },
         [](Shell& shell) {
           return std::make_unique<Rasterizer>(shell, shell.GetTaskRunners());

shell/common/rasterizer.cc

@@ -136,6 +136,16 @@ void Rasterizer::Draw(fml::RefPtr<Pipeline<flutter::LayerTree>> pipeline) {
     consume_result = PipelineConsumeResult::MoreAvailable;
   }
 
+  // Merging the thread as we know the next `Draw` should be run on the platform
+  // thread.
+  if (raster_status == RasterStatus::kResubmit) {
+    auto* external_view_embedder = surface_->GetExternalViewEmbedder();
+    // We know only the `external_view_embedder` can
+    // causes|RasterStatus::kResubmit|. Check to make sure.
+    FML_DCHECK(external_view_embedder != nullptr);
+    external_view_embedder->EndFrame(raster_thread_merger_);
+  }
+
   // Consume as many pipeline items as possible. But yield the event loop
   // between successive tries.
   switch (consume_result) {

shell/common/shell_test.cc

@@ -271,9 +271,12 @@ std::unique_ptr<Shell> ShellTest::CreateShell(Settings settings,
                      simulate_vsync);
 }
 
-std::unique_ptr<Shell> ShellTest::CreateShell(Settings settings,
-                                              TaskRunners task_runners,
-                                              bool simulate_vsync) {
+std::unique_ptr<Shell> ShellTest::CreateShell(
+    Settings settings,
+    TaskRunners task_runners,
+    bool simulate_vsync,
+    std::shared_ptr<ShellTestExternalViewEmbedder>
+        shell_test_external_view_embedder) {
   const auto vsync_clock = std::make_shared<ShellTestVsyncClock>();
   CreateVsyncWaiter create_vsync_waiter = [&]() {
     if (simulate_vsync) {
@@ -286,17 +289,18 @@ std::unique_ptr<Shell> ShellTest::CreateShell(Settings settings,
   };
   return Shell::Create(
       task_runners, settings,
-      [vsync_clock, &create_vsync_waiter](Shell& shell) {
+      [vsync_clock, &create_vsync_waiter,
+       shell_test_external_view_embedder](Shell& shell) {
         return ShellTestPlatformView::Create(
             shell, shell.GetTaskRunners(), vsync_clock,
             std::move(create_vsync_waiter),
-            ShellTestPlatformView::BackendType::kDefaultBackend);
+            ShellTestPlatformView::BackendType::kDefaultBackend,
+            shell_test_external_view_embedder);
       },
       [](Shell& shell) {
         return std::make_unique<Rasterizer>(shell, shell.GetTaskRunners());
       });
 }
-
 void ShellTest::DestroyShell(std::unique_ptr<Shell> shell) {
   DestroyShell(std::move(shell), GetTaskRunnersForFixture());
 }

shell/common/shell_test.h

@@ -16,6 +16,7 @@
 #include "flutter/shell/common/persistent_cache.h"
 #include "flutter/shell/common/run_configuration.h"
 #include "flutter/shell/common/shell.h"
+#include "flutter/shell/common/shell_test_external_view_embedder.h"
 #include "flutter/shell/common/thread_host.h"
 #include "flutter/shell/common/vsync_waiters_test.h"
 #include "flutter/testing/elf_loader.h"
@@ -32,9 +33,12 @@ class ShellTest : public ThreadTest {
   Settings CreateSettingsForFixture();
   std::unique_ptr<Shell> CreateShell(Settings settings,
                                      bool simulate_vsync = false);
-  std::unique_ptr<Shell> CreateShell(Settings settings,
-                                     TaskRunners task_runners,
-                                     bool simulate_vsync = false);
+  std::unique_ptr<Shell> CreateShell(
+      Settings settings,
+      TaskRunners task_runners,
+      bool simulate_vsync = false,
+      std::shared_ptr<ShellTestExternalViewEmbedder>
+          shell_test_external_view_embedder = nullptr);
   void DestroyShell(std::unique_ptr<Shell> shell);
   void DestroyShell(std::unique_ptr<Shell> shell, TaskRunners task_runners);
   TaskRunners GetTaskRunnersForFixture();

shell/common/shell_test_external_view_embedder.cc

@@ -0,0 +1,55 @@
+#include "shell_test_external_view_embedder.h"
+
+namespace flutter {
+
+// |ExternalViewEmbedder|
+void ShellTestExternalViewEmbedder::CancelFrame() {}
+
+// |ExternalViewEmbedder|
+void ShellTestExternalViewEmbedder::BeginFrame(SkISize frame_size,
+                                               GrContext* context,
+                                               double device_pixel_ratio) {}
+
+// |ExternalViewEmbedder|
+void ShellTestExternalViewEmbedder::PrerollCompositeEmbeddedView(
+    int view_id,
+    std::unique_ptr<EmbeddedViewParams> params) {}
+
+// |ExternalViewEmbedder|
+PostPrerollResult ShellTestExternalViewEmbedder::PostPrerollAction(
+    fml::RefPtr<fml::RasterThreadMerger> raster_thread_merger) {
+  FML_DCHECK(raster_thread_merger);
+  return post_preroll_result_;
+}
+
+// |ExternalViewEmbedder|
+std::vector<SkCanvas*> ShellTestExternalViewEmbedder::GetCurrentCanvases() {
+  return {};
+}
+
+// |ExternalViewEmbedder|
+SkCanvas* ShellTestExternalViewEmbedder::CompositeEmbeddedView(int view_id) {
+  return nullptr;
+}
+
+// |ExternalViewEmbedder|
+bool ShellTestExternalViewEmbedder::SubmitFrame(GrContext* context,
+                                                SkCanvas* background_canvas) {
+  return true;
+}
+
+// |ExternalViewEmbedder|
+void ShellTestExternalViewEmbedder::FinishFrame() {}
+
+// |ExternalViewEmbedder|
+void ShellTestExternalViewEmbedder::EndFrame(
+    fml::RefPtr<fml::RasterThreadMerger> raster_thread_merger) {
+  end_frame_call_back_();
+}
+
+// |ExternalViewEmbedder|
+SkCanvas* ShellTestExternalViewEmbedder::GetRootCanvas() {
+  return nullptr;
+}
+
+}  // namespace flutter

shell/common/shell_test_external_view_embedder.h

@@ -0,0 +1,72 @@
+// 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_TEST_EXTERNAL_VIEW_EMBEDDER_H_
+#define FLUTTER_SHELL_TEST_EXTERNAL_VIEW_EMBEDDER_H_
+
+#include "flutter/flow/embedded_views.h"
+#include "flutter/fml/raster_thread_merger.h"
+
+namespace flutter {
+
+//------------------------------------------------------------------------------
+/// @brief The external view embedder used by |ShellTestPlatformViewGL|
+///
+class ShellTestExternalViewEmbedder final : public ExternalViewEmbedder {
+ public:
+  using EndFrameCallBack = std::function<void(void)>;
+
+  ShellTestExternalViewEmbedder(const EndFrameCallBack& end_frame_call_back,
+                                PostPrerollResult post_preroll_result)
+      : end_frame_call_back_(end_frame_call_back),
+        post_preroll_result_(post_preroll_result) {}
+
+  ~ShellTestExternalViewEmbedder() = default;
+
+ private:
+  // |ExternalViewEmbedder|
+  void CancelFrame() override;
+
+  // |ExternalViewEmbedder|
+  void BeginFrame(SkISize frame_size,
+                  GrContext* context,
+                  double device_pixel_ratio) override;
+
+  // |ExternalViewEmbedder|
+  void PrerollCompositeEmbeddedView(
+      int view_id,
+      std::unique_ptr<EmbeddedViewParams> params) override;
+
+  // |ExternalViewEmbedder|
+  PostPrerollResult PostPrerollAction(
+      fml::RefPtr<fml::RasterThreadMerger> raster_thread_merger) override;
+
+  // |ExternalViewEmbedder|
+  std::vector<SkCanvas*> GetCurrentCanvases() override;
+
+  // |ExternalViewEmbedder|
+  SkCanvas* CompositeEmbeddedView(int view_id) override;
+
+  // |ExternalViewEmbedder|
+  bool SubmitFrame(GrContext* context, SkCanvas* background_canvas) override;
+
+  // |ExternalViewEmbedder|
+  void FinishFrame() override;
+
+  // |ExternalViewEmbedder|
+  void EndFrame(
+      fml::RefPtr<fml::RasterThreadMerger> raster_thread_merger) override;
+
+  // |ExternalViewEmbedder|
+  SkCanvas* GetRootCanvas() override;
+
+  const EndFrameCallBack end_frame_call_back_;
+  const PostPrerollResult post_preroll_result_;
+
+  FML_DISALLOW_COPY_AND_ASSIGN(ShellTestExternalViewEmbedder);
+};
+
+}  // namespace flutter
+
+#endif  // FLUTTER_SHELL_TEST_EXTERNAL_VIEW_EMBEDDER_H_

shell/common/shell_test_platform_view.cc

@@ -19,20 +19,24 @@ std::unique_ptr<ShellTestPlatformView> ShellTestPlatformView::Create(
     TaskRunners task_runners,
     std::shared_ptr<ShellTestVsyncClock> vsync_clock,
     CreateVsyncWaiter create_vsync_waiter,
-    BackendType backend) {
+    BackendType backend,
+    std::shared_ptr<ShellTestExternalViewEmbedder>
+        shell_test_external_view_embedder) {
   // TODO(gw280): https://github.com/flutter/flutter/issues/50298
   // Make this fully runtime configurable
   switch (backend) {
     case BackendType::kDefaultBackend:
 #ifdef SHELL_ENABLE_GL
     case BackendType::kGLBackend:
       return std::make_unique<ShellTestPlatformViewGL>(
-          delegate, task_runners, vsync_clock, create_vsync_waiter);
+          delegate, task_runners, vsync_clock, create_vsync_waiter,
+          shell_test_external_view_embedder);
 #endif  // SHELL_ENABLE_GL
 #ifdef SHELL_ENABLE_VULKAN
     case BackendType::kVulkanBackend:
       return std::make_unique<ShellTestPlatformViewVulkan>(
-          delegate, task_runners, vsync_clock, create_vsync_waiter);
+          delegate, task_runners, vsync_clock, create_vsync_waiter,
+          shell_test_external_view_embedder);
 #endif  // SHELL_ENABLE_VULKAN
     default:
       FML_LOG(FATAL) << "No backends supported for ShellTestPlatformView";