Compositor owns platform view manager

shell/platform/windows/compositor.h

@@ -7,6 +7,10 @@
 
 #include "flutter/shell/platform/embedder/embedder.h"
 
+#include <memory>
+
+#include "flutter/shell/platform/windows/platform_view_manager.h"
+
 namespace flutter {
 
 // Enables the Flutter engine to render content on Windows.
@@ -19,6 +23,7 @@ namespace flutter {
 // Platform views are not yet supported.
 class Compositor {
  public:
+  Compositor(std::unique_ptr<PlatformViewManager> manager) : platform_view_manager_(std::move(manager)) {}
   virtual ~Compositor() = default;
 
   // Creates a backing store used for rendering Flutter content.
@@ -32,6 +37,9 @@ class Compositor {
 
   // Present Flutter content and platform views onto the view.
   virtual bool Present(const FlutterLayer** layers, size_t layers_count) = 0;
+
+ protected:
+  std::unique_ptr<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(std::unique_ptr<PlatformViewManager> manager,
+                                   FlutterWindowsEngine* engine,
                                    impeller::ProcTableGLES::Resolver resolver)
-    : engine_(engine), resolver_(resolver) {}
+    : Compositor(std::move(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(std::unique_ptr<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(std::unique_ptr<PlatformViewManager> manager,
+                                       FlutterWindowsEngine* engine)
+    : Compositor(std::move(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(std::unique_ptr<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/flutter_windows_engine.cc

@@ -380,14 +380,15 @@ bool FlutterWindowsEngine::Run(std::string_view entrypoint) {
 
   args.custom_task_runners = &custom_task_runners;
 
+  auto 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>(std::move(platform_view_manager), this, resolver);
   } else {
-    compositor_ = std::make_unique<CompositorSoftware>(this);
+    compositor_ = std::make_unique<CompositorSoftware>(std::move(platform_view_manager), this);
   }
 
   FlutterCompositor compositor = {};