[Windows] Make the engine own the PlatformHandler

shell/platform/windows/flutter_windows_engine.cc

@@ -207,6 +207,8 @@ FlutterWindowsEngine::FlutterWindowsEngine(
   // Set up internal channels.
   // TODO: Replace this with an embedder.h API. See
   // https://github.com/flutter/flutter/issues/71099
+  platform_handler_ =
+      std::make_unique<PlatformHandler>(messenger_wrapper_.get(), this);
   settings_plugin_ = std::make_unique<SettingsPlugin>(messenger_wrapper_.get(),
                                                       task_runner_.get());
 }

shell/platform/windows/flutter_windows_engine.h

@@ -23,6 +23,7 @@
 #include "flutter/shell/platform/windows/flutter_desktop_messenger.h"
 #include "flutter/shell/platform/windows/flutter_project_bundle.h"
 #include "flutter/shell/platform/windows/flutter_windows_texture_registrar.h"
+#include "flutter/shell/platform/windows/platform_handler.h"
 #include "flutter/shell/platform/windows/public/flutter_windows.h"
 #include "flutter/shell/platform/windows/settings_plugin.h"
 #include "flutter/shell/platform/windows/task_runner.h"
@@ -306,6 +307,9 @@ class FlutterWindowsEngine {
   // May be nullptr if ANGLE failed to initialize.
   std::unique_ptr<AngleSurfaceManager> surface_manager_;
 
+  // Handler for the flutter/platform channel.
+  std::unique_ptr<PlatformHandler> platform_handler_;
+
   // The settings plugin.
   std::unique_ptr<SettingsPlugin> settings_plugin_;
 

shell/platform/windows/flutter_windows_view.cc

@@ -63,8 +63,6 @@ void FlutterWindowsView::SetEngine(
   // Set up the system channel handlers.
   auto internal_plugin_messenger = internal_plugin_registrar_->messenger();
   InitializeKeyboard();
-  platform_handler_ =
-      std::make_unique<PlatformHandler>(internal_plugin_messenger, this);
   cursor_handler_ = std::make_unique<CursorHandler>(internal_plugin_messenger,
                                                     binding_handler_.get());
 

shell/platform/windows/flutter_windows_view.h

@@ -22,7 +22,6 @@
 #include "flutter/shell/platform/windows/flutter_windows_engine.h"
 #include "flutter/shell/platform/windows/keyboard_handler_base.h"
 #include "flutter/shell/platform/windows/keyboard_key_embedder_handler.h"
-#include "flutter/shell/platform/windows/platform_handler.h"
 #include "flutter/shell/platform/windows/public/flutter_windows.h"
 #include "flutter/shell/platform/windows/text_input_plugin.h"
 #include "flutter/shell/platform/windows/text_input_plugin_delegate.h"
@@ -380,9 +379,6 @@ class FlutterWindowsView : public WindowBindingHandlerDelegate,
   // Handlers for text events from Windows.
   std::unique_ptr<TextInputPlugin> text_input_plugin_;
 
-  // Handler for the flutter/platform channel.
-  std::unique_ptr<PlatformHandler> platform_handler_;
-
   // Handler for cursor events.
   std::unique_ptr<CursorHandler> cursor_handler_;
 

shell/platform/windows/platform_handler.cc

@@ -199,14 +199,14 @@ int ScopedClipboard::SetString(const std::wstring string) {
 
 PlatformHandler::PlatformHandler(
     BinaryMessenger* messenger,
-    FlutterWindowsView* view,
+    FlutterWindowsEngine* engine,
     std::optional<std::function<std::unique_ptr<ScopedClipboardInterface>()>>
         scoped_clipboard_provider)
     : channel_(std::make_unique<MethodChannel<rapidjson::Document>>(
           messenger,
           kChannelName,
           &JsonMethodCodec::GetInstance())),
-      view_(view) {
+      engine_(engine) {
   channel_->SetMethodCallHandler(
       [this](const MethodCall<rapidjson::Document>& call,
              std::unique_ptr<MethodResult<rapidjson::Document>> result) {
@@ -226,10 +226,17 @@ PlatformHandler::~PlatformHandler() = default;
 void PlatformHandler::GetPlainText(
     std::unique_ptr<MethodResult<rapidjson::Document>> result,
     std::string_view key) {
+  const FlutterWindowsView* view = engine_->view();
+  if (view == nullptr) {
+    result->Error(kClipboardError,
+                  "Clipboard is not available in Windows headless mode");
+    return;
+  }
+
   std::unique_ptr<ScopedClipboardInterface> clipboard =
       scoped_clipboard_provider_();
 
-  int open_result = clipboard->Open(std::get<HWND>(*view_->GetRenderTarget()));
+  int open_result = clipboard->Open(std::get<HWND>(*view->GetRenderTarget()));
   if (open_result != kErrorSuccess) {
     rapidjson::Document error_code;
     error_code.SetInt(open_result);
@@ -262,11 +269,18 @@ void PlatformHandler::GetPlainText(
 
 void PlatformHandler::GetHasStrings(
     std::unique_ptr<MethodResult<rapidjson::Document>> result) {
+  const FlutterWindowsView* view = engine_->view();
+  if (view == nullptr) {
+    result->Error(kClipboardError,
+                  "Clipboard is not available in Windows headless mode");
+    return;
+  }
+
   std::unique_ptr<ScopedClipboardInterface> clipboard =
       scoped_clipboard_provider_();
 
   bool hasStrings;
-  int open_result = clipboard->Open(std::get<HWND>(*view_->GetRenderTarget()));
+  int open_result = clipboard->Open(std::get<HWND>(*view->GetRenderTarget()));
   if (open_result != kErrorSuccess) {
     // Swallow errors of type ERROR_ACCESS_DENIED. These happen when the app is
     // not in the foreground and GetHasStrings is irrelevant.
@@ -293,10 +307,17 @@ void PlatformHandler::GetHasStrings(
 void PlatformHandler::SetPlainText(
     const std::string& text,
     std::unique_ptr<MethodResult<rapidjson::Document>> result) {
+  const FlutterWindowsView* view = engine_->view();
+  if (view == nullptr) {
+    result->Error(kClipboardError,
+                  "Clipboard is not available in Windows headless mode");
+    return;
+  }
+
   std::unique_ptr<ScopedClipboardInterface> clipboard =
       scoped_clipboard_provider_();
 
-  int open_result = clipboard->Open(std::get<HWND>(*view_->GetRenderTarget()));
+  int open_result = clipboard->Open(std::get<HWND>(*view->GetRenderTarget()));
   if (open_result != kErrorSuccess) {
     rapidjson::Document error_code;
     error_code.SetInt(open_result);

shell/platform/windows/platform_handler.h

@@ -18,15 +18,15 @@
 
 namespace flutter {
 
-class FlutterWindowsView;
+class FlutterWindowsEngine;
 class ScopedClipboardInterface;
 
 // Handler for internal system channels.
 class PlatformHandler {
  public:
   explicit PlatformHandler(
       BinaryMessenger* messenger,
-      FlutterWindowsView* view,
+      FlutterWindowsEngine* engine,
       std::optional<std::function<std::unique_ptr<ScopedClipboardInterface>()>>
           scoped_clipboard_provider = std::nullopt);
 
@@ -68,8 +68,8 @@ class PlatformHandler {
   // The MethodChannel used for communication with the Flutter engine.
   std::unique_ptr<MethodChannel<rapidjson::Document>> channel_;
 
-  // A reference to the Flutter view.
-  FlutterWindowsView* view_;
+  // A reference to the Flutter engine.
+  FlutterWindowsEngine* engine_;
 
   // A scoped clipboard provider that can be passed in for mocking in tests.
   // Use this to acquire clipboard in each operation to avoid blocking clipboard