Review feedback + align code style with guidelines

Author: hbatagelo

engine/src/flutter/shell/platform/common/windowing.h

@@ -7,6 +7,7 @@
 
 #include <optional>
 
+#include "flutter/fml/mapping.h"
 #include "geometry.h"
 
 namespace flutter {
@@ -17,48 +18,51 @@ using FlutterViewId = int64_t;
 // Types of windows.
 enum class WindowArchetype {
   // Regular top-level window.
-  regular,
+  kRegular,
 };
 
 // Possible states a window can be in.
 enum class WindowState {
   // Normal state, neither maximized, nor minimized.
-  restored,
+  kRestored,
   // Maximized, occupying the full screen but still showing the system UI.
-  maximized,
+  kMaximized,
   // Minimized and not visible on the screen.
-  minimized,
+  kMinimized,
 };
 
-// Converts a |flutter::WindowState| to its corresponding string representation.
+// Converts a |flutter::WindowState| to the string representation of
+// |WindowState| as defined in the framework.
 inline std::string WindowStateToString(WindowState state) {
   switch (state) {
-    case WindowState::restored:
+    case WindowState::kRestored:
       return "WindowState.restored";
-    case WindowState::maximized:
+    case WindowState::kMaximized:
       return "WindowState.maximized";
-    case WindowState::minimized:
+    case WindowState::kMinimized:
       return "WindowState.minimized";
+    default:
+      FML_UNREACHABLE();
   }
-  return {};
 }
 
-// Converts a string to a |flutter::WindowState|. Returns std::nullopt if
+// Converts the string representation of |WindowState| defined in the framework
+// to a |flutter::WindowState|. Returns std::nullopt if the given string is
 // invalid.
 inline std::optional<WindowState> StringToWindowState(std::string_view str) {
   if (str == "WindowState.restored")
-    return WindowState::restored;
+    return WindowState::kRestored;
   if (str == "WindowState.maximized")
-    return WindowState::maximized;
+    return WindowState::kMaximized;
   if (str == "WindowState.minimized")
-    return WindowState::minimized;
+    return WindowState::kMinimized;
   return std::nullopt;
 }
 
 // Settings used for creating a Flutter window.
 struct WindowCreationSettings {
   // Type of the window.
-  WindowArchetype archetype = WindowArchetype::regular;
+  WindowArchetype archetype = WindowArchetype::kRegular;
   // Requested size of the window's client area, in logical coordinates.
   Size size;
   // Minimum size of the window's client area, in logical coordinates.
@@ -76,7 +80,7 @@ struct WindowMetadata {
   // The ID of the view used for this window, which is unique to each window.
   FlutterViewId view_id = 0;
   // The type of the window.
-  WindowArchetype archetype = WindowArchetype::regular;
+  WindowArchetype archetype = WindowArchetype::kRegular;
   // Size of the created window, in logical coordinates.
   Size size;
   // The ID of the view used by the parent window. If not set, the window is

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

@@ -146,9 +146,9 @@ std::optional<flutter::Size> GetWindowSizeForClientSize(
   UINT const dpi = flutter::GetDpiForHWND(owner_hwnd);
   double const scale_factor =
       static_cast<double>(dpi) / USER_DEFAULT_SCREEN_DPI;
-  RECT rect = {};
-  rect.right = static_cast<LONG>(client_size.width() * scale_factor);
-  rect.bottom = static_cast<LONG>(client_size.height() * scale_factor);
+  RECT rect = {
+      .right = static_cast<LONG>(client_size.width() * scale_factor),
+      .bottom = static_cast<LONG>(client_size.height() * scale_factor)};
 
   HMODULE const user32_raw = LoadLibraryA("User32.dll");
   auto free_user32_module = [](HMODULE module) { FreeLibrary(module); };
@@ -211,7 +211,7 @@ bool IsClassRegistered(LPCWSTR class_name) {
 }
 
 // Convert std::string to std::wstring
-std::wstring StringToWstring(const std::string& str) {
+std::wstring StringToWstring(std::string const& str) {
   if (str.empty()) {
     return {};
   }
@@ -273,7 +273,7 @@ FlutterHostWindow::FlutterHostWindow(FlutterHostWindowController* controller,
   DWORD window_style = 0;
   DWORD extended_window_style = 0;
   switch (archetype_) {
-    case WindowArchetype::regular:
+    case WindowArchetype::kRegular:
       window_style |= WS_OVERLAPPEDWINDOW;
       break;
     default:
@@ -395,23 +395,23 @@ FlutterHostWindow::FlutterHostWindow(FlutterHostWindowController* controller,
 
   SetChildContent(view_controller_->view()->GetWindowHandle());
 
-  state_ = settings.state.value_or(WindowState::restored);
+  state_ = settings.state.value_or(WindowState::kRestored);
 
   // TODO(loicsharma): Hide the window until the first frame is rendered.
   // Single window apps use the engine's next frame callback to show the
   // window. This doesn't work for multi window apps as the engine cannot have
   // multiple next frame callbacks. If multiple windows are created, only the
   // last one will be shown.
   UINT const cmd_show = [&]() {
-    if (archetype_ == WindowArchetype::regular) {
+    if (archetype_ == WindowArchetype::kRegular) {
       switch (state_) {
-        case WindowState::restored:
+        case WindowState::kRestored:
           return SW_SHOWNORMAL;
           break;
-        case WindowState::maximized:
+        case WindowState::kMaximized:
           return SW_SHOWMAXIMIZED;
           break;
-        case WindowState::minimized:
+        case WindowState::kMinimized:
           return SW_SHOWMINIMIZED;
           break;
         default:

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

@@ -79,7 +79,7 @@ class FlutterHostWindow {
   std::unique_ptr<FlutterWindowsViewController> view_controller_;
 
   // The window archetype.
-  WindowArchetype archetype_ = WindowArchetype::regular;
+  WindowArchetype archetype_ = WindowArchetype::kRegular;
 
   // Indicates if closing this window will quit the application.
   bool quit_on_close_ = false;
@@ -97,7 +97,7 @@ class FlutterHostWindow {
   std::optional<Size> max_size_;
 
   // The window state.
-  WindowState state_ = WindowState::restored;
+  WindowState state_ = WindowState::kRestored;
 
   FML_DISALLOW_COPY_AND_ASSIGN(FlutterHostWindow);
 };

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

@@ -112,10 +112,11 @@ LRESULT FlutterHostWindowController::HandleMessage(HWND hwnd,
           });
       if (it != windows_.end()) {
         auto& [view_id, window] = *it;
-        if (window->archetype_ == WindowArchetype::regular) {
-          window->state_ = (wparam == SIZE_MAXIMIZED)   ? WindowState::maximized
-                           : (wparam == SIZE_MINIMIZED) ? WindowState::minimized
-                                                        : WindowState::restored;
+        if (window->archetype_ == WindowArchetype::kRegular) {
+          window->state_ = (wparam == SIZE_MAXIMIZED) ? WindowState::kMaximized
+                           : (wparam == SIZE_MINIMIZED)
+                               ? WindowState::kMinimized
+                               : WindowState::kRestored;
         }
         SendOnWindowChanged(view_id, GetWindowSize(view_id), std::nullopt);
       }

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

@@ -64,7 +64,7 @@ class FlutterHostWindowControllerTest : public WindowsTest {
 TEST_F(FlutterHostWindowControllerTest, CreateRegularWindow) {
   // Define parameters for the window to be created.
   WindowCreationSettings const settings = {
-      .archetype = WindowArchetype::regular,
+      .archetype = WindowArchetype::kRegular,
       .size = {800.0, 600.0},
       .title = "window",
   };
@@ -130,7 +130,7 @@ TEST_F(FlutterHostWindowControllerTest, DestroyWindow) {
 
   // Define parameters for the window to be created.
   WindowCreationSettings const settings = {
-      .archetype = WindowArchetype::regular,
+      .archetype = WindowArchetype::kRegular,
       .size = {800.0, 600.0},
       .title = "window",
   };

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

@@ -134,7 +134,7 @@ void WindowingHandler::HandleMethodCall(
   const std::string& method = method_call.method_name();
 
   if (method == kCreateWindowMethod) {
-    HandleCreateWindow(WindowArchetype::regular, method_call, *result);
+    HandleCreateWindow(WindowArchetype::kRegular, method_call, *result);
   } else if (method == kDestroyWindowMethod) {
     HandleDestroyWindow(method_call, *result);
   } else {
@@ -153,8 +153,8 @@ void WindowingHandler::HandleCreateWindow(WindowArchetype archetype,
   }
 
   // Helper lambda to check and report invalid window size
-  auto const hasValidWindowSize = [&result](Size size,
-                                            std::string_view key_name) -> bool {
+  auto const has_valid_window_size =
+      [&result](Size size, std::string_view key_name) -> bool {
     if (size.width() <= 0 || size.height() <= 0) {
       result.Error(kInvalidValueError,
                    "Values for the '" + std::string(key_name) + "' key (" +
@@ -176,24 +176,24 @@ void WindowingHandler::HandleCreateWindow(WindowArchetype archetype,
     return;
   }
   settings.size = {size_list->at(0), size_list->at(1)};
-  if (!hasValidWindowSize(settings.size, kSizeKey)) {
+  if (!has_valid_window_size(settings.size, kSizeKey)) {
     return;
   }
 
-  if (archetype == WindowArchetype::regular) {
+  if (archetype == WindowArchetype::kRegular) {
     // Get value for the 'minSize' key (nullable)
     if (auto const list = GetListOfValuesForKeyOrSendError<double, 2>(
             kMinSizeKey, map, result)) {
       settings.min_size = {list->at(0), list->at(1)};
-      if (!hasValidWindowSize(*settings.min_size, kMinSizeKey)) {
+      if (!has_valid_window_size(*settings.min_size, kMinSizeKey)) {
         return;
       }
     }
     // Get value for the 'maxSize' key (nullable)
     if (auto const list = GetListOfValuesForKeyOrSendError<double, 2>(
             kMaxSizeKey, map, result)) {
       settings.max_size = {list->at(0), list->at(1)};
-      if (!hasValidWindowSize(*settings.max_size, kMaxSizeKey)) {
+      if (!has_valid_window_size(*settings.max_size, kMaxSizeKey)) {
         return;
       }
     }
@@ -214,7 +214,7 @@ void WindowingHandler::HandleCreateWindow(WindowArchetype archetype,
     WindowMetadata const& data = data_opt.value();
     EncodableMap map;
 
-    if (archetype == WindowArchetype::regular) {
+    if (archetype == WindowArchetype::kRegular) {
       map.insert({EncodableValue(kViewIdKey), EncodableValue(data.view_id)});
       map.insert(
           {EncodableValue(kSizeKey),

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

@@ -79,7 +79,7 @@ class WindowingHandlerTest : public WindowsTest {
         .WillByDefault([](WindowCreationSettings const& settings) {
           return WindowMetadata{
               .size = settings.size,
-              .state = WindowState::restored,
+              .state = WindowState::kRestored,
           };
         });
     ON_CALL(*mock_controller_, DestroyHostWindow).WillByDefault(Return(true));
@@ -110,7 +110,7 @@ TEST_F(WindowingHandlerTest, HandleCreateRegularWindow) {
   WindowingHandler windowing_handler(&messenger, controller());
 
   WindowCreationSettings const settings = {
-      .archetype = WindowArchetype::regular,
+      .archetype = WindowArchetype::kRegular,
       .size = {800.0, 600.0},
       .title = "regular",
   };