fuchsia: create new flutter_runner render path (#19584)

Author: arbreng

ci/licenses_golden/licenses_flutter

@@ -1162,6 +1162,8 @@ FILE: ../../../flutter/shell/platform/fuchsia/flutter/engine.h
 FILE: ../../../flutter/shell/platform/fuchsia/flutter/flutter_runner_fakes.h
 FILE: ../../../flutter/shell/platform/fuchsia/flutter/flutter_runner_product_configuration.cc
 FILE: ../../../flutter/shell/platform/fuchsia/flutter/flutter_runner_product_configuration.h
+FILE: ../../../flutter/shell/platform/fuchsia/flutter/fuchsia_external_view_embedder.cc
+FILE: ../../../flutter/shell/platform/fuchsia/flutter/fuchsia_external_view_embedder.h
 FILE: ../../../flutter/shell/platform/fuchsia/flutter/fuchsia_intl.cc
 FILE: ../../../flutter/shell/platform/fuchsia/flutter/fuchsia_intl.h
 FILE: ../../../flutter/shell/platform/fuchsia/flutter/fuchsia_intl_unittest.cc

shell/platform/fuchsia/flutter/BUILD.gn

@@ -53,12 +53,12 @@ template("runner_sources") {
       "accessibility_bridge.h",
       "component.cc",
       "component.h",
-      "compositor_context.cc",
-      "compositor_context.h",
       "engine.cc",
       "engine.h",
       "flutter_runner_product_configuration.cc",
       "flutter_runner_product_configuration.h",
+      "fuchsia_external_view_embedder.cc",
+      "fuchsia_external_view_embedder.h",
       "fuchsia_intl.cc",
       "fuchsia_intl.h",
       "isolate_configurator.cc",
@@ -92,6 +92,12 @@ template("runner_sources") {
       "vulkan_surface_producer.cc",
       "vulkan_surface_producer.h",
     ]
+    if (flutter_enable_legacy_fuchsia_embedder) {
+      sources += [
+        "compositor_context.cc",
+        "compositor_context.h",
+      ]
+    }
 
     public_configs = runner_configs
 

shell/platform/fuchsia/flutter/component.cc

@@ -54,6 +54,7 @@ constexpr char kDataKey[] = "data";
 constexpr char kAssetsKey[] = "assets";
 constexpr char kTmpPath[] = "/tmp";
 constexpr char kServiceRootPath[] = "/svc";
+constexpr char kRunnerConfigPath[] = "/config/data/flutter_runner_config";
 
 // static
 void Application::ParseProgramMetadata(
@@ -346,11 +347,13 @@ Application::Application(
     }
   }
 
-  // Load and use product-specific configuration, if it exists.
+  // Load and use runner-specific configuration, if it exists.
   std::string json_string;
-  if (dart_utils::ReadFileToString(
-          "/config/data/frame_scheduling_performance_values", &json_string)) {
+  if (dart_utils::ReadFileToString(kRunnerConfigPath, &json_string)) {
     product_config_ = FlutterRunnerProductConfiguration(json_string);
+  } else {
+    FML_LOG(WARNING) << "Failed to load runner configuration from "
+                     << kRunnerConfigPath << "; using default config values.";
   }
 
 #if defined(DART_PRODUCT)

shell/platform/fuchsia/flutter/engine.cc

@@ -8,21 +8,27 @@
 #include <zircon/status.h>
 
 #include "../runtime/dart/utils/files.h"
-#include "compositor_context.h"
 #include "flutter/common/task_runners.h"
 #include "flutter/fml/make_copyable.h"
 #include "flutter/fml/synchronization/waitable_event.h"
 #include "flutter/fml/task_runner.h"
 #include "flutter/runtime/dart_vm_lifecycle.h"
 #include "flutter/shell/common/rasterizer.h"
 #include "flutter/shell/common/run_configuration.h"
+#include "third_party/skia/include/ports/SkFontMgr_fuchsia.h"
+
 #include "flutter_runner_product_configuration.h"
+#include "fuchsia_external_view_embedder.h"
 #include "fuchsia_intl.h"
 #include "platform_view.h"
+#include "surface.h"
 #include "task_runner_adapter.h"
-#include "third_party/skia/include/ports/SkFontMgr_fuchsia.h"
 #include "thread.h"
 
+#if defined(LEGACY_FUCHSIA_EMBEDDER)
+#include "compositor_context.h"  // nogncheck
+#endif
+
 namespace flutter_runner {
 namespace {
 
@@ -65,6 +71,9 @@ Engine::Engine(Delegate& delegate,
                FlutterRunnerProductConfiguration product_config)
     : delegate_(delegate),
       thread_label_(std::move(thread_label)),
+#if defined(LEGACY_FUCHSIA_EMBEDDER)
+      use_legacy_renderer_(product_config.use_legacy_renderer()),
+#endif
       weak_factory_(this) {
   if (zx::event::create(0, &vsync_event_) != ZX_OK) {
     FML_DLOG(ERROR) << "Could not create the vsync event.";
@@ -124,9 +133,18 @@ Engine::Engine(Delegate& delegate,
             thread_label_, std::move(session),
             std::move(session_error_callback), [](auto) {}, vsync_handle);
         surface_producer_.emplace(session_connection_->get());
-        scene_update_context_.emplace(thread_label_, std::move(view_token),
-                                      std::move(view_ref_pair),
-                                      session_connection_.value());
+#if defined(LEGACY_FUCHSIA_EMBEDDER)
+        if (use_legacy_renderer_) {
+          legacy_external_view_embedder_.emplace(
+              thread_label_, std::move(view_token), std::move(view_ref_pair),
+              session_connection_.value());
+        } else
+#endif
+        {
+          external_view_embedder_.emplace(
+              thread_label_, std::move(view_token), std::move(view_ref_pair),
+              session_connection_.value(), surface_producer_.value());
+        }
       }));
 
   // Grab the parent environment services. The platform view may want to
@@ -152,11 +170,8 @@ Engine::Engine(Delegate& delegate,
   OnDestroyView on_destroy_view_callback =
       std::bind(&Engine::DestroyView, this, std::placeholders::_1);
 
-  OnGetViewEmbedder on_get_view_embedder_callback =
-      std::bind(&Engine::GetViewEmbedder, this);
-
-  OnGetGrContext on_get_gr_context_callback =
-      std::bind(&Engine::GetGrContext, this);
+  OnCreateSurface on_create_surface_callback =
+      std::bind(&Engine::CreateSurface, this);
 
   // SessionListener has a OnScenicError method; invoke this callback on the
   // platform thread when that happens. The Session itself should also be
@@ -187,11 +202,9 @@ Engine::Engine(Delegate& delegate,
            on_create_view_callback = std::move(on_create_view_callback),
            on_update_view_callback = std::move(on_update_view_callback),
            on_destroy_view_callback = std::move(on_destroy_view_callback),
-           on_get_view_embedder_callback =
-               std::move(on_get_view_embedder_callback),
-           on_get_gr_context_callback = std::move(on_get_gr_context_callback),
-           vsync_handle = vsync_event_.get(),
-           product_config = product_config](flutter::Shell& shell) mutable {
+           on_create_surface_callback = std::move(on_create_surface_callback),
+           vsync_offset = product_config.get_vsync_offset(),
+           vsync_handle = vsync_event_.get()](flutter::Shell& shell) mutable {
             return std::make_unique<flutter_runner::PlatformView>(
                 shell,                   // delegate
                 debug_label,             // debug label
@@ -206,27 +219,35 @@ Engine::Engine(Delegate& delegate,
                 std::move(on_create_view_callback),
                 std::move(on_update_view_callback),
                 std::move(on_destroy_view_callback),
-                std::move(on_get_view_embedder_callback),
-                std::move(on_get_gr_context_callback),
-                vsync_handle,  // vsync handle
-                product_config);
+                std::move(on_create_surface_callback),
+                std::move(vsync_offset),  // vsync offset
+                vsync_handle);
           });
 
   // Setup the callback that will instantiate the rasterizer.
-  flutter::Shell::CreateCallback<flutter::Rasterizer> on_create_rasterizer =
-      fml::MakeCopyable([this](flutter::Shell& shell) mutable {
-        FML_DCHECK(session_connection_);
-        FML_DCHECK(surface_producer_);
-        FML_DCHECK(scene_update_context_);
-
-        std::unique_ptr<flutter_runner::CompositorContext> compositor_context =
-            std::make_unique<flutter_runner::CompositorContext>(
-                session_connection_.value(), surface_producer_.value(),
-                scene_update_context_.value());
-
-        return std::make_unique<flutter::Rasterizer>(
-            shell, std::move(compositor_context));
-      });
+  flutter::Shell::CreateCallback<flutter::Rasterizer> on_create_rasterizer;
+#if defined(LEGACY_FUCHSIA_EMBEDDER)
+  on_create_rasterizer = [this](flutter::Shell& shell) {
+    if (use_legacy_renderer_) {
+      FML_DCHECK(session_connection_);
+      FML_DCHECK(surface_producer_);
+      FML_DCHECK(legacy_external_view_embedder_);
+
+      auto compositor_context =
+          std::make_unique<flutter_runner::CompositorContext>(
+              session_connection_.value(), surface_producer_.value(),
+              legacy_external_view_embedder_.value());
+      return std::make_unique<flutter::Rasterizer>(
+          shell, std::move(compositor_context));
+    } else {
+      return std::make_unique<flutter::Rasterizer>(shell);
+    }
+  };
+#else
+  on_create_rasterizer = [](flutter::Shell& shell) {
+    return std::make_unique<flutter::Rasterizer>(shell);
+  };
+#endif
 
   settings.root_isolate_create_callback =
       std::bind(&Engine::OnMainIsolateStart, this);
@@ -479,59 +500,97 @@ void Engine::Terminate() {
 }
 
 void Engine::DebugWireframeSettingsChanged(bool enabled) {
-  if (!shell_ || !scene_update_context_) {
-    return;
-  }
-
-  shell_->GetTaskRunners().GetRasterTaskRunner()->PostTask(
-      [this, enabled]() { scene_update_context_->EnableWireframe(enabled); });
+  FML_CHECK(shell_);
+
+  shell_->GetTaskRunners().GetRasterTaskRunner()->PostTask([this, enabled]() {
+#if defined(LEGACY_FUCHSIA_EMBEDDER)
+    if (use_legacy_renderer_) {
+      FML_CHECK(legacy_external_view_embedder_);
+      legacy_external_view_embedder_->EnableWireframe(enabled);
+    } else
+#endif
+    {
+      FML_CHECK(external_view_embedder_);
+      external_view_embedder_->EnableWireframe(enabled);
+    }
+  });
 }
 
 void Engine::CreateView(int64_t view_id, bool hit_testable, bool focusable) {
-  if (!shell_ || !scene_update_context_) {
-    return;
-  }
+  FML_CHECK(shell_);
 
   shell_->GetTaskRunners().GetRasterTaskRunner()->PostTask(
       [this, view_id, hit_testable, focusable]() {
-        scene_update_context_->CreateView(view_id, hit_testable, focusable);
+#if defined(LEGACY_FUCHSIA_EMBEDDER)
+        if (use_legacy_renderer_) {
+          FML_CHECK(legacy_external_view_embedder_);
+          legacy_external_view_embedder_->CreateView(view_id, hit_testable,
+                                                     focusable);
+        } else
+#endif
+        {
+          FML_CHECK(external_view_embedder_);
+          external_view_embedder_->CreateView(view_id);
+          external_view_embedder_->SetViewProperties(view_id, hit_testable,
+                                                     focusable);
+        }
       });
 }
 
 void Engine::UpdateView(int64_t view_id, bool hit_testable, bool focusable) {
-  if (!shell_ || !scene_update_context_) {
-    return;
-  }
+  FML_CHECK(shell_);
 
   shell_->GetTaskRunners().GetRasterTaskRunner()->PostTask(
       [this, view_id, hit_testable, focusable]() {
-        scene_update_context_->UpdateView(view_id, hit_testable, focusable);
+#if defined(LEGACY_FUCHSIA_EMBEDDER)
+        if (use_legacy_renderer_) {
+          FML_CHECK(legacy_external_view_embedder_);
+          legacy_external_view_embedder_->UpdateView(view_id, hit_testable,
+                                                     focusable);
+        } else
+#endif
+        {
+          FML_CHECK(external_view_embedder_);
+          external_view_embedder_->SetViewProperties(view_id, hit_testable,
+                                                     focusable);
+        }
       });
 }
 
 void Engine::DestroyView(int64_t view_id) {
-  if (!shell_ || !scene_update_context_) {
-    return;
-  }
-
-  shell_->GetTaskRunners().GetRasterTaskRunner()->PostTask(
-      [this, view_id]() { scene_update_context_->DestroyView(view_id); });
+  FML_CHECK(shell_);
+
+  shell_->GetTaskRunners().GetRasterTaskRunner()->PostTask([this, view_id]() {
+#if defined(LEGACY_FUCHSIA_EMBEDDER)
+    if (use_legacy_renderer_) {
+      FML_CHECK(legacy_external_view_embedder_);
+      legacy_external_view_embedder_->DestroyView(view_id);
+    } else
+#endif
+    {
+      FML_CHECK(external_view_embedder_);
+      external_view_embedder_->DestroyView(view_id);
+    }
+  });
 }
 
-flutter::ExternalViewEmbedder* Engine::GetViewEmbedder() {
-  if (!scene_update_context_) {
-    return nullptr;
-  }
-
-  return &scene_update_context_.value();
-}
+std::unique_ptr<flutter::Surface> Engine::CreateSurface() {
+  flutter::ExternalViewEmbedder* external_view_embedder = nullptr;
 
-GrDirectContext* Engine::GetGrContext() {
-  // GetGrContext should be called only after rasterizer is created.
-  FML_DCHECK(shell_);
-  FML_DCHECK(shell_->GetRasterizer());
+#if defined(LEGACY_FUCHSIA_EMBEDDER)
+  if (use_legacy_renderer_) {
+    FML_CHECK(legacy_external_view_embedder_);
+    external_view_embedder = &legacy_external_view_embedder_.value();
+  } else
+#endif
+  {
+    FML_CHECK(external_view_embedder_);
+    external_view_embedder = &external_view_embedder_.value();
+  }
+  FML_CHECK(external_view_embedder);
 
-  return surface_producer_->gr_context();
+  return std::make_unique<Surface>(thread_label_, external_view_embedder,
+                                   surface_producer_->gr_context());
 }
 
 #if !defined(DART_PRODUCT)

shell/platform/fuchsia/flutter/engine.h

@@ -14,17 +14,21 @@
 #include <lib/ui/scenic/cpp/view_ref_pair.h>
 #include <lib/zx/event.h>
 
-#include "flutter/flow/embedded_views.h"
-#include "flutter/flow/scene_update_context.h"
+#include "flutter/flow/surface.h"
 #include "flutter/fml/macros.h"
 #include "flutter/shell/common/shell.h"
 
 #include "flutter_runner_product_configuration.h"
+#include "fuchsia_external_view_embedder.h"
 #include "isolate_configurator.h"
 #include "session_connection.h"
 #include "thread.h"
 #include "vulkan_surface_producer.h"
 
+#if defined(LEGACY_FUCHSIA_EMBEDDER)
+#include "flutter/flow/scene_update_context.h"  // nogncheck
+#endif
+
 namespace flutter_runner {
 
 // Represents an instance of running Flutter engine along with the threads
@@ -65,7 +69,10 @@ class Engine final {
 
   std::optional<SessionConnection> session_connection_;
   std::optional<VulkanSurfaceProducer> surface_producer_;
-  std::optional<flutter::SceneUpdateContext> scene_update_context_;
+  std::optional<FuchsiaExternalViewEmbedder> external_view_embedder_;
+#if defined(LEGACY_FUCHSIA_EMBEDDER)
+  std::optional<flutter::SceneUpdateContext> legacy_external_view_embedder_;
+#endif
 
   std::unique_ptr<IsolateConfigurator> isolate_configurator_;
   std::unique_ptr<flutter::Shell> shell_;
@@ -74,6 +81,10 @@ class Engine final {
 
   zx::event vsync_event_;
 
+#if defined(LEGACY_FUCHSIA_EMBEDDER)
+  bool use_legacy_renderer_ = true;
+#endif
+
   fml::WeakPtrFactory<Engine> weak_factory_;
 
   void OnMainIsolateStart();
@@ -87,9 +98,7 @@ class Engine final {
   void UpdateView(int64_t view_id, bool hit_testable, bool focusable);
   void DestroyView(int64_t view_id);
 
-  flutter::ExternalViewEmbedder* GetViewEmbedder();
-
-  GrDirectContext* GetGrContext();
+  std::unique_ptr<flutter::Surface> CreateSurface();
 
   FML_DISALLOW_COPY_AND_ASSIGN(Engine);
 };