Revert "Reland 2: Multiview Pipeline (flutter#47239)"

This reverts commit 0ef5caa.

Author: dkwingsmt

flow/frame_timings.cc

@@ -254,30 +254,8 @@ const char* FrameTimingsRecorder::GetFrameNumberTraceArg() const {
   return frame_number_trace_arg_val_.c_str();
 }
 
-static const char* StateToString(FrameTimingsRecorder::State state) {
-#ifndef NDEBUG
-  switch (state) {
-    case FrameTimingsRecorder::State::kUninitialized:
-      return "kUninitialized";
-    case FrameTimingsRecorder::State::kVsync:
-      return "kVsync";
-    case FrameTimingsRecorder::State::kBuildStart:
-      return "kBuildStart";
-    case FrameTimingsRecorder::State::kBuildEnd:
-      return "kBuildEnd";
-    case FrameTimingsRecorder::State::kRasterStart:
-      return "kRasterStart";
-    case FrameTimingsRecorder::State::kRasterEnd:
-      return "kRasterEnd";
-  };
-  FML_UNREACHABLE();
-#endif
-  return "";
-}
-
 void FrameTimingsRecorder::AssertInState(State state) const {
-  FML_DCHECK(state_ == state) << "Expected state " << StateToString(state)
-                              << ", actual state " << StateToString(state_);
+  FML_DCHECK(state_ == state);
 }
 
 }  // namespace flutter

flow/frame_timings.h

@@ -31,7 +31,6 @@ class FrameTimingsRecorder {
  public:
   /// Various states that the recorder can be in. When created the recorder is
   /// in an unitialized state and transtions in sequential order of the states.
-  // After adding an item to this enum, modify StateToString accordingly.
   enum class State : uint32_t {
     kUninitialized,
     kVsync,
@@ -122,8 +121,6 @@ class FrameTimingsRecorder {
   ///
   /// Instead of adding a `GetState` method and asserting on the result, this
   /// method prevents other logic from relying on the state.
-  ///
-  /// In opt builds, this call is a no-op.
   void AssertInState(State state) const;
 
  private:

lib/ui/dart_ui.cc

@@ -98,7 +98,7 @@ typedef CanvasPath Path;
   V(NativeStringAttribute::initSpellOutStringAttribute, 3)            \
   V(PlatformConfigurationNativeApi::DefaultRouteName, 0)              \
   V(PlatformConfigurationNativeApi::ScheduleFrame, 0)                 \
-  V(PlatformConfigurationNativeApi::Render, 2)                        \
+  V(PlatformConfigurationNativeApi::Render, 1)                        \
   V(PlatformConfigurationNativeApi::UpdateSemantics, 1)               \
   V(PlatformConfigurationNativeApi::SetNeedsReportTimings, 1)         \
   V(PlatformConfigurationNativeApi::SetIsolateDebugName, 1)           \

lib/ui/painting/image_dispose_unittests.cc

@@ -5,7 +5,6 @@
 #define FML_USED_ON_EMBEDDER
 
 #include "flutter/common/task_runners.h"
-#include "flutter/fml/synchronization/count_down_latch.h"
 #include "flutter/fml/synchronization/waitable_event.h"
 #include "flutter/lib/ui/painting/canvas.h"
 #include "flutter/lib/ui/painting/image.h"
@@ -58,10 +57,6 @@ TEST_F(ImageDisposeTest, ImageReleasedAfterFrameAndDisposePictureAndLayer) {
   };
 
   Settings settings = CreateSettingsForFixture();
-  fml::CountDownLatch frame_latch{2};
-  settings.frame_rasterized_callback = [&frame_latch](const FrameTiming& t) {
-    frame_latch.CountDown();
-  };
   auto task_runner = CreateNewThread();
   TaskRunners task_runners("test",                  // label
                            GetCurrentTaskRunner(),  // platform
@@ -88,15 +83,12 @@ TEST_F(ImageDisposeTest, ImageReleasedAfterFrameAndDisposePictureAndLayer) {
   shell->RunEngine(std::move(configuration), [&](auto result) {
     ASSERT_EQ(result, Engine::RunStatus::Success);
   });
+
   message_latch_.Wait();
 
   ASSERT_TRUE(current_display_list_);
   ASSERT_TRUE(current_image_);
 
-  // Wait for 2 frames to be rasterized. The 2nd frame releases resources of the
-  // 1st frame.
-  frame_latch.Wait();
-
   // Force a drain the SkiaUnrefQueue. The engine does this normally as frames
   // pump, but we force it here to make the test more deterministic.
   message_latch_.Reset();

lib/ui/window.dart

@@ -374,16 +374,14 @@ class FlutterView {
   void render(Scene scene, {Size? size}) {
     // Duplicated calls or calls outside of onBeginFrame/onDrawFrame (indicated
     // by _renderedViews being null) are ignored. See _renderedViews.
-    // TODO(dkwingsmt): We should change this skip into an assertion.
-    // https://github.com/flutter/flutter/issues/137073
     final bool validRender = platformDispatcher._renderedViews?.add(this) ?? false;
     if (validRender) {
-      _render(viewId, scene as _NativeScene, size?.width ?? physicalSize.width, size?.height ?? physicalSize.height);
+      _render(scene as _NativeScene, size?.width ?? physicalSize.width, size?.height ?? physicalSize.height);
     }
   }
 
-  @Native<Void Function(Int64, Pointer<Void>, Double, Double)>(symbol: 'PlatformConfigurationNativeApi::Render')
-  external static void _render(int viewId, _NativeScene scene, double width, double height);
+  @Native<Void Function(Pointer<Void>, Double, Double)>(symbol: 'PlatformConfigurationNativeApi::Render')
+  external static void _render(_NativeScene scene, double width, double height);
 
   /// Change the retained semantics data about this [FlutterView].
   ///

lib/ui/window/platform_configuration.cc

@@ -449,13 +449,12 @@ void PlatformConfiguration::CompletePlatformMessageResponse(
   response->Complete(std::make_unique<fml::DataMapping>(std::move(data)));
 }
 
-void PlatformConfigurationNativeApi::Render(int64_t view_id,
-                                            Scene* scene,
+void PlatformConfigurationNativeApi::Render(Scene* scene,
                                             double width,
                                             double height) {
   UIDartState::ThrowIfUIOperationsProhibited();
   UIDartState::Current()->platform_configuration()->client()->Render(
-      view_id, scene, width, height);
+      scene, width, height);
 }
 
 void PlatformConfigurationNativeApi::SetNeedsReportTimings(bool value) {

lib/ui/window/platform_configuration.h

@@ -69,10 +69,7 @@ class PlatformConfigurationClient {
   /// @brief      Updates the client's rendering on the GPU with the newly
   ///             provided Scene.
   ///
-  virtual void Render(int64_t view_id,
-                      Scene* scene,
-                      double width,
-                      double height) = 0;
+  virtual void Render(Scene* scene, double width, double height) = 0;
 
   //--------------------------------------------------------------------------
   /// @brief      Receives an updated semantics tree from the Framework.
@@ -560,10 +557,7 @@ class PlatformConfigurationNativeApi {
 
   static void ScheduleFrame();
 
-  static void Render(int64_t view_id,
-                     Scene* scene,
-                     double width,
-                     double height);
+  static void Render(Scene* scene, double width, double height);
 
   static void UpdateSemantics(SemanticsUpdate* update);
 

lib/ui/window/platform_configuration_unittests.cc

@@ -15,166 +15,8 @@
 #include "flutter/shell/common/shell_test.h"
 #include "flutter/shell/common/thread_host.h"
 #include "flutter/testing/testing.h"
-#include "gmock/gmock.h"
 
 namespace flutter {
-
-namespace {
-
-static constexpr int64_t kImplicitViewId = 0;
-
-static void PostSync(const fml::RefPtr<fml::TaskRunner>& task_runner,
-                     const fml::closure& task) {
-  fml::AutoResetWaitableEvent latch;
-  fml::TaskRunner::RunNowOrPostTask(task_runner, [&latch, &task] {
-    task();
-    latch.Signal();
-  });
-  latch.Wait();
-}
-
-class MockRuntimeDelegate : public RuntimeDelegate {
- public:
-  MOCK_METHOD(std::string, DefaultRouteName, (), (override));
-  MOCK_METHOD(void, ScheduleFrame, (bool), (override));
-  MOCK_METHOD(void,
-              Render,
-              (int64_t, std::unique_ptr<flutter::LayerTree>, float),
-              (override));
-  MOCK_METHOD(void,
-              UpdateSemantics,
-              (SemanticsNodeUpdates, CustomAccessibilityActionUpdates),
-              (override));
-  MOCK_METHOD(void,
-              HandlePlatformMessage,
-              (std::unique_ptr<PlatformMessage>),
-              (override));
-  MOCK_METHOD(FontCollection&, GetFontCollection, (), (override));
-  MOCK_METHOD(std::shared_ptr<AssetManager>, GetAssetManager, (), (override));
-  MOCK_METHOD(void, OnRootIsolateCreated, (), (override));
-  MOCK_METHOD(void,
-              UpdateIsolateDescription,
-              (const std::string, int64_t),
-              (override));
-  MOCK_METHOD(void, SetNeedsReportTimings, (bool), (override));
-  MOCK_METHOD(std::unique_ptr<std::vector<std::string>>,
-              ComputePlatformResolvedLocale,
-              (const std::vector<std::string>&),
-              (override));
-  MOCK_METHOD(void, RequestDartDeferredLibrary, (intptr_t), (override));
-  MOCK_METHOD(std::weak_ptr<PlatformMessageHandler>,
-              GetPlatformMessageHandler,
-              (),
-              (const, override));
-  MOCK_METHOD(void, SendChannelUpdate, (std::string, bool), (override));
-  MOCK_METHOD(double,
-              GetScaledFontSize,
-              (double font_size, int configuration_id),
-              (const, override));
-};
-
-class MockPlatformMessageHandler : public PlatformMessageHandler {
- public:
-  MOCK_METHOD(void,
-              HandlePlatformMessage,
-              (std::unique_ptr<PlatformMessage> message),
-              (override));
-  MOCK_METHOD(bool,
-              DoesHandlePlatformMessageOnPlatformThread,
-              (),
-              (const, override));
-  MOCK_METHOD(void,
-              InvokePlatformMessageResponseCallback,
-              (int response_id, std::unique_ptr<fml::Mapping> mapping),
-              (override));
-  MOCK_METHOD(void,
-              InvokePlatformMessageEmptyResponseCallback,
-              (int response_id),
-              (override));
-};
-
-// A class that can launch a RuntimeController with the specified
-// RuntimeDelegate.
-//
-// To use this class, contruct this class with Create, call LaunchRootIsolate,
-// and use the controller with ControllerTaskSync().
-class RuntimeControllerContext {
- public:
-  using ControllerCallback = std::function<void(RuntimeController&)>;
-
-  [[nodiscard]] static std::unique_ptr<RuntimeControllerContext> Create(
-      Settings settings,                //
-      const TaskRunners& task_runners,  //
-      RuntimeDelegate& client) {
-    auto [vm, isolate_snapshot] = Shell::InferVmInitDataFromSettings(settings);
-    FML_CHECK(vm) << "Must be able to initialize the VM.";
-    // Construct the class with `new` because `make_unique` has no access to the
-    // private constructor.
-    RuntimeControllerContext* raw_pointer = new RuntimeControllerContext(
-        settings, task_runners, client, std::move(vm), isolate_snapshot);
-    return std::unique_ptr<RuntimeControllerContext>(raw_pointer);
-  }
-
-  ~RuntimeControllerContext() {
-    PostSync(task_runners_.GetUITaskRunner(),
-             [&]() { runtime_controller_.reset(); });
-  }
-
-  // Launch the root isolate. The post_launch callback will be executed in the
-  // same UI task, which can be used to create initial views.
-  void LaunchRootIsolate(RunConfiguration& configuration,
-                         ControllerCallback post_launch) {
-    PostSync(task_runners_.GetUITaskRunner(), [&]() {
-      bool launch_success = runtime_controller_->LaunchRootIsolate(
-          settings_,                                  //
-          []() {},                                    //
-          configuration.GetEntrypoint(),              //
-          configuration.GetEntrypointLibrary(),       //
-          configuration.GetEntrypointArgs(),          //
-          configuration.TakeIsolateConfiguration());  //
-      ASSERT_TRUE(launch_success);
-      post_launch(*runtime_controller_);
-    });
-  }
-
-  // Run a task that operates the RuntimeController on the UI thread, and wait
-  // for the task to end.
-  void ControllerTaskSync(ControllerCallback task) {
-    ASSERT_TRUE(runtime_controller_);
-    ASSERT_TRUE(task);
-    PostSync(task_runners_.GetUITaskRunner(),
-             [&]() { task(*runtime_controller_); });
-  }
-
- private:
-  RuntimeControllerContext(const Settings& settings,
-                           const TaskRunners& task_runners,
-                           RuntimeDelegate& client,
-                           DartVMRef vm,
-                           fml::RefPtr<const DartSnapshot> isolate_snapshot)
-      : settings_(settings),
-        task_runners_(task_runners),
-        isolate_snapshot_(std::move(isolate_snapshot)),
-        vm_(std::move(vm)),
-        runtime_controller_(std::make_unique<RuntimeController>(
-            client,
-            &vm_,
-            std::move(isolate_snapshot_),
-            settings.idle_notification_callback,  // idle notification callback
-            flutter::PlatformData(),              // platform data
-            settings.isolate_create_callback,     // isolate create callback
-            settings.isolate_shutdown_callback,   // isolate shutdown callback
-            settings.persistent_isolate_data,     // persistent isolate data
-            UIDartState::Context{task_runners})) {}
-
-  Settings settings_;
-  TaskRunners task_runners_;
-  fml::RefPtr<const DartSnapshot> isolate_snapshot_;
-  DartVMRef vm_;
-  std::unique_ptr<RuntimeController> runtime_controller_;
-};
-}  // namespace
-
 namespace testing {
 
 class PlatformConfigurationTest : public ShellTest {};

runtime/runtime_controller.cc

@@ -341,16 +341,15 @@ void RuntimeController::ScheduleFrame() {
 }
 
 // |PlatformConfigurationClient|
-void RuntimeController::Render(int64_t view_id,
-                               Scene* scene,
-                               double width,
-                               double height) {
+void RuntimeController::Render(Scene* scene, double width, double height) {
+  // TODO(dkwingsmt): Currently only supports a single window.
+  int64_t view_id = kFlutterImplicitViewId;
   const ViewportMetrics* view_metrics =
       UIDartState::Current()->platform_configuration()->GetMetrics(view_id);
   if (view_metrics == nullptr) {
     return;
   }
-  client_.Render(view_id, scene->takeLayerTree(width, height),
+  client_.Render(scene->takeLayerTree(width, height),
                  view_metrics->device_pixel_ratio);
 }
 

runtime/runtime_controller.h

@@ -658,10 +658,7 @@ class RuntimeController : public PlatformConfigurationClient {
   void ScheduleFrame() override;
 
   // |PlatformConfigurationClient|
-  void Render(int64_t view_id,
-              Scene* scene,
-              double width,
-              double height) override;
+  void Render(Scene* scene, double width, double height) override;
 
   // |PlatformConfigurationClient|
   void UpdateSemantics(SemanticsUpdate* update) override;