Add Platform View Manager to Windows shell

shell/platform/windows/BUILD.gn

@@ -98,6 +98,8 @@ source_set("flutter_windows_source") {
     "keyboard_utils.h",
     "platform_handler.cc",
     "platform_handler.h",
+    "platform_view_manager.cc",
+    "platform_view_manager.h",
     "sequential_id_generator.cc",
     "sequential_id_generator.h",
     "settings_plugin.cc",
@@ -220,6 +222,7 @@ executable("flutter_windows_unittests") {
     "testing/flutter_windows_engine_builder.cc",
     "testing/flutter_windows_engine_builder.h",
     "testing/mock_direct_manipulation.h",
+    "testing/mock_platform_view_manager.h",
     "testing/mock_text_input_manager.cc",
     "testing/mock_text_input_manager.h",
     "testing/mock_window.cc",

shell/platform/windows/client_wrapper/testing/stub_flutter_windows_api.cc

@@ -176,6 +176,16 @@ bool FlutterDesktopEngineProcessExternalWindowMessage(
   return false;
 }
 
+void FlutterDesktopEngineRegisterPlatformViewType(
+    FlutterDesktopEngineRef engine,
+    const char* view_type_name,
+    FlutterPlatformViewTypeEntry view_type) {
+  if (s_stub_implementation) {
+    s_stub_implementation->EngineRegisterPlatformViewType(view_type_name,
+                                                          view_type);
+  }
+}
+
 FlutterDesktopViewRef FlutterDesktopPluginRegistrarGetView(
     FlutterDesktopPluginRegistrarRef controller) {
   // The stub ignores this, so just return an arbitrary non-zero value.

shell/platform/windows/client_wrapper/testing/stub_flutter_windows_api.h

@@ -72,6 +72,11 @@ class StubFlutterWindowsApi {
   // Called for FlutterDesktopEngineReloadSystemFonts.
   virtual void EngineReloadSystemFonts() {}
 
+  // Called for FlutterDesktopEngineRegisterPlatformViewType.
+  virtual void EngineRegisterPlatformViewType(
+      const char* view_type_name,
+      FlutterPlatformViewTypeEntry view_type) {}
+
   // Called for FlutterDesktopViewGetHWND.
   virtual HWND ViewGetHWND() { return reinterpret_cast<HWND>(1); }
 

shell/platform/windows/compositor.h

@@ -7,6 +7,8 @@
 
 #include "flutter/shell/platform/embedder/embedder.h"
 
+#include "flutter/shell/platform/windows/platform_view_manager.h"
+
 namespace flutter {
 
 // Enables the Flutter engine to render content on Windows.
@@ -19,6 +21,7 @@ namespace flutter {
 // Platform views are not yet supported.
 class Compositor {
  public:
+  Compositor(PlatformViewManager* manager) : platform_view_manager_(manager) {}
   virtual ~Compositor() = default;
 
   // Creates a backing store used for rendering Flutter content.
@@ -32,6 +35,9 @@ class Compositor {
 
   // Present Flutter content and platform views onto the view.
   virtual bool Present(const FlutterLayer** layers, size_t layers_count) = 0;
+
+ protected:
+  PlatformViewManager* platform_view_manager_;
 };
 
 }  // namespace flutter

shell/platform/windows/compositor_opengl.cc

@@ -34,9 +34,10 @@ int GetSupportedTextureFormat(const impeller::DescriptionGLES* description) {
 
 }  // namespace
 
-CompositorOpenGL::CompositorOpenGL(FlutterWindowsEngine* engine,
+CompositorOpenGL::CompositorOpenGL(PlatformViewManager* manager,
+                                   FlutterWindowsEngine* engine,
                                    impeller::ProcTableGLES::Resolver resolver)
-    : engine_(engine), resolver_(resolver) {}
+    : Compositor(manager), engine_(engine), resolver_(resolver) {}
 
 bool CompositorOpenGL::CreateBackingStore(
     const FlutterBackingStoreConfig& config,

shell/platform/windows/compositor_opengl.h

@@ -17,7 +17,8 @@ namespace flutter {
 // Enables the Flutter engine to render content on Windows using OpenGL.
 class CompositorOpenGL : public Compositor {
  public:
-  CompositorOpenGL(FlutterWindowsEngine* engine,
+  CompositorOpenGL(PlatformViewManager* manager,
+                   FlutterWindowsEngine* engine,
                    impeller::ProcTableGLES::Resolver resolver);
 
   /// |Compositor|

shell/platform/windows/compositor_opengl_unittests.cc

@@ -113,7 +113,7 @@ class CompositorOpenGLTest : public WindowsTest {
 TEST_F(CompositorOpenGLTest, CreateBackingStore) {
   UseHeadlessEngine();
 
-  auto compositor = CompositorOpenGL{engine(), kMockResolver};
+  auto compositor = CompositorOpenGL{nullptr, engine(), kMockResolver};
 
   FlutterBackingStoreConfig config = {};
   FlutterBackingStore backing_store = {};
@@ -127,7 +127,7 @@ TEST_F(CompositorOpenGLTest, CreateBackingStore) {
 TEST_F(CompositorOpenGLTest, InitializationFailure) {
   UseHeadlessEngine();
 
-  auto compositor = CompositorOpenGL{engine(), kMockResolver};
+  auto compositor = CompositorOpenGL{nullptr, engine(), kMockResolver};
 
   FlutterBackingStoreConfig config = {};
   FlutterBackingStore backing_store = {};
@@ -140,7 +140,7 @@ TEST_F(CompositorOpenGLTest, InitializationFailure) {
 TEST_F(CompositorOpenGLTest, Present) {
   UseEngineWithView();
 
-  auto compositor = CompositorOpenGL{engine(), kMockResolver};
+  auto compositor = CompositorOpenGL{nullptr, engine(), kMockResolver};
 
   FlutterBackingStoreConfig config = {};
   FlutterBackingStore backing_store = {};
@@ -164,7 +164,7 @@ TEST_F(CompositorOpenGLTest, Present) {
 TEST_F(CompositorOpenGLTest, PresentEmpty) {
   UseEngineWithView();
 
-  auto compositor = CompositorOpenGL{engine(), kMockResolver};
+  auto compositor = CompositorOpenGL{nullptr, engine(), kMockResolver};
 
   // The context will be bound twice: first to initialize the compositor, second
   // to clear the surface.
@@ -177,7 +177,7 @@ TEST_F(CompositorOpenGLTest, PresentEmpty) {
 TEST_F(CompositorOpenGLTest, HeadlessPresentIgnored) {
   UseHeadlessEngine();
 
-  auto compositor = CompositorOpenGL{engine(), kMockResolver};
+  auto compositor = CompositorOpenGL{nullptr, engine(), kMockResolver};
 
   FlutterBackingStoreConfig config = {};
   FlutterBackingStore backing_store = {};
@@ -199,7 +199,7 @@ TEST_F(CompositorOpenGLTest, HeadlessPresentIgnored) {
 TEST_F(CompositorOpenGLTest, NoSurfaceIgnored) {
   UseEngineWithView(/*add_surface = */ false);
 
-  auto compositor = CompositorOpenGL{engine(), kMockResolver};
+  auto compositor = CompositorOpenGL{nullptr, engine(), kMockResolver};
 
   FlutterBackingStoreConfig config = {};
   FlutterBackingStore backing_store = {};

shell/platform/windows/compositor_software.cc

@@ -8,8 +8,9 @@
 
 namespace flutter {
 
-CompositorSoftware::CompositorSoftware(FlutterWindowsEngine* engine)
-    : engine_(engine) {}
+CompositorSoftware::CompositorSoftware(PlatformViewManager* manager,
+                                       FlutterWindowsEngine* engine)
+    : Compositor(manager), engine_(engine) {}
 
 bool CompositorSoftware::CreateBackingStore(
     const FlutterBackingStoreConfig& config,

shell/platform/windows/compositor_software.h

@@ -15,7 +15,8 @@ namespace flutter {
 // rasterization and bitmaps.
 class CompositorSoftware : public Compositor {
  public:
-  CompositorSoftware(FlutterWindowsEngine* engine);
+  CompositorSoftware(PlatformViewManager* manager,
+                     FlutterWindowsEngine* engine);
 
   /// |Compositor|
   bool CreateBackingStore(const FlutterBackingStoreConfig& config,

shell/platform/windows/compositor_software_unittests.cc

@@ -76,7 +76,7 @@ class CompositorSoftwareTest : public WindowsTest {
 TEST_F(CompositorSoftwareTest, CreateBackingStore) {
   UseHeadlessEngine();
 
-  auto compositor = CompositorSoftware{engine()};
+  auto compositor = CompositorSoftware{nullptr, engine()};
 
   FlutterBackingStoreConfig config = {};
   FlutterBackingStore backing_store = {};
@@ -88,7 +88,7 @@ TEST_F(CompositorSoftwareTest, CreateBackingStore) {
 TEST_F(CompositorSoftwareTest, Present) {
   UseEngineWithView();
 
-  auto compositor = CompositorSoftware{engine()};
+  auto compositor = CompositorSoftware{nullptr, engine()};
 
   FlutterBackingStoreConfig config = {};
   FlutterBackingStore backing_store = {};
@@ -109,7 +109,7 @@ TEST_F(CompositorSoftwareTest, Present) {
 TEST_F(CompositorSoftwareTest, PresentEmpty) {
   UseEngineWithView();
 
-  auto compositor = CompositorSoftware{engine()};
+  auto compositor = CompositorSoftware{nullptr, engine()};
 
   EXPECT_CALL(*view(), ClearSoftwareBitmap).WillOnce(Return(true));
   EXPECT_TRUE(compositor.Present(nullptr, 0));
@@ -118,7 +118,7 @@ TEST_F(CompositorSoftwareTest, PresentEmpty) {
 TEST_F(CompositorSoftwareTest, HeadlessPresentIgnored) {
   UseHeadlessEngine();
 
-  auto compositor = CompositorSoftware{engine()};
+  auto compositor = CompositorSoftware{nullptr, engine()};
 
   FlutterBackingStoreConfig config = {};
   FlutterBackingStore backing_store = {};

shell/platform/windows/fixtures/main.dart

@@ -4,7 +4,7 @@
 
 import 'dart:async';
 import 'dart:io' as io;
-import 'dart:typed_data' show ByteData, Uint8List;
+import 'dart:typed_data' show ByteData, Endian, Uint8List;
 import 'dart:ui' as ui;
 import 'dart:convert';
 
@@ -159,6 +159,26 @@ void enableLifecycleToFrom() async {
   });
 }
 
+@pragma('vm:entry-point')
+void sendCreationMethod() async {
+  final List<int> data = <int>[
+    // Method name
+    7, 'create'.length, ...utf8.encode('create'),
+    // Method arguments: {'type': 'type':, 'id': 0}
+    13, 2,
+    7, 'type'.length, ...utf8.encode('type'),
+    7, 'type'.length, ...utf8.encode('type'),
+    7, 'id'.length, ...utf8.encode('id'),
+    3, 0, 0, 0, 0,
+  ];
+
+  final Completer<ByteData?> completed = Completer<ByteData?>();
+  final ByteData bytes = ByteData.sublistView(Uint8List.fromList(data));
+  ui.PlatformDispatcher.instance.sendPlatformMessage('flutter/platform_views', bytes, (ByteData? response) {
+    completed.complete(response);
+  });
+}
+
 @pragma('vm:entry-point')
 void customEntrypoint() {}
 

shell/platform/windows/flutter_windows.cc

@@ -246,6 +246,13 @@ bool FlutterDesktopEngineProcessExternalWindowMessage(
   return lresult.has_value();
 }
 
+void FlutterDesktopEngineRegisterPlatformViewType(
+    FlutterDesktopEngineRef engine,
+    const char* view_type_name,
+    FlutterPlatformViewTypeEntry view_type) {
+  // TODO(schectman): forward to platform view manager
+}
+
 FlutterDesktopViewRef FlutterDesktopPluginRegistrarGetView(
     FlutterDesktopPluginRegistrarRef registrar) {
   return HandleForView(registrar->engine->view());

shell/platform/windows/flutter_windows_engine.cc

@@ -380,14 +380,20 @@ bool FlutterWindowsEngine::Run(std::string_view entrypoint) {
 
   args.custom_task_runners = &custom_task_runners;
 
+  if (!platform_view_manager_) {
+    platform_view_manager_ = std::make_unique<PlatformViewManager>(
+        task_runner_.get(), messenger_wrapper_.get());
+  }
   if (egl_manager_) {
     auto resolver = [](const char* name) -> void* {
       return reinterpret_cast<void*>(::eglGetProcAddress(name));
     };
 
-    compositor_ = std::make_unique<CompositorOpenGL>(this, resolver);
+    compositor_ = std::make_unique<CompositorOpenGL>(
+        platform_view_manager_.get(), this, resolver);
   } else {
-    compositor_ = std::make_unique<CompositorSoftware>(this);
+    compositor_ = std::make_unique<CompositorSoftware>(
+        platform_view_manager_.get(), this);
   }
 
   FlutterCompositor compositor = {};

shell/platform/windows/flutter_windows_engine.h

@@ -137,6 +137,8 @@ class FlutterWindowsEngine {
 
   TaskRunner* task_runner() { return task_runner_.get(); }
 
+  BinaryMessenger* messenger_wrapper() { return messenger_wrapper_.get(); }
+
   FlutterWindowsTextureRegistrar* texture_registrar() {
     return texture_registrar_.get();
   }
@@ -427,6 +429,8 @@ class FlutterWindowsEngine {
 
   std::shared_ptr<egl::ProcTable> gl_;
 
+  std::unique_ptr<PlatformViewManager> platform_view_manager_;
+
   FML_DISALLOW_COPY_AND_ASSIGN(FlutterWindowsEngine);
 };
 

shell/platform/windows/flutter_windows_engine_unittests.cc

@@ -12,6 +12,7 @@
 #include "flutter/shell/platform/windows/testing/egl/mock_manager.h"
 #include "flutter/shell/platform/windows/testing/engine_modifier.h"
 #include "flutter/shell/platform/windows/testing/flutter_windows_engine_builder.h"
+#include "flutter/shell/platform/windows/testing/mock_platform_view_manager.h"
 #include "flutter/shell/platform/windows/testing/mock_window_binding_handler.h"
 #include "flutter/shell/platform/windows/testing/mock_windows_proc_table.h"
 #include "flutter/shell/platform/windows/testing/test_keyboard.h"
@@ -1169,5 +1170,29 @@ TEST_F(FlutterWindowsEngineTest, ChannelListenedTo) {
   }
 }
 
+TEST_F(FlutterWindowsEngineTest, ReceivePlatformViewMessage) {
+  FlutterWindowsEngineBuilder builder{GetContext()};
+  builder.SetDartEntrypoint("sendCreationMethod");
+  auto engine = builder.Build();
+
+  EngineModifier modifier(engine.get());
+  modifier.embedder_api().RunsAOTCompiledDartCode = []() { return false; };
+
+  bool received_call = false;
+
+  auto manager = std::make_unique<MockPlatformViewManager>(engine.get());
+  EXPECT_CALL(*manager, QueuePlatformViewCreation)
+      .WillRepeatedly([&](std::string_view type_name, int64_t id) {
+        received_call = true;
+      });
+  modifier.SetPlatformViewManager(std::move(manager));
+
+  engine->Run();
+
+  while (!received_call) {
+    engine->task_runner()->ProcessTasks();
+  }
+}
+
 }  // namespace testing
 }  // namespace flutter

shell/platform/windows/platform_view_manager.cc

@@ -0,0 +1,57 @@
+// 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/platform/windows/platform_view_manager.h"
+
+#include "flutter/shell/platform/common/client_wrapper/include/flutter/standard_method_codec.h"
+
+namespace flutter {
+
+namespace {
+constexpr char kChannelName[] = "flutter/platform_views";
+}
+
+PlatformViewManager::PlatformViewManager(TaskRunner* task_runner,
+                                         BinaryMessenger* binary_messenger)
+    : task_runner_(task_runner),
+      channel_(std::make_unique<MethodChannel<EncodableValue>>(
+          binary_messenger,
+          kChannelName,
+          &StandardMethodCodec::GetInstance())) {
+  channel_->SetMethodCallHandler(
+      [this](const MethodCall<EncodableValue>& call,
+             std::unique_ptr<MethodResult<EncodableValue>> result) {
+        const auto& args = std::get<EncodableMap>(*call.arguments());
+        if (call.method_name() == "create") {
+          const auto& type =
+              std::get<std::string>(args.find(EncodableValue("type"))->second);
+          const auto& id =
+              std::get<std::int32_t>(args.find(EncodableValue("id"))->second);
+          QueuePlatformViewCreation(type, id);
+        }
+        result->Success();
+      });
+}
+
+PlatformViewManager::~PlatformViewManager() {}
+
+void PlatformViewManager::QueuePlatformViewCreation(std::string_view type_name,
+                                                    int64_t id) {}
+
+void PlatformViewManager::InstantiatePlatformView(int64_t id) {}
+
+void PlatformViewManager::RegisterPlatformViewType(
+    std::string_view type_name,
+    const FlutterPlatformViewTypeEntry& type) {}
+
+void PlatformViewManager::FocusPlatformView(int64_t id,
+                                            FocusChangeDirection direction,
+                                            bool focus) {}
+
+std::optional<HWND> PlatformViewManager::GetNativeHandleForId(
+    int64_t id) const {
+  return std::nullopt;
+}
+
+}  // namespace flutter