Add support for windows created in the runner

Author: hbatagelo

engine/src/flutter/shell/platform/windows/flutter_host_window.cc

@@ -15,6 +15,20 @@ namespace {
 
 constexpr wchar_t kWindowClassName[] = L"FLUTTER_HOST_WINDOW";
 
+// RAII wrapper for global Win32 ATOMs.
+struct AtomRAII {
+  AtomRAII(wchar_t const* name) : atom(GlobalAddAtom(name)) {}
+  ~AtomRAII() { GlobalDeleteAtom(atom); }
+  ATOM const atom;
+};
+
+// Atom representing a window property that stores a pointer to this host
+// window. This property serves as an alternative way to access the window in
+// |FlutterHostWindow::GetThisFromHandle| for windows created from existing
+// views, since the `GWLP_USERDATA` of such windows may point to something other
+// than a |FlutterHostWindow|.
+AtomRAII const kWindowPropAtom(kWindowClassName);
+
 // Clamps |size| to the size of the virtual screen. Both the parameter and
 // return size are in physical coordinates.
 flutter::Size ClampToVirtualScreen(flutter::Size size) {
@@ -303,6 +317,40 @@ FlutterHostWindow::FlutterHostWindow(FlutterHostWindowController* controller,
             window_size ? *window_size : Size{CW_USEDEFAULT, CW_USEDEFAULT}};
   }();
 
+  // Set up the view.
+  FlutterWindowsEngine* const engine = window_controller_->engine();
+  auto view_window = std::make_unique<FlutterWindow>(
+      initial_window_rect.width(), initial_window_rect.height(),
+      engine->windows_proc_table());
+
+  std::unique_ptr<FlutterWindowsView> view =
+      engine->CreateView(std::move(view_window));
+  if (!view) {
+    FML_LOG(ERROR) << "Failed to create view";
+    return;
+  }
+
+  view_controller_ =
+      std::make_unique<FlutterWindowsViewController>(nullptr, std::move(view));
+
+  // Launch the engine if it is not running already.
+  if (!engine->running() && !engine->Run()) {
+    FML_LOG(ERROR) << "Failed to launch engine";
+    return;
+  }
+  // Must happen after engine is running.
+  view_controller_->view()->SendInitialBounds();
+  // The Windows embedder listens to accessibility updates using the
+  // view's HWND. The embedder's accessibility features may be stale if
+  // the app was in headless mode.
+  view_controller_->engine()->UpdateAccessibilityFeatures();
+
+  // Ensure that basic setup of the view controller was successful.
+  if (!view_controller_->view()) {
+    FML_LOG(ERROR) << "Failed to set up the view controller";
+    return;
+  }
+
   // Register the window class.
   if (!IsClassRegistered(kWindowClassName)) {
     auto const idi_app_icon = 101;
@@ -354,44 +402,6 @@ FlutterHostWindow::FlutterHostWindow(FlutterHostWindowController* controller,
                window_rect.top - top_dropshadow_height, 0, 0,
                SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
 
-  // Set up the view.
-  RECT client_rect;
-  GetClientRect(hwnd, &client_rect);
-  int const width = client_rect.right - client_rect.left;
-  int const height = client_rect.bottom - client_rect.top;
-
-  FlutterWindowsEngine* const engine = window_controller_->engine();
-  auto view_window = std::make_unique<FlutterWindow>(
-      width, height, engine->windows_proc_table());
-
-  std::unique_ptr<FlutterWindowsView> view =
-      engine->CreateView(std::move(view_window));
-  if (!view) {
-    FML_LOG(ERROR) << "Failed to create view";
-    return;
-  }
-
-  view_controller_ =
-      std::make_unique<FlutterWindowsViewController>(nullptr, std::move(view));
-
-  // Launch the engine if it is not running already.
-  if (!engine->running() && !engine->Run()) {
-    FML_LOG(ERROR) << "Failed to launch engine";
-    return;
-  }
-  // Must happen after engine is running.
-  view_controller_->view()->SendInitialBounds();
-  // The Windows embedder listens to accessibility updates using the
-  // view's HWND. The embedder's accessibility features may be stale if
-  // the app was in headless mode.
-  view_controller_->engine()->UpdateAccessibilityFeatures();
-
-  // Ensure that basic setup of the view controller was successful.
-  if (!view_controller_->view()) {
-    FML_LOG(ERROR) << "Failed to set up the view controller";
-    return;
-  }
-
   UpdateTheme(hwnd);
 
   SetChildContent(view_controller_->view()->GetWindowHandle());
@@ -426,26 +436,46 @@ FlutterHostWindow::FlutterHostWindow(FlutterHostWindowController* controller,
   window_handle_ = hwnd;
 }
 
+FlutterHostWindow::FlutterHostWindow(FlutterHostWindowController* controller,
+                                     HWND hwnd,
+                                     FlutterWindowsView* view)
+    : window_controller_(controller), window_handle_(hwnd) {
+  if (!SetProp(hwnd, MAKEINTATOM(kWindowPropAtom.atom), this)) {
+    FML_LOG(ERROR) << "Failed to set up entry in the window property list";
+    return;
+  }
+  child_content_ = view->GetWindowHandle();
+}
+
 FlutterHostWindow::~FlutterHostWindow() {
-  if (HWND const hwnd = window_handle_) {
-    window_handle_ = nullptr;
+  HWND const hwnd = window_handle_;
+  window_handle_ = nullptr;
+  if (view_controller_) {
     DestroyWindow(hwnd);
-
-    // Unregisters the window class. It will fail silently if there are
-    // other windows using the class, as only the last window can
-    // successfully unregister the class.
+    // Unregister the window class. Fail silently if other windows are still
+    // using the class, as only the last window can successfully unregister it.
     if (!UnregisterClass(kWindowClassName, GetModuleHandle(nullptr))) {
-      // Clears the error information after the failed unregistering.
+      // Clear the error state after the failed unregistration.
       SetLastError(ERROR_SUCCESS);
     }
   }
 }
 
 FlutterHostWindow* FlutterHostWindow::GetThisFromHandle(HWND hwnd) {
+  // For native windows created by the runner, retrieve the instance pointer
+  // from a window property.
+  if (HANDLE const data = GetProp(hwnd, MAKEINTATOM(kWindowPropAtom.atom))) {
+    return reinterpret_cast<FlutterHostWindow*>(data);
+  }
+  // Otherwise, retrieve the instance pointer from the window's user data.
   return reinterpret_cast<FlutterHostWindow*>(
       GetWindowLongPtr(hwnd, GWLP_USERDATA));
 }
 
+bool FlutterHostWindow::HasThisAsProperty(HWND hwnd) {
+  return GetProp(hwnd, MAKEINTATOM(kWindowPropAtom.atom)) != nullptr;
+}
+
 HWND FlutterHostWindow::GetWindowHandle() const {
   return window_handle_;
 }
@@ -487,12 +517,6 @@ LRESULT FlutterHostWindow::HandleMessage(HWND hwnd,
                                          WPARAM wparam,
                                          LPARAM lparam) {
   switch (message) {
-    case WM_DESTROY:
-      if (window_handle_ && quit_on_close_) {
-        PostQuitMessage(0);
-      }
-      return 0;
-
     case WM_DPICHANGED: {
       auto* const new_scaled_window_rect = reinterpret_cast<RECT*>(lparam);
       LONG const width =
@@ -567,6 +591,18 @@ LRESULT FlutterHostWindow::HandleMessage(HWND hwnd,
       break;
   }
 
+  if (!view_controller_) {
+    return 0;
+  }
+
+  if (window_handle_) {
+    LRESULT* result;
+    if (view_controller_->engine()->lifecycle_manager()->WindowProc(
+            hwnd, message, wparam, lparam, result)) {
+      return 0;
+    }
+  }
+
   return DefWindowProc(hwnd, message, wparam, lparam);
 }
 

engine/src/flutter/shell/platform/windows/flutter_host_window.h

@@ -17,6 +17,7 @@
 namespace flutter {
 
 class FlutterHostWindowController;
+class FlutterWindowsView;
 class FlutterWindowsViewController;
 
 // A Win32 window that hosts a |FlutterWindow| in its client area.
@@ -28,11 +29,21 @@ class FlutterHostWindow {
   // |FlutterHostWindow::GetWindowHandle|.
   FlutterHostWindow(FlutterHostWindowController* controller,
                     WindowCreationSettings const& settings);
+  // Creates a |FlutterHostWindow| from an existing |view| associated with a
+  // top-level |hwnd|. Used when the native window is created by the runner.
+  FlutterHostWindow(FlutterHostWindowController* controller,
+                    HWND hwnd,
+                    FlutterWindowsView* view);
   virtual ~FlutterHostWindow();
 
   // Returns the instance pointer for |hwnd| or nulllptr if invalid.
   static FlutterHostWindow* GetThisFromHandle(HWND hwnd);
 
+  // Returns true if |hwnd| has an instance pointer set as a window property.
+  // This is the case only if |hwnd| was created by the runner with an
+  // associated |FlutterHostWindow|.
+  static bool HasThisAsProperty(HWND hwnd);
+
   // Returns the current window state.
   WindowState GetState() const;
 
@@ -43,7 +54,7 @@ class FlutterHostWindow {
  private:
   friend FlutterHostWindowController;
 
-  // Set the focus to the child view window of |window|.
+  // Sets the focus to the child view window of |window|.
   static void FocusViewOf(FlutterHostWindow* window);
 
   // OS callback called by message pump. Handles the WM_NCCREATE message which
@@ -70,9 +81,11 @@ class FlutterHostWindow {
   void SetTitle(std::string_view title) const;
 
   // Controller for this window.
-  FlutterHostWindowController* const window_controller_;
+  FlutterHostWindowController* const window_controller_ = nullptr;
 
-  // Controller for the view hosted by this window.
+  // Controller for the view hosted in this window. Value-initialized if the
+  // window is created from an existing top-level native window created by the
+  // runner.
   std::unique_ptr<FlutterWindowsViewController> view_controller_;
 
   // The window archetype.

engine/src/flutter/shell/platform/windows/flutter_host_window_controller.cc

@@ -32,10 +32,6 @@ FlutterHostWindowController::FlutterHostWindowController(
     FlutterWindowsEngine* engine)
     : engine_(engine) {}
 
-FlutterHostWindowController::~FlutterHostWindowController() {
-  DestroyAllWindows();
-}
-
 std::optional<WindowMetadata> FlutterHostWindowController::CreateHostWindow(
     WindowCreationSettings const& settings) {
   auto window = std::make_unique<FlutterHostWindow>(this, settings);
@@ -63,6 +59,15 @@ std::optional<WindowMetadata> FlutterHostWindowController::CreateHostWindow(
   return result;
 }
 
+void FlutterHostWindowController::CreateHostWindowFromExisting(
+    HWND hwnd,
+    FlutterWindowsView* view) {
+  auto window = std::make_unique<FlutterHostWindow>(this, hwnd, view);
+
+  FlutterViewId const view_id = view->view_id();
+  windows_[view_id] = std::move(window);
+}
+
 bool FlutterHostWindowController::ModifyHostWindow(
     FlutterViewId view_id,
     WindowModificationSettings const& settings) const {
@@ -123,49 +128,49 @@ LRESULT FlutterHostWindowController::HandleMessage(HWND hwnd,
                                                    UINT message,
                                                    WPARAM wparam,
                                                    LPARAM lparam) {
-  switch (message) {
-    case WM_NCDESTROY: {
-      auto const it = std::find_if(
-          windows_.begin(), windows_.end(), [hwnd](auto const& window) {
-            return window.second->GetWindowHandle() == hwnd;
-          });
-      if (it != windows_.end()) {
-        FlutterViewId const view_id = it->first;
-        bool const quit_on_close = it->second->quit_on_close_;
-
-        windows_.erase(it);
-
-        SendOnWindowDestroyed(view_id);
-
-        if (quit_on_close) {
-          DestroyAllWindows();
+  if (engine_->running()) {
+    switch (message) {
+      case WM_NCDESTROY:
+        if (engine_->running()) {
+          auto const it = std::find_if(
+              windows_.begin(), windows_.end(), [hwnd](auto const& pair) {
+                return pair.second->GetWindowHandle() == hwnd;
+              });
+          if (it != windows_.end()) {
+            FlutterViewId const view_id = it->first;
+            bool const quit_on_close = it->second->quit_on_close_;
+            windows_.erase(it);
+            SendOnWindowDestroyed(view_id);
+            if (quit_on_close) {
+              PostQuitMessage(0);
+            }
+          }
         }
-      }
-    }
-      return 0;
-    case WM_SIZE: {
-      auto const it = std::find_if(
-          windows_.begin(), windows_.end(), [hwnd](auto const& window) {
-            return window.second->GetWindowHandle() == hwnd;
-          });
-      if (it != windows_.end()) {
-        auto& [view_id, window] = *it;
-        if (window->archetype_ == WindowArchetype::kRegular) {
-          window->state_ = (wparam == SIZE_MAXIMIZED) ? WindowState::kMaximized
-                           : (wparam == SIZE_MINIMIZED)
-                               ? WindowState::kMinimized
-                               : WindowState::kRestored;
+        return 0;
+      case WM_SIZE: {
+        auto const it = std::find_if(
+            windows_.begin(), windows_.end(), [hwnd](auto const& pair) {
+              return pair.second->GetWindowHandle() == hwnd;
+            });
+        if (it != windows_.end()) {
+          auto& [view_id, window] = *it;
+          if (window->archetype_ == WindowArchetype::kRegular) {
+            window->state_ =
+                (wparam == SIZE_MAXIMIZED)   ? WindowState::kMaximized
+                : (wparam == SIZE_MINIMIZED) ? WindowState::kMinimized
+                                             : WindowState::kRestored;
+          }
+          SendOnWindowChanged(view_id, GetViewSize(view_id), std::nullopt);
         }
-        SendOnWindowChanged(view_id, GetViewSize(view_id), std::nullopt);
-      }
-    } break;
-    default:
-      break;
-  }
+      } break;
+      default:
+        break;
+    }
 
-  if (FlutterHostWindow* const window =
-          FlutterHostWindow::GetThisFromHandle(hwnd)) {
-    return window->HandleMessage(hwnd, message, wparam, lparam);
+    if (FlutterHostWindow* const window =
+            FlutterHostWindow::GetThisFromHandle(hwnd)) {
+      return window->HandleMessage(hwnd, message, wparam, lparam);
+    }
   }
   return DefWindowProc(hwnd, message, wparam, lparam);
 }
@@ -179,20 +184,6 @@ FlutterWindowsEngine* FlutterHostWindowController::engine() const {
   return engine_;
 }
 
-void FlutterHostWindowController::DestroyAllWindows() {
-  if (!windows_.empty()) {
-    // Destroy windows in reverse order of creation.
-    for (auto it = std::prev(windows_.end());
-         it != std::prev(windows_.begin());) {
-      auto const current = it--;
-      auto const& [view_id, window] = *current;
-      if (window->GetWindowHandle()) {
-        DestroyHostWindow(view_id);
-      }
-    }
-  }
-}
-
 Size FlutterHostWindowController::GetViewSize(FlutterViewId view_id) const {
   HWND const window_handle = GetHostWindow(view_id)->GetWindowHandle();
   RECT rect;