Flutter Windows Embedder
flutter_windows_view_unittests.cc
Go to the documentation of this file.
1 // Copyright 2013 The Flutter Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
6 
7 #include <UIAutomation.h>
8 #include <comdef.h>
9 #include <comutil.h>
10 #include <oleacc.h>
11 
12 #include <future>
13 #include <vector>
14 
15 #include "flutter/fml/logging.h"
16 #include "flutter/fml/synchronization/waitable_event.h"
18 #include "flutter/shell/platform/embedder/test_utils/proc_table_replacement.h"
23 #include "flutter/shell/platform/windows/testing/egl/mock_context.h"
24 #include "flutter/shell/platform/windows/testing/egl/mock_manager.h"
25 #include "flutter/shell/platform/windows/testing/egl/mock_window_surface.h"
26 #include "flutter/shell/platform/windows/testing/engine_modifier.h"
27 #include "flutter/shell/platform/windows/testing/mock_window_binding_handler.h"
28 #include "flutter/shell/platform/windows/testing/mock_windows_proc_table.h"
29 #include "flutter/shell/platform/windows/testing/test_keyboard.h"
30 #include "flutter/shell/platform/windows/testing/view_modifier.h"
31 
32 #include "gmock/gmock.h"
33 #include "gtest/gtest.h"
34 
35 namespace flutter {
36 namespace testing {
37 
38 using ::testing::_;
39 using ::testing::InSequence;
40 using ::testing::NiceMock;
41 using ::testing::Return;
42 
43 constexpr uint64_t kScanCodeKeyA = 0x1e;
44 constexpr uint64_t kVirtualKeyA = 0x41;
45 
46 namespace {
47 
48 // A struct to use as a FlutterPlatformMessageResponseHandle so it can keep the
49 // callbacks and user data passed to the engine's
50 // PlatformMessageCreateResponseHandle for use in the SendPlatformMessage
51 // overridden function.
52 struct TestResponseHandle {
54  void* user_data;
55 };
56 
57 static bool test_response = false;
58 
59 constexpr uint64_t kKeyEventFromChannel = 0x11;
60 constexpr uint64_t kKeyEventFromEmbedder = 0x22;
61 static std::vector<int> key_event_logs;
62 
63 std::unique_ptr<std::vector<uint8_t>> keyHandlingResponse(bool handled) {
64  rapidjson::Document document;
65  auto& allocator = document.GetAllocator();
66  document.SetObject();
67  document.AddMember("handled", test_response, allocator);
69 }
70 
71 // Returns a Flutter project with the required path values to create
72 // a test engine.
73 FlutterProjectBundle GetTestProject() {
74  FlutterDesktopEngineProperties properties = {};
75  properties.assets_path = L"C:\\foo\\flutter_assets";
76  properties.icu_data_path = L"C:\\foo\\icudtl.dat";
77  properties.aot_library_path = L"C:\\foo\\aot.so";
78  properties.impeller_switch = DefaultImpeller;
79 
80  return FlutterProjectBundle{properties};
81 }
82 
83 class ViewTestEGLManager : public egl::MockManager {
84  public:
85  ViewTestEGLManager() {
86  ON_CALL(*this, CreateWindowSurface).WillByDefault([](HWND, size_t, size_t) {
87  auto surface = std::make_unique<NiceMock<egl::MockWindowSurface>>();
88  ON_CALL(*surface, IsValid).WillByDefault(Return(true));
89  ON_CALL(*surface, MakeCurrent).WillByDefault(Return(true));
90  ON_CALL(*surface, SetVSyncEnabled).WillByDefault(Return(true));
91  ON_CALL(*surface, Destroy).WillByDefault(Return(true));
92  return surface;
93  });
94  ON_CALL(*this, render_context).WillByDefault(Return(&mock_context_));
95  ON_CALL(*this, resource_context).WillByDefault(Return(&mock_context_));
96  ON_CALL(mock_context_, ClearCurrent).WillByDefault(Return(true));
97  ON_CALL(mock_context_, MakeCurrent).WillByDefault(Return(true));
98  }
99 
100  private:
101  NiceMock<egl::MockContext> mock_context_;
102 };
103 
104 // Returns an engine instance configured with test project path values, and
105 // overridden methods for sending platform messages, so that the engine can
106 // respond as if the framework were connected.
107 std::unique_ptr<FlutterWindowsEngine> GetTestEngine(
108  std::shared_ptr<WindowsProcTable> windows_proc_table = nullptr) {
109  auto engine = std::make_unique<FlutterWindowsEngine>(
110  GetTestProject(), std::move(windows_proc_table));
111 
112  EngineModifier modifier(engine.get());
113  modifier.SetEGLManager(std::make_unique<NiceMock<ViewTestEGLManager>>());
114  modifier.embedder_api().Run = MOCK_ENGINE_PROC(
115  Run, ([](size_t version, const FlutterRendererConfig* config,
116  const FlutterProjectArgs* args, void* user_data,
117  FLUTTER_API_SYMBOL(FlutterEngine)* engine) {
118  *engine =
119  reinterpret_cast<FLUTTER_API_SYMBOL(FlutterEngine)>(0x12345678);
120  return kSuccess;
121  }));
122 
123  modifier.embedder_api().Shutdown = MOCK_ENGINE_PROC(
124  Shutdown,
125  ([](FLUTTER_API_SYMBOL(FlutterEngine) engine) { return kSuccess; }));
126 
127  modifier.embedder_api().UpdateLocales = MOCK_ENGINE_PROC(
128  UpdateLocales, ([](FLUTTER_API_SYMBOL(FlutterEngine) engine,
129  const FlutterLocale** locales,
130  size_t locales_count) { return kSuccess; }));
131 
132  modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
133  UpdateAccessibilityFeatures,
134  ([](FLUTTER_API_SYMBOL(FlutterEngine) engine,
135  FlutterAccessibilityFeature flags) { return kSuccess; }));
136 
137  modifier.embedder_api().PostRenderThreadTask = MOCK_ENGINE_PROC(
138  PostRenderThreadTask, ([](auto engine, auto callback, auto context) {
139  callback(context);
140  return kSuccess;
141  }));
142 
143  auto key_response_controller = std::make_shared<MockKeyResponseController>();
144  key_response_controller->SetChannelResponse(
145  [](MockKeyResponseController::ResponseCallback callback) {
146  key_event_logs.push_back(kKeyEventFromChannel);
147  callback(test_response);
148  });
149  key_response_controller->SetEmbedderResponse(
150  [](const FlutterKeyEvent* event,
151  MockKeyResponseController::ResponseCallback callback) {
152  key_event_logs.push_back(kKeyEventFromEmbedder);
153  callback(test_response);
154  });
155  modifier.embedder_api().NotifyDisplayUpdate =
156  MOCK_ENGINE_PROC(NotifyDisplayUpdate,
157  ([engine_instance = engine.get()](
158  FLUTTER_API_SYMBOL(FlutterEngine) raw_engine,
159  const FlutterEngineDisplaysUpdateType update_type,
160  const FlutterEngineDisplay* embedder_displays,
161  size_t display_count) { return kSuccess; }));
162 
163  MockEmbedderApiForKeyboard(modifier, key_response_controller);
164 
165  engine->Run();
166  return engine;
167 }
168 
169 class MockFlutterWindowsEngine : public FlutterWindowsEngine {
170  public:
171  explicit MockFlutterWindowsEngine(
172  std::shared_ptr<WindowsProcTable> windows_proc_table = nullptr)
173  : FlutterWindowsEngine(GetTestProject(), std::move(windows_proc_table)) {}
174 
175  MOCK_METHOD(bool, running, (), (const));
176  MOCK_METHOD(bool, Stop, (), ());
177  MOCK_METHOD(void, RemoveView, (FlutterViewId view_id), ());
178  MOCK_METHOD(bool, PostRasterThreadTask, (fml::closure), (const));
179 
180  private:
181  FML_DISALLOW_COPY_AND_ASSIGN(MockFlutterWindowsEngine);
182 };
183 
184 } // namespace
185 
186 // Ensure that submenu buttons have their expanded/collapsed status set
187 // apropriately.
188 TEST(FlutterWindowsViewTest, SubMenuExpandedState) {
189  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
190  EngineModifier modifier(engine.get());
191  modifier.embedder_api().UpdateSemanticsEnabled =
192  [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
193  return kSuccess;
194  };
195 
196  auto window_binding_handler =
197  std::make_unique<NiceMock<MockWindowBindingHandler>>();
198  std::unique_ptr<FlutterWindowsView> view =
199  engine->CreateView(std::move(window_binding_handler),
200  /*is_sized_to_content=*/false, BoxConstraints(),
201  /*allow_implicit_view=*/true);
202 
203  // Enable semantics to instantiate accessibility bridge.
204  view->OnUpdateSemanticsEnabled(true);
205 
206  auto bridge = view->accessibility_bridge().lock();
207  ASSERT_TRUE(bridge);
208 
209  FlutterSemanticsNode2 root{sizeof(FlutterSemanticsNode2), 0};
210  root.id = 0;
211  root.label = "root";
212  root.hint = "";
213  root.value = "";
214  root.increased_value = "";
215  root.decreased_value = "";
216  root.child_count = 0;
217  root.custom_accessibility_actions_count = 0;
218  auto flags = FlutterSemanticsFlags{
219  .is_expanded = FlutterTristate::kFlutterTristateTrue,
220  };
221  root.flags2 = &flags;
222 
223  bridge->AddFlutterSemanticsNodeUpdate(root);
224 
225  bridge->CommitUpdates();
226 
227  {
228  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
229  EXPECT_TRUE(root_node->GetData().HasState(ax::mojom::State::kExpanded));
230 
231  // Get the IAccessible for the root node.
232  IAccessible* native_view = root_node->GetNativeViewAccessible();
233  ASSERT_TRUE(native_view != nullptr);
234 
235  // Look up against the node itself (not one of its children).
236  VARIANT varchild = {};
237  varchild.vt = VT_I4;
238 
239  // Verify the submenu is expanded.
240  varchild.lVal = CHILDID_SELF;
241  VARIANT native_state = {};
242  ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
243  EXPECT_TRUE(native_state.lVal & STATE_SYSTEM_EXPANDED);
244 
245  // Perform similar tests for UIA value;
246  IRawElementProviderSimple* uia_node;
247  native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
248  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
249  UIA_ExpandCollapseExpandCollapseStatePropertyId, &native_state)));
250  EXPECT_EQ(native_state.lVal, ExpandCollapseState_Expanded);
251 
252  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
253  UIA_AriaPropertiesPropertyId, &native_state)));
254  EXPECT_NE(std::wcsstr(native_state.bstrVal, L"expanded=true"), nullptr);
255  }
256 
257  // Test collapsed too.
258  auto updated_flags = FlutterSemanticsFlags{
259  .is_expanded = FlutterTristate::kFlutterTristateFalse,
260  };
261  root.flags2 = &updated_flags;
262 
263  bridge->AddFlutterSemanticsNodeUpdate(root);
264  bridge->CommitUpdates();
265 
266  {
267  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
268  EXPECT_TRUE(root_node->GetData().HasState(ax::mojom::State::kCollapsed));
269 
270  // Get the IAccessible for the root node.
271  IAccessible* native_view = root_node->GetNativeViewAccessible();
272  ASSERT_TRUE(native_view != nullptr);
273 
274  // Look up against the node itself (not one of its children).
275  VARIANT varchild = {};
276  varchild.vt = VT_I4;
277 
278  // Verify the submenu is collapsed.
279  varchild.lVal = CHILDID_SELF;
280  VARIANT native_state = {};
281  ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
282  EXPECT_TRUE(native_state.lVal & STATE_SYSTEM_COLLAPSED);
283 
284  // Perform similar tests for UIA value;
285  IRawElementProviderSimple* uia_node;
286  native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
287  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
288  UIA_ExpandCollapseExpandCollapseStatePropertyId, &native_state)));
289  EXPECT_EQ(native_state.lVal, ExpandCollapseState_Collapsed);
290 
291  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
292  UIA_AriaPropertiesPropertyId, &native_state)));
293  EXPECT_NE(std::wcsstr(native_state.bstrVal, L"expanded=false"), nullptr);
294  }
295 }
296 
297 // The view's surface must be destroyed after the engine is shutdown.
298 // See: https://github.com/flutter/flutter/issues/124463
299 TEST(FlutterWindowsViewTest, Shutdown) {
300  auto engine = std::make_unique<MockFlutterWindowsEngine>();
301  auto window_binding_handler =
302  std::make_unique<NiceMock<MockWindowBindingHandler>>();
303  auto egl_manager = std::make_unique<egl::MockManager>();
304  auto surface = std::make_unique<egl::MockWindowSurface>();
305  egl::MockContext render_context;
306 
307  auto engine_ptr = engine.get();
308  auto surface_ptr = surface.get();
309  auto egl_manager_ptr = egl_manager.get();
310 
311  EngineModifier modifier{engine.get()};
312  modifier.SetEGLManager(std::move(egl_manager));
313 
314  InSequence s;
315  std::unique_ptr<FlutterWindowsView> view;
316 
317  // Mock render surface initialization.
318  {
319  EXPECT_CALL(*egl_manager_ptr, CreateWindowSurface)
320  .WillOnce(Return(std::move(surface)));
321  EXPECT_CALL(*engine_ptr, running).WillOnce(Return(false));
322  EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(true));
323  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
324  EXPECT_CALL(*surface_ptr, SetVSyncEnabled).WillOnce(Return(true));
325  EXPECT_CALL(*egl_manager_ptr, render_context)
326  .WillOnce(Return(&render_context));
327  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
328 
329  view = engine->CreateView(std::move(window_binding_handler), false,
330  BoxConstraints(), /*allow_implicit_view=*/true);
331  }
332 
333  // The view must be removed before the surface can be destroyed.
334  {
335  auto view_id = view->view_id();
336  FlutterWindowsViewController controller{std::move(engine), std::move(view)};
337 
338  EXPECT_CALL(*engine_ptr, running).WillOnce(Return(true));
339  EXPECT_CALL(*engine_ptr, RemoveView(view_id)).Times(1);
340  EXPECT_CALL(*engine_ptr, running).WillOnce(Return(true));
341  EXPECT_CALL(*engine_ptr, PostRasterThreadTask)
342  .WillOnce([](fml::closure callback) {
343  callback();
344  return true;
345  });
346  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
347  }
348 }
349 
350 TEST(FlutterWindowsViewTest, KeySequence) {
351  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
352 
353  test_response = false;
354 
355  std::unique_ptr<FlutterWindowsView> view =
356  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
357  /*is_sized_to_content=*/false, BoxConstraints(),
358  /*allow_implicit_view=*/true);
359 
360  view->OnKey(kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false, false,
361  [](bool handled) {});
362 
363  EXPECT_EQ(key_event_logs.size(), 2);
364  EXPECT_EQ(key_event_logs[0], kKeyEventFromEmbedder);
365  EXPECT_EQ(key_event_logs[1], kKeyEventFromChannel);
366 
367  key_event_logs.clear();
368 }
369 
370 TEST(FlutterWindowsViewTest, KeyEventCallback) {
371  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
372 
373  std::unique_ptr<FlutterWindowsView> view =
374  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
375  /*is_sized_to_content=*/false, BoxConstraints(),
376  /*allow_implicit_view=*/true);
377 
378  class MockCallback {
379  public:
380  MOCK_METHOD(void, Call, ());
381  };
382 
383  NiceMock<MockCallback> callback_with_valid_view;
384  NiceMock<MockCallback> callback_with_invalid_view;
385 
386  auto trigger_key_event = [&](NiceMock<MockCallback>& callback) {
387  view->OnKey(kVirtualKeyA, kScanCodeKeyA, WM_KEYDOWN, 'a', false, false,
388  [&](bool) { callback.Call(); });
389  };
390 
391  EXPECT_CALL(callback_with_valid_view, Call()).Times(1);
392  EXPECT_CALL(callback_with_invalid_view, Call()).Times(0);
393 
394  trigger_key_event(callback_with_valid_view);
395  engine->RemoveView(view->view_id());
396  trigger_key_event(callback_with_invalid_view);
397 
398  key_event_logs.clear();
399 }
400 
401 TEST(FlutterWindowsViewTest, EnableSemantics) {
402  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
403  EngineModifier modifier(engine.get());
404 
405  bool semantics_enabled = false;
406  modifier.embedder_api().UpdateSemanticsEnabled = MOCK_ENGINE_PROC(
407  UpdateSemanticsEnabled,
408  [&semantics_enabled](FLUTTER_API_SYMBOL(FlutterEngine) engine,
409  bool enabled) {
410  semantics_enabled = enabled;
411  return kSuccess;
412  });
413 
414  auto window_binding_handler =
415  std::make_unique<NiceMock<MockWindowBindingHandler>>();
416  std::unique_ptr<FlutterWindowsView> view =
417  engine->CreateView(std::move(window_binding_handler),
418  /*is_sized_to_content=*/false, BoxConstraints(),
419  /*allow_implicit_view=*/true);
420 
421  view->OnUpdateSemanticsEnabled(true);
422  EXPECT_TRUE(semantics_enabled);
423 }
424 
425 TEST(FlutterWindowsViewTest, AddSemanticsNodeUpdate) {
426  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
427  EngineModifier modifier(engine.get());
428  modifier.embedder_api().UpdateSemanticsEnabled =
429  [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
430  return kSuccess;
431  };
432 
433  auto window_binding_handler =
434  std::make_unique<NiceMock<MockWindowBindingHandler>>();
435  std::unique_ptr<FlutterWindowsView> view =
436  engine->CreateView(std::move(window_binding_handler),
437  /*is_sized_to_content=*/false, BoxConstraints(),
438  /*allow_implicit_view=*/true);
439 
440  // Enable semantics to instantiate accessibility bridge.
441  view->OnUpdateSemanticsEnabled(true);
442 
443  auto bridge = view->accessibility_bridge().lock();
444  ASSERT_TRUE(bridge);
445 
446  // Add root node.
447  FlutterSemanticsNode2 node{sizeof(FlutterSemanticsNode2), 0};
448  node.label = "name";
449  node.value = "value";
450  node.platform_view_id = -1;
451  auto flags = FlutterSemanticsFlags{};
452  node.flags2 = &flags;
453  bridge->AddFlutterSemanticsNodeUpdate(node);
454  bridge->CommitUpdates();
455 
456  // Look up the root windows node delegate.
457  auto node_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
458  ASSERT_TRUE(node_delegate);
459  EXPECT_EQ(node_delegate->GetChildCount(), 0);
460 
461  // Get the native IAccessible object.
462  IAccessible* native_view = node_delegate->GetNativeViewAccessible();
463  ASSERT_TRUE(native_view != nullptr);
464 
465  // Property lookups will be made against this node itself.
466  VARIANT varchild{};
467  varchild.vt = VT_I4;
468  varchild.lVal = CHILDID_SELF;
469 
470  // Verify node name matches our label.
471  BSTR bname = nullptr;
472  ASSERT_EQ(native_view->get_accName(varchild, &bname), S_OK);
473  std::string name(_com_util::ConvertBSTRToString(bname));
474  EXPECT_EQ(name, "name");
475 
476  // Verify node value matches.
477  BSTR bvalue = nullptr;
478  ASSERT_EQ(native_view->get_accValue(varchild, &bvalue), S_OK);
479  std::string value(_com_util::ConvertBSTRToString(bvalue));
480  EXPECT_EQ(value, "value");
481 
482  // Verify node type is static text.
483  VARIANT varrole{};
484  varrole.vt = VT_I4;
485  ASSERT_EQ(native_view->get_accRole(varchild, &varrole), S_OK);
486  EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_STATICTEXT);
487 
488  // Get the IRawElementProviderFragment object.
489  IRawElementProviderSimple* uia_view;
490  native_view->QueryInterface(IID_PPV_ARGS(&uia_view));
491  ASSERT_TRUE(uia_view != nullptr);
492 
493  // Verify name property matches our label.
494  VARIANT varname{};
495  ASSERT_EQ(uia_view->GetPropertyValue(UIA_NamePropertyId, &varname), S_OK);
496  EXPECT_EQ(varname.vt, VT_BSTR);
497  name = _com_util::ConvertBSTRToString(varname.bstrVal);
498  EXPECT_EQ(name, "name");
499 
500  // Verify value property matches our label.
501  VARIANT varvalue{};
502  ASSERT_EQ(uia_view->GetPropertyValue(UIA_ValueValuePropertyId, &varvalue),
503  S_OK);
504  EXPECT_EQ(varvalue.vt, VT_BSTR);
505  value = _com_util::ConvertBSTRToString(varvalue.bstrVal);
506  EXPECT_EQ(value, "value");
507 
508  // Verify node control type is text.
509  varrole = {};
510  ASSERT_EQ(uia_view->GetPropertyValue(UIA_ControlTypePropertyId, &varrole),
511  S_OK);
512  EXPECT_EQ(varrole.vt, VT_I4);
513  EXPECT_EQ(varrole.lVal, UIA_TextControlTypeId);
514 }
515 
516 // Verify the native IAccessible COM object tree is an accurate reflection of
517 // the platform-agnostic tree. Verify both a root node with children as well as
518 // a non-root node with children, since the AX tree includes special handling
519 // for the root.
520 //
521 // node0
522 // / \
523 // node1 node2
524 // |
525 // node3
526 //
527 // node0 and node2 are grouping nodes. node1 and node2 are static text nodes.
528 TEST(FlutterWindowsViewTest, AddSemanticsNodeUpdateWithChildren) {
529  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
530  EngineModifier modifier(engine.get());
531  modifier.embedder_api().UpdateSemanticsEnabled =
532  [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
533  return kSuccess;
534  };
535 
536  std::unique_ptr<FlutterWindowsView> view =
537  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
538  /*is_sized_to_content=*/false, BoxConstraints(),
539  /*allow_implicit_view=*/true);
540 
541  // Enable semantics to instantiate accessibility bridge.
542  view->OnUpdateSemanticsEnabled(true);
543 
544  auto bridge = view->accessibility_bridge().lock();
545  ASSERT_TRUE(bridge);
546 
547  // Add root node.
548  FlutterSemanticsNode2 node0{sizeof(FlutterSemanticsNode2), 0};
549  std::vector<int32_t> node0_children{1, 2};
550  node0.child_count = node0_children.size();
551  node0.children_in_traversal_order = node0_children.data();
552  node0.children_in_hit_test_order = node0_children.data();
553  auto empty_flags = FlutterSemanticsFlags{};
554  node0.flags2 = &empty_flags;
555 
556  FlutterSemanticsNode2 node1{sizeof(FlutterSemanticsNode2), 1};
557  node1.label = "prefecture";
558  node1.value = "Kyoto";
559  node1.flags2 = &empty_flags;
560  FlutterSemanticsNode2 node2{sizeof(FlutterSemanticsNode2), 2};
561  std::vector<int32_t> node2_children{3};
562  node2.child_count = node2_children.size();
563  node2.children_in_traversal_order = node2_children.data();
564  node2.children_in_hit_test_order = node2_children.data();
565  node2.flags2 = &empty_flags;
566  FlutterSemanticsNode2 node3{sizeof(FlutterSemanticsNode2), 3};
567  node3.label = "city";
568  node3.value = "Uji";
569  node3.flags2 = &empty_flags;
570 
571  bridge->AddFlutterSemanticsNodeUpdate(node0);
572  bridge->AddFlutterSemanticsNodeUpdate(node1);
573  bridge->AddFlutterSemanticsNodeUpdate(node2);
574  bridge->AddFlutterSemanticsNodeUpdate(node3);
575  bridge->CommitUpdates();
576 
577  // Look up the root windows node delegate.
578  auto node_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
579  ASSERT_TRUE(node_delegate);
580  EXPECT_EQ(node_delegate->GetChildCount(), 2);
581 
582  // Get the native IAccessible object.
583  IAccessible* node0_accessible = node_delegate->GetNativeViewAccessible();
584  ASSERT_TRUE(node0_accessible != nullptr);
585 
586  // Property lookups will be made against this node itself.
587  VARIANT varchild{};
588  varchild.vt = VT_I4;
589  varchild.lVal = CHILDID_SELF;
590 
591  // Verify node type is a group.
592  VARIANT varrole{};
593  varrole.vt = VT_I4;
594  ASSERT_EQ(node0_accessible->get_accRole(varchild, &varrole), S_OK);
595  EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_GROUPING);
596 
597  // Verify child count.
598  long node0_child_count = 0;
599  ASSERT_EQ(node0_accessible->get_accChildCount(&node0_child_count), S_OK);
600  EXPECT_EQ(node0_child_count, 2);
601 
602  {
603  // Look up first child of node0 (node1), a static text node.
604  varchild.lVal = 1;
605  IDispatch* node1_dispatch = nullptr;
606  ASSERT_EQ(node0_accessible->get_accChild(varchild, &node1_dispatch), S_OK);
607  ASSERT_TRUE(node1_dispatch != nullptr);
608  IAccessible* node1_accessible = nullptr;
609  ASSERT_EQ(node1_dispatch->QueryInterface(
610  IID_IAccessible, reinterpret_cast<void**>(&node1_accessible)),
611  S_OK);
612  ASSERT_TRUE(node1_accessible != nullptr);
613 
614  // Verify node name matches our label.
615  varchild.lVal = CHILDID_SELF;
616  BSTR bname = nullptr;
617  ASSERT_EQ(node1_accessible->get_accName(varchild, &bname), S_OK);
618  std::string name(_com_util::ConvertBSTRToString(bname));
619  EXPECT_EQ(name, "prefecture");
620 
621  // Verify node value matches.
622  BSTR bvalue = nullptr;
623  ASSERT_EQ(node1_accessible->get_accValue(varchild, &bvalue), S_OK);
624  std::string value(_com_util::ConvertBSTRToString(bvalue));
625  EXPECT_EQ(value, "Kyoto");
626 
627  // Verify node type is static text.
628  VARIANT varrole{};
629  varrole.vt = VT_I4;
630  ASSERT_EQ(node1_accessible->get_accRole(varchild, &varrole), S_OK);
631  EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_STATICTEXT);
632 
633  // Verify the parent node is the root.
634  IDispatch* parent_dispatch;
635  node1_accessible->get_accParent(&parent_dispatch);
636  IAccessible* parent_accessible;
637  ASSERT_EQ(
638  parent_dispatch->QueryInterface(
639  IID_IAccessible, reinterpret_cast<void**>(&parent_accessible)),
640  S_OK);
641  EXPECT_EQ(parent_accessible, node0_accessible);
642  }
643 
644  // Look up second child of node0 (node2), a parent group for node3.
645  varchild.lVal = 2;
646  IDispatch* node2_dispatch = nullptr;
647  ASSERT_EQ(node0_accessible->get_accChild(varchild, &node2_dispatch), S_OK);
648  ASSERT_TRUE(node2_dispatch != nullptr);
649  IAccessible* node2_accessible = nullptr;
650  ASSERT_EQ(node2_dispatch->QueryInterface(
651  IID_IAccessible, reinterpret_cast<void**>(&node2_accessible)),
652  S_OK);
653  ASSERT_TRUE(node2_accessible != nullptr);
654 
655  {
656  // Verify child count.
657  long node2_child_count = 0;
658  ASSERT_EQ(node2_accessible->get_accChildCount(&node2_child_count), S_OK);
659  EXPECT_EQ(node2_child_count, 1);
660 
661  // Verify node type is static text.
662  varchild.lVal = CHILDID_SELF;
663  VARIANT varrole{};
664  varrole.vt = VT_I4;
665  ASSERT_EQ(node2_accessible->get_accRole(varchild, &varrole), S_OK);
666  EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_GROUPING);
667 
668  // Verify the parent node is the root.
669  IDispatch* parent_dispatch;
670  node2_accessible->get_accParent(&parent_dispatch);
671  IAccessible* parent_accessible;
672  ASSERT_EQ(
673  parent_dispatch->QueryInterface(
674  IID_IAccessible, reinterpret_cast<void**>(&parent_accessible)),
675  S_OK);
676  EXPECT_EQ(parent_accessible, node0_accessible);
677  }
678 
679  {
680  // Look up only child of node2 (node3), a static text node.
681  varchild.lVal = 1;
682  IDispatch* node3_dispatch = nullptr;
683  ASSERT_EQ(node2_accessible->get_accChild(varchild, &node3_dispatch), S_OK);
684  ASSERT_TRUE(node3_dispatch != nullptr);
685  IAccessible* node3_accessible = nullptr;
686  ASSERT_EQ(node3_dispatch->QueryInterface(
687  IID_IAccessible, reinterpret_cast<void**>(&node3_accessible)),
688  S_OK);
689  ASSERT_TRUE(node3_accessible != nullptr);
690 
691  // Verify node name matches our label.
692  varchild.lVal = CHILDID_SELF;
693  BSTR bname = nullptr;
694  ASSERT_EQ(node3_accessible->get_accName(varchild, &bname), S_OK);
695  std::string name(_com_util::ConvertBSTRToString(bname));
696  EXPECT_EQ(name, "city");
697 
698  // Verify node value matches.
699  BSTR bvalue = nullptr;
700  ASSERT_EQ(node3_accessible->get_accValue(varchild, &bvalue), S_OK);
701  std::string value(_com_util::ConvertBSTRToString(bvalue));
702  EXPECT_EQ(value, "Uji");
703 
704  // Verify node type is static text.
705  VARIANT varrole{};
706  varrole.vt = VT_I4;
707  ASSERT_EQ(node3_accessible->get_accRole(varchild, &varrole), S_OK);
708  EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_STATICTEXT);
709 
710  // Verify the parent node is node2.
711  IDispatch* parent_dispatch;
712  node3_accessible->get_accParent(&parent_dispatch);
713  IAccessible* parent_accessible;
714  ASSERT_EQ(
715  parent_dispatch->QueryInterface(
716  IID_IAccessible, reinterpret_cast<void**>(&parent_accessible)),
717  S_OK);
718  EXPECT_EQ(parent_accessible, node2_accessible);
719  }
720 }
721 
722 // Flutter used to assume that the accessibility root had ID 0.
723 // In a multi-view world, each view has its own accessibility root
724 // with a globally unique node ID.
725 //
726 // node1
727 // |
728 // node2
729 //
730 // node1 is a grouping node, node0 is a static text node.
731 TEST(FlutterWindowsViewTest, NonZeroSemanticsRoot) {
732  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
733  EngineModifier modifier(engine.get());
734  modifier.embedder_api().UpdateSemanticsEnabled =
735  [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
736  return kSuccess;
737  };
738 
739  std::unique_ptr<FlutterWindowsView> view =
740  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
741  /*is_sized_to_content=*/false, BoxConstraints(),
742  /*allow_implicit_view=*/true);
743 
744  // Enable semantics to instantiate accessibility bridge.
745  view->OnUpdateSemanticsEnabled(true);
746 
747  auto bridge = view->accessibility_bridge().lock();
748  ASSERT_TRUE(bridge);
749 
750  // Add root node.
751  FlutterSemanticsNode2 node1{sizeof(FlutterSemanticsNode2), 1};
752  std::vector<int32_t> node1_children{2};
753  node1.child_count = node1_children.size();
754  node1.children_in_traversal_order = node1_children.data();
755  node1.children_in_hit_test_order = node1_children.data();
756  auto empty_flags = FlutterSemanticsFlags{};
757  node1.flags2 = &empty_flags;
758 
759  FlutterSemanticsNode2 node2{sizeof(FlutterSemanticsNode2), 2};
760  node2.label = "prefecture";
761  node2.value = "Kyoto";
762  node2.flags2 = &empty_flags;
763  bridge->AddFlutterSemanticsNodeUpdate(node1);
764  bridge->AddFlutterSemanticsNodeUpdate(node2);
765  bridge->CommitUpdates();
766 
767  // Look up the root windows node delegate.
768  auto root_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
769  ASSERT_TRUE(root_delegate);
770  EXPECT_EQ(root_delegate->GetChildCount(), 1);
771 
772  // Look up the child node delegate
773  auto child_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(2).lock();
774  ASSERT_TRUE(child_delegate);
775  EXPECT_EQ(child_delegate->GetChildCount(), 0);
776 
777  // Ensure a node with ID 0 does not exist.
778  auto fake_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
779  ASSERT_FALSE(fake_delegate);
780 
781  // Get the root's native IAccessible object.
782  IAccessible* node1_accessible = root_delegate->GetNativeViewAccessible();
783  ASSERT_TRUE(node1_accessible != nullptr);
784 
785  // Property lookups will be made against this node itself.
786  VARIANT varchild{};
787  varchild.vt = VT_I4;
788  varchild.lVal = CHILDID_SELF;
789 
790  // Verify node type is a group.
791  VARIANT varrole{};
792  varrole.vt = VT_I4;
793  ASSERT_EQ(node1_accessible->get_accRole(varchild, &varrole), S_OK);
794  EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_GROUPING);
795 
796  // Verify child count.
797  long node1_child_count = 0;
798  ASSERT_EQ(node1_accessible->get_accChildCount(&node1_child_count), S_OK);
799  EXPECT_EQ(node1_child_count, 1);
800 
801  {
802  // Look up first child of node1 (node0), a static text node.
803  varchild.lVal = 1;
804  IDispatch* node2_dispatch = nullptr;
805  ASSERT_EQ(node1_accessible->get_accChild(varchild, &node2_dispatch), S_OK);
806  ASSERT_TRUE(node2_dispatch != nullptr);
807  IAccessible* node2_accessible = nullptr;
808  ASSERT_EQ(node2_dispatch->QueryInterface(
809  IID_IAccessible, reinterpret_cast<void**>(&node2_accessible)),
810  S_OK);
811  ASSERT_TRUE(node2_accessible != nullptr);
812 
813  // Verify node name matches our label.
814  varchild.lVal = CHILDID_SELF;
815  BSTR bname = nullptr;
816  ASSERT_EQ(node2_accessible->get_accName(varchild, &bname), S_OK);
817  std::string name(_com_util::ConvertBSTRToString(bname));
818  EXPECT_EQ(name, "prefecture");
819 
820  // Verify node value matches.
821  BSTR bvalue = nullptr;
822  ASSERT_EQ(node2_accessible->get_accValue(varchild, &bvalue), S_OK);
823  std::string value(_com_util::ConvertBSTRToString(bvalue));
824  EXPECT_EQ(value, "Kyoto");
825 
826  // Verify node type is static text.
827  VARIANT varrole{};
828  varrole.vt = VT_I4;
829  ASSERT_EQ(node2_accessible->get_accRole(varchild, &varrole), S_OK);
830  EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_STATICTEXT);
831 
832  // Verify the parent node is the root.
833  IDispatch* parent_dispatch;
834  node2_accessible->get_accParent(&parent_dispatch);
835  IAccessible* parent_accessible;
836  ASSERT_EQ(
837  parent_dispatch->QueryInterface(
838  IID_IAccessible, reinterpret_cast<void**>(&parent_accessible)),
839  S_OK);
840  EXPECT_EQ(parent_accessible, node1_accessible);
841  }
842 }
843 
844 // Verify the native IAccessible accHitTest method returns the correct
845 // IAccessible COM object for the given coordinates.
846 //
847 // +-----------+
848 // | | |
849 // node0 | | B |
850 // / \ | A |-----|
851 // node1 node2 | | C |
852 // | | | |
853 // node3 +-----------+
854 //
855 // node0 and node2 are grouping nodes. node1 and node2 are static text nodes.
856 //
857 // node0 is located at 0,0 with size 500x500. It spans areas A, B, and C.
858 // node1 is located at 0,0 with size 250x500. It spans area A.
859 // node2 is located at 250,0 with size 250x500. It spans areas B and C.
860 // node3 is located at 250,250 with size 250x250. It spans area C.
861 TEST(FlutterWindowsViewTest, AccessibilityHitTesting) {
862  constexpr FlutterTransformation kIdentityTransform = {1, 0, 0, //
863  0, 1, 0, //
864  0, 0, 1};
865 
866  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
867  EngineModifier modifier(engine.get());
868  modifier.embedder_api().UpdateSemanticsEnabled =
869  [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
870  return kSuccess;
871  };
872 
873  std::unique_ptr<FlutterWindowsView> view =
874  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
875  /*is_sized_to_content=*/false, BoxConstraints(),
876  /*allow_implicit_view=*/true);
877 
878  // Enable semantics to instantiate accessibility bridge.
879  view->OnUpdateSemanticsEnabled(true);
880 
881  auto bridge = view->accessibility_bridge().lock();
882  ASSERT_TRUE(bridge);
883 
884  // Add root node at origin. Size 500x500.
885  FlutterSemanticsNode2 node0{sizeof(FlutterSemanticsNode2), 0};
886  auto empty_flags = FlutterSemanticsFlags{};
887  std::vector<int32_t> node0_children{1, 2};
888  node0.rect = {0, 0, 500, 500};
889  node0.transform = kIdentityTransform;
890  node0.child_count = node0_children.size();
891  node0.children_in_traversal_order = node0_children.data();
892  node0.children_in_hit_test_order = node0_children.data();
893  node0.flags2 = &empty_flags;
894 
895  // Add node 1 located at 0,0 relative to node 0. Size 250x500.
896  FlutterSemanticsNode2 node1{sizeof(FlutterSemanticsNode2), 1};
897  node1.rect = {0, 0, 250, 500};
898  node1.transform = kIdentityTransform;
899  node1.label = "prefecture";
900  node1.value = "Kyoto";
901  node1.flags2 = &empty_flags;
902 
903  // Add node 2 located at 250,0 relative to node 0. Size 250x500.
904  FlutterSemanticsNode2 node2{sizeof(FlutterSemanticsNode2), 2};
905  std::vector<int32_t> node2_children{3};
906  node2.rect = {0, 0, 250, 500};
907  node2.transform = {1, 0, 250, 0, 1, 0, 0, 0, 1};
908  node2.child_count = node2_children.size();
909  node2.children_in_traversal_order = node2_children.data();
910  node2.children_in_hit_test_order = node2_children.data();
911  node2.flags2 = &empty_flags;
912 
913  // Add node 3 located at 0,250 relative to node 2. Size 250, 250.
914  FlutterSemanticsNode2 node3{sizeof(FlutterSemanticsNode2), 3};
915  node3.rect = {0, 0, 250, 250};
916  node3.transform = {1, 0, 0, 0, 1, 250, 0, 0, 1};
917  node3.label = "city";
918  node3.value = "Uji";
919  node3.flags2 = &empty_flags;
920 
921  bridge->AddFlutterSemanticsNodeUpdate(node0);
922  bridge->AddFlutterSemanticsNodeUpdate(node1);
923  bridge->AddFlutterSemanticsNodeUpdate(node2);
924  bridge->AddFlutterSemanticsNodeUpdate(node3);
925  bridge->CommitUpdates();
926 
927  // Look up the root windows node delegate.
928  auto node0_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
929  ASSERT_TRUE(node0_delegate);
930  auto node1_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
931  ASSERT_TRUE(node1_delegate);
932  auto node2_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(2).lock();
933  ASSERT_TRUE(node2_delegate);
934  auto node3_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(3).lock();
935  ASSERT_TRUE(node3_delegate);
936 
937  // Get the native IAccessible root object.
938  IAccessible* node0_accessible = node0_delegate->GetNativeViewAccessible();
939  ASSERT_TRUE(node0_accessible != nullptr);
940 
941  // Perform a hit test that should hit node 1.
942  VARIANT varchild{};
943  ASSERT_TRUE(SUCCEEDED(node0_accessible->accHitTest(150, 150, &varchild)));
944  EXPECT_EQ(varchild.vt, VT_DISPATCH);
945  EXPECT_EQ(varchild.pdispVal, node1_delegate->GetNativeViewAccessible());
946 
947  // Perform a hit test that should hit node 2.
948  varchild = {};
949  ASSERT_TRUE(SUCCEEDED(node0_accessible->accHitTest(450, 150, &varchild)));
950  EXPECT_EQ(varchild.vt, VT_DISPATCH);
951  EXPECT_EQ(varchild.pdispVal, node2_delegate->GetNativeViewAccessible());
952 
953  // Perform a hit test that should hit node 3.
954  varchild = {};
955  ASSERT_TRUE(SUCCEEDED(node0_accessible->accHitTest(450, 450, &varchild)));
956  EXPECT_EQ(varchild.vt, VT_DISPATCH);
957  EXPECT_EQ(varchild.pdispVal, node3_delegate->GetNativeViewAccessible());
958 }
959 
960 TEST(FlutterWindowsViewTest, WindowResizeTests) {
961  auto windows_proc_table = std::make_shared<NiceMock<MockWindowsProcTable>>();
962  std::unique_ptr<FlutterWindowsEngine> engine =
963  GetTestEngine(windows_proc_table);
964 
965  EngineModifier engine_modifier{engine.get()};
966  engine_modifier.embedder_api().PostRenderThreadTask = MOCK_ENGINE_PROC(
967  PostRenderThreadTask,
968  ([](auto engine, VoidCallback callback, void* user_data) {
970  return kSuccess;
971  }));
972 
973  auto egl_manager = std::make_unique<egl::MockManager>();
974  auto surface = std::make_unique<egl::MockWindowSurface>();
975  auto resized_surface = std::make_unique<egl::MockWindowSurface>();
976  egl::MockContext render_context;
977 
978  auto surface_ptr = surface.get();
979  auto resized_surface_ptr = resized_surface.get();
980 
981  // Mock render surface creation
982  EXPECT_CALL(*egl_manager, CreateWindowSurface)
983  .WillOnce(Return(std::move(surface)));
984  EXPECT_CALL(*surface_ptr, IsValid).WillRepeatedly(Return(true));
985  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
986  EXPECT_CALL(*surface_ptr, SetVSyncEnabled).WillOnce(Return(true));
987  EXPECT_CALL(*egl_manager, render_context).WillOnce(Return(&render_context));
988  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
989 
990  // Mock render surface resize
991  EXPECT_CALL(*surface_ptr, Destroy).WillOnce(Return(true));
992  EXPECT_CALL(*egl_manager.get(),
993  CreateWindowSurface(_, /*width=*/500, /*height=*/500))
994  .WillOnce(Return(std::move((resized_surface))));
995  EXPECT_CALL(*resized_surface_ptr, MakeCurrent).WillOnce(Return(true));
996  EXPECT_CALL(*resized_surface_ptr, SetVSyncEnabled).WillOnce(Return(true));
997  EXPECT_CALL(*windows_proc_table.get(), DwmFlush).WillOnce(Return(S_OK));
998 
999  EXPECT_CALL(*resized_surface_ptr, Destroy).WillOnce(Return(true));
1000 
1001  engine_modifier.SetEGLManager(std::move(egl_manager));
1002 
1003  std::unique_ptr<FlutterWindowsView> view =
1004  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1005  /*is_sized_to_content=*/false, BoxConstraints(),
1006  /*allow_implicit_view=*/true);
1007 
1008  fml::AutoResetWaitableEvent metrics_sent_latch;
1009  engine_modifier.embedder_api().SendWindowMetricsEvent = MOCK_ENGINE_PROC(
1010  SendWindowMetricsEvent,
1011  ([&metrics_sent_latch](auto engine,
1012  const FlutterWindowMetricsEvent* event) {
1013  metrics_sent_latch.Signal();
1014  return kSuccess;
1015  }));
1016 
1017  // Simulate raster thread.
1018  std::thread frame_thread([&metrics_sent_latch, &view]() {
1019  metrics_sent_latch.Wait();
1020  // Frame generated and presented from the raster thread.
1021  EXPECT_TRUE(view->OnFrameGenerated(500, 500));
1022  view->OnFramePresented();
1023  });
1024 
1025  // Start the window resize. This sends the new window metrics
1026  // and then blocks polling run loop until another thread completes the window
1027  // resize.
1028  EXPECT_TRUE(view->OnWindowSizeChanged(500, 500));
1029  frame_thread.join();
1030 }
1031 
1032 // Verify that an empty frame completes a view resize.
1033 TEST(FlutterWindowsViewTest, TestEmptyFrameResizes) {
1034  auto windows_proc_table = std::make_shared<NiceMock<MockWindowsProcTable>>();
1035  std::unique_ptr<FlutterWindowsEngine> engine =
1036  GetTestEngine(windows_proc_table);
1037 
1038  EngineModifier engine_modifier{engine.get()};
1039  engine_modifier.embedder_api().PostRenderThreadTask = MOCK_ENGINE_PROC(
1040  PostRenderThreadTask,
1041  ([](auto engine, VoidCallback callback, void* user_data) {
1043  return kSuccess;
1044  }));
1045 
1046  auto egl_manager = std::make_unique<egl::MockManager>();
1047  auto surface = std::make_unique<egl::MockWindowSurface>();
1048  auto resized_surface = std::make_unique<egl::MockWindowSurface>();
1049  auto resized_surface_ptr = resized_surface.get();
1050 
1051  EXPECT_CALL(*surface.get(), IsValid).WillRepeatedly(Return(true));
1052  EXPECT_CALL(*surface.get(), Destroy).WillOnce(Return(true));
1053 
1054  EXPECT_CALL(*egl_manager.get(),
1055  CreateWindowSurface(_, /*width=*/500, /*height=*/300))
1056  .WillOnce(Return(std::move((resized_surface))));
1057  EXPECT_CALL(*resized_surface_ptr, MakeCurrent).WillOnce(Return(true));
1058  EXPECT_CALL(*resized_surface_ptr, SetVSyncEnabled).WillOnce(Return(true));
1059  EXPECT_CALL(*windows_proc_table.get(), DwmFlush).WillOnce(Return(S_OK));
1060 
1061  EXPECT_CALL(*resized_surface_ptr, Destroy).WillOnce(Return(true));
1062 
1063  fml::AutoResetWaitableEvent metrics_sent_latch;
1064  engine_modifier.embedder_api().SendWindowMetricsEvent = MOCK_ENGINE_PROC(
1065  SendWindowMetricsEvent,
1066  ([&metrics_sent_latch](auto engine,
1067  const FlutterWindowMetricsEvent* event) {
1068  metrics_sent_latch.Signal();
1069  return kSuccess;
1070  }));
1071 
1072  std::unique_ptr<FlutterWindowsView> view =
1073  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1074  /*is_sized_to_content=*/false, BoxConstraints(),
1075  /*allow_implicit_view=*/true);
1076 
1077  ViewModifier view_modifier{view.get()};
1078  engine_modifier.SetEGLManager(std::move(egl_manager));
1079  view_modifier.SetSurface(std::move(surface));
1080 
1081  // Simulate raster thread.
1082  std::thread frame_thread([&metrics_sent_latch, &view]() {
1083  metrics_sent_latch.Wait();
1084 
1085  // Empty frame generated and presented from the raster thread.
1086  EXPECT_TRUE(view->OnEmptyFrameGenerated());
1087  view->OnFramePresented();
1088  });
1089 
1090  // Start the window resize. This sends the new window metrics
1091  // and then blocks until another thread completes the window resize.
1092  EXPECT_TRUE(view->OnWindowSizeChanged(500, 300));
1093  frame_thread.join();
1094 }
1095 
1096 // A window resize can be interleaved between a frame generation and
1097 // presentation. This should not crash the app. Regression test for:
1098 // https://github.com/flutter/flutter/issues/141855
1099 TEST(FlutterWindowsViewTest, WindowResizeRace) {
1100  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1101 
1102  EngineModifier engine_modifier(engine.get());
1103  engine_modifier.embedder_api().PostRenderThreadTask = MOCK_ENGINE_PROC(
1104  PostRenderThreadTask,
1105  ([](auto engine, VoidCallback callback, void* user_data) {
1107  return kSuccess;
1108  }));
1109 
1110  auto egl_manager = std::make_unique<egl::MockManager>();
1111  auto surface = std::make_unique<egl::MockWindowSurface>();
1112 
1113  EXPECT_CALL(*surface.get(), IsValid).WillRepeatedly(Return(true));
1114  EXPECT_CALL(*surface.get(), Destroy).WillOnce(Return(true));
1115 
1116  std::unique_ptr<FlutterWindowsView> view =
1117  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1118  /*is_sized_to_content=*/false, BoxConstraints(),
1119  /*allow_implicit_view=*/true);
1120 
1121  ViewModifier view_modifier{view.get()};
1122  engine_modifier.SetEGLManager(std::move(egl_manager));
1123  view_modifier.SetSurface(std::move(surface));
1124 
1125  // Begin a frame.
1126  ASSERT_TRUE(view->OnFrameGenerated(100, 100));
1127 
1128  // Inject a window resize between the frame generation and
1129  // frame presentation. The new size invalidates the current frame.
1130  EXPECT_FALSE(view->OnWindowSizeChanged(500, 500));
1131 
1132  // Complete the invalidated frame while a resize is pending. Although this
1133  // might mean that we presented a frame with the wrong size, this should not
1134  // crash the app.
1135  view->OnFramePresented();
1136 }
1137 
1138 // Window resize should succeed even if the render surface could not be created
1139 // even though EGL initialized successfully.
1140 TEST(FlutterWindowsViewTest, WindowResizeInvalidSurface) {
1141  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1142 
1143  EngineModifier engine_modifier(engine.get());
1144  engine_modifier.embedder_api().PostRenderThreadTask = MOCK_ENGINE_PROC(
1145  PostRenderThreadTask,
1146  ([](auto engine, VoidCallback callback, void* user_data) {
1148  return kSuccess;
1149  }));
1150 
1151  auto egl_manager = std::make_unique<egl::MockManager>();
1152  auto surface = std::make_unique<egl::MockWindowSurface>();
1153 
1154  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface).Times(0);
1155  EXPECT_CALL(*surface.get(), IsValid).WillRepeatedly(Return(false));
1156  EXPECT_CALL(*surface.get(), Destroy).WillOnce(Return(false));
1157 
1158  std::unique_ptr<FlutterWindowsView> view =
1159  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1160  /*is_sized_to_content=*/false, BoxConstraints(),
1161  /*allow_implicit_view=*/true);
1162 
1163  ViewModifier view_modifier{view.get()};
1164  engine_modifier.SetEGLManager(std::move(egl_manager));
1165  view_modifier.SetSurface(std::move(surface));
1166 
1167  auto metrics_sent = false;
1168  engine_modifier.embedder_api().SendWindowMetricsEvent = MOCK_ENGINE_PROC(
1169  SendWindowMetricsEvent,
1170  ([&metrics_sent](auto engine, const FlutterWindowMetricsEvent* event) {
1171  metrics_sent = true;
1172  return kSuccess;
1173  }));
1174 
1175  view->OnWindowSizeChanged(500, 500);
1176 }
1177 
1178 // Window resize should succeed even if EGL initialized successfully
1179 // but the EGL surface could not be created.
1180 TEST(FlutterWindowsViewTest, WindowResizeWithoutSurface) {
1181  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1182  EngineModifier modifier(engine.get());
1183 
1184  auto egl_manager = std::make_unique<egl::MockManager>();
1185 
1186  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface).Times(0);
1187 
1188  std::unique_ptr<FlutterWindowsView> view =
1189  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1190  /*is_sized_to_content=*/false, BoxConstraints(),
1191  /*allow_implicit_view=*/true);
1192 
1193  modifier.SetEGLManager(std::move(egl_manager));
1194 
1195  auto metrics_sent = false;
1196  modifier.embedder_api().SendWindowMetricsEvent = MOCK_ENGINE_PROC(
1197  SendWindowMetricsEvent,
1198  ([&metrics_sent](auto engine, const FlutterWindowMetricsEvent* event) {
1199  metrics_sent = true;
1200  return kSuccess;
1201  }));
1202 
1203  view->OnWindowSizeChanged(500, 500);
1204 }
1205 
1206 TEST(FlutterWindowsViewTest, WindowRepaintTests) {
1207  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1208  EngineModifier modifier(engine.get());
1209 
1210  FlutterWindowsView view{kImplicitViewId, engine.get(),
1211  std::make_unique<flutter::FlutterWindow>(
1212  100, 100, engine->display_manager()),
1213  /*is_sized_to_content=*/false, BoxConstraints()};
1214 
1215  bool schedule_frame_called = false;
1216  modifier.embedder_api().ScheduleFrame =
1217  MOCK_ENGINE_PROC(ScheduleFrame, ([&schedule_frame_called](auto engine) {
1218  schedule_frame_called = true;
1219  return kSuccess;
1220  }));
1221 
1222  view.OnWindowRepaint();
1223  EXPECT_TRUE(schedule_frame_called);
1224 }
1225 
1226 // Ensure that checkboxes have their checked status set apropriately
1227 // Previously, only Radios could have this flag updated
1228 // Resulted in the issue seen at
1229 // https://github.com/flutter/flutter/issues/96218
1230 // This test ensures that the native state of Checkboxes on Windows,
1231 // specifically, is updated as desired.
1232 TEST(FlutterWindowsViewTest, CheckboxNativeState) {
1233  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1234  EngineModifier modifier(engine.get());
1235  modifier.embedder_api().UpdateSemanticsEnabled =
1236  [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
1237  return kSuccess;
1238  };
1239 
1240  std::unique_ptr<FlutterWindowsView> view =
1241  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1242  /*is_sized_to_content=*/false, BoxConstraints(),
1243  /*allow_implicit_view=*/true);
1244 
1245  // Enable semantics to instantiate accessibility bridge.
1246  view->OnUpdateSemanticsEnabled(true);
1247 
1248  auto bridge = view->accessibility_bridge().lock();
1249  ASSERT_TRUE(bridge);
1250 
1251  FlutterSemanticsNode2 root{sizeof(FlutterSemanticsNode2), 0};
1252  root.id = 0;
1253  root.label = "root";
1254  root.hint = "";
1255  root.value = "";
1256  root.increased_value = "";
1257  root.decreased_value = "";
1258  root.child_count = 0;
1259  root.custom_accessibility_actions_count = 0;
1260  auto flags = FlutterSemanticsFlags{
1261  .is_checked = FlutterCheckState::kFlutterCheckStateTrue,
1262  };
1263  root.flags2 = &flags;
1264  bridge->AddFlutterSemanticsNodeUpdate(root);
1265 
1266  bridge->CommitUpdates();
1267 
1268  {
1269  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
1270  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kCheckBox);
1271  EXPECT_EQ(root_node->GetData().GetCheckedState(),
1272  ax::mojom::CheckedState::kTrue);
1273 
1274  // Get the IAccessible for the root node.
1275  IAccessible* native_view = root_node->GetNativeViewAccessible();
1276  ASSERT_TRUE(native_view != nullptr);
1277 
1278  // Look up against the node itself (not one of its children).
1279  VARIANT varchild = {};
1280  varchild.vt = VT_I4;
1281 
1282  // Verify the checkbox is checked.
1283  varchild.lVal = CHILDID_SELF;
1284  VARIANT native_state = {};
1285  ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
1286  EXPECT_TRUE(native_state.lVal & STATE_SYSTEM_CHECKED);
1287 
1288  // Perform similar tests for UIA value;
1289  IRawElementProviderSimple* uia_node;
1290  native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
1291  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
1292  UIA_ToggleToggleStatePropertyId, &native_state)));
1293  EXPECT_EQ(native_state.lVal, ToggleState_On);
1294 
1295  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
1296  UIA_AriaPropertiesPropertyId, &native_state)));
1297  EXPECT_NE(std::wcsstr(native_state.bstrVal, L"checked=true"), nullptr);
1298  }
1299 
1300  // Test unchecked too.
1301  auto updated_flags = FlutterSemanticsFlags{
1302  .is_checked = FlutterCheckState::kFlutterCheckStateFalse,
1303  };
1304  root.flags2 = &updated_flags;
1305  bridge->AddFlutterSemanticsNodeUpdate(root);
1306  bridge->CommitUpdates();
1307 
1308  {
1309  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
1310  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kCheckBox);
1311  EXPECT_EQ(root_node->GetData().GetCheckedState(),
1312  ax::mojom::CheckedState::kFalse);
1313 
1314  // Get the IAccessible for the root node.
1315  IAccessible* native_view = root_node->GetNativeViewAccessible();
1316  ASSERT_TRUE(native_view != nullptr);
1317 
1318  // Look up against the node itself (not one of its children).
1319  VARIANT varchild = {};
1320  varchild.vt = VT_I4;
1321 
1322  // Verify the checkbox is unchecked.
1323  varchild.lVal = CHILDID_SELF;
1324  VARIANT native_state = {};
1325  ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
1326  EXPECT_FALSE(native_state.lVal & STATE_SYSTEM_CHECKED);
1327 
1328  // Perform similar tests for UIA value;
1329  IRawElementProviderSimple* uia_node;
1330  native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
1331  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
1332  UIA_ToggleToggleStatePropertyId, &native_state)));
1333  EXPECT_EQ(native_state.lVal, ToggleState_Off);
1334 
1335  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
1336  UIA_AriaPropertiesPropertyId, &native_state)));
1337  EXPECT_NE(std::wcsstr(native_state.bstrVal, L"checked=false"), nullptr);
1338  }
1339 
1340  // Now check mixed state.
1341  auto updated_mixe_flags = FlutterSemanticsFlags{
1342  .is_checked = FlutterCheckState::kFlutterCheckStateMixed,
1343  };
1344  root.flags2 = &updated_mixe_flags;
1345  bridge->AddFlutterSemanticsNodeUpdate(root);
1346  bridge->CommitUpdates();
1347 
1348  {
1349  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
1350  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kCheckBox);
1351  EXPECT_EQ(root_node->GetData().GetCheckedState(),
1352  ax::mojom::CheckedState::kMixed);
1353 
1354  // Get the IAccessible for the root node.
1355  IAccessible* native_view = root_node->GetNativeViewAccessible();
1356  ASSERT_TRUE(native_view != nullptr);
1357 
1358  // Look up against the node itself (not one of its children).
1359  VARIANT varchild = {};
1360  varchild.vt = VT_I4;
1361 
1362  // Verify the checkbox is mixed.
1363  varchild.lVal = CHILDID_SELF;
1364  VARIANT native_state = {};
1365  ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
1366  EXPECT_TRUE(native_state.lVal & STATE_SYSTEM_MIXED);
1367 
1368  // Perform similar tests for UIA value;
1369  IRawElementProviderSimple* uia_node;
1370  native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
1371  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
1372  UIA_ToggleToggleStatePropertyId, &native_state)));
1373  EXPECT_EQ(native_state.lVal, ToggleState_Indeterminate);
1374 
1375  ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
1376  UIA_AriaPropertiesPropertyId, &native_state)));
1377  EXPECT_NE(std::wcsstr(native_state.bstrVal, L"checked=mixed"), nullptr);
1378  }
1379 }
1380 
1381 // Ensure that switches have their toggle status set apropriately
1382 TEST(FlutterWindowsViewTest, SwitchNativeState) {
1383  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1384  EngineModifier modifier(engine.get());
1385  modifier.embedder_api().UpdateSemanticsEnabled =
1386  [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
1387  return kSuccess;
1388  };
1389 
1390  std::unique_ptr<FlutterWindowsView> view =
1391  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1392  /*is_sized_to_content=*/false, BoxConstraints(),
1393  /*allow_implicit_view=*/true);
1394 
1395  // Enable semantics to instantiate accessibility bridge.
1396  view->OnUpdateSemanticsEnabled(true);
1397 
1398  auto bridge = view->accessibility_bridge().lock();
1399  ASSERT_TRUE(bridge);
1400 
1401  FlutterSemanticsNode2 root{sizeof(FlutterSemanticsNode2), 0};
1402  root.id = 0;
1403  root.label = "root";
1404  root.hint = "";
1405  root.value = "";
1406  root.increased_value = "";
1407  root.decreased_value = "";
1408  root.child_count = 0;
1409  root.custom_accessibility_actions_count = 0;
1410 
1411  auto flags = FlutterSemanticsFlags{
1412  .is_toggled = FlutterTristate::kFlutterTristateTrue,
1413  };
1414  root.flags2 = &flags;
1415  bridge->AddFlutterSemanticsNodeUpdate(root);
1416 
1417  bridge->CommitUpdates();
1418 
1419  {
1420  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
1421  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kSwitch);
1422  EXPECT_EQ(root_node->GetData().GetCheckedState(),
1423  ax::mojom::CheckedState::kTrue);
1424 
1425  // Get the IAccessible for the root node.
1426  IAccessible* native_view = root_node->GetNativeViewAccessible();
1427  ASSERT_TRUE(native_view != nullptr);
1428 
1429  // Look up against the node itself (not one of its children).
1430  VARIANT varchild = {};
1431  varchild.vt = VT_I4;
1432 
1433  varchild.lVal = CHILDID_SELF;
1434  VARIANT varrole = {};
1435 
1436  // Verify the role of the switch is CHECKBUTTON
1437  ASSERT_EQ(native_view->get_accRole(varchild, &varrole), S_OK);
1438  ASSERT_EQ(varrole.lVal, ROLE_SYSTEM_CHECKBUTTON);
1439 
1440  // Verify the switch is pressed.
1441  VARIANT native_state = {};
1442  ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
1443  EXPECT_TRUE(native_state.lVal & STATE_SYSTEM_PRESSED);
1444  EXPECT_TRUE(native_state.lVal & STATE_SYSTEM_CHECKED);
1445 
1446  // Test similarly on UIA node.
1447  IRawElementProviderSimple* uia_node;
1448  native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
1449  ASSERT_EQ(uia_node->GetPropertyValue(UIA_ControlTypePropertyId, &varrole),
1450  S_OK);
1451  EXPECT_EQ(varrole.lVal, UIA_ButtonControlTypeId);
1452  ASSERT_EQ(uia_node->GetPropertyValue(UIA_ToggleToggleStatePropertyId,
1453  &native_state),
1454  S_OK);
1455  EXPECT_EQ(native_state.lVal, ToggleState_On);
1456  ASSERT_EQ(
1457  uia_node->GetPropertyValue(UIA_AriaPropertiesPropertyId, &native_state),
1458  S_OK);
1459  EXPECT_NE(std::wcsstr(native_state.bstrVal, L"pressed=true"), nullptr);
1460  }
1461 
1462  // Test unpressed too.
1463  auto updated_flags = FlutterSemanticsFlags{
1464  .is_toggled = FlutterTristate::kFlutterTristateFalse,
1465  };
1466  root.flags2 = &updated_flags;
1467 
1468  bridge->AddFlutterSemanticsNodeUpdate(root);
1469  bridge->CommitUpdates();
1470 
1471  {
1472  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
1473  EXPECT_EQ(root_node->GetData().role, ax::mojom::Role::kSwitch);
1474  EXPECT_EQ(root_node->GetData().GetCheckedState(),
1475  ax::mojom::CheckedState::kFalse);
1476 
1477  // Get the IAccessible for the root node.
1478  IAccessible* native_view = root_node->GetNativeViewAccessible();
1479  ASSERT_TRUE(native_view != nullptr);
1480 
1481  // Look up against the node itself (not one of its children).
1482  VARIANT varchild = {};
1483  varchild.vt = VT_I4;
1484 
1485  // Verify the switch is not pressed.
1486  varchild.lVal = CHILDID_SELF;
1487  VARIANT native_state = {};
1488  ASSERT_TRUE(SUCCEEDED(native_view->get_accState(varchild, &native_state)));
1489  EXPECT_FALSE(native_state.lVal & STATE_SYSTEM_PRESSED);
1490  EXPECT_FALSE(native_state.lVal & STATE_SYSTEM_CHECKED);
1491 
1492  // Test similarly on UIA node.
1493  IRawElementProviderSimple* uia_node;
1494  native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
1495  ASSERT_EQ(uia_node->GetPropertyValue(UIA_ToggleToggleStatePropertyId,
1496  &native_state),
1497  S_OK);
1498  EXPECT_EQ(native_state.lVal, ToggleState_Off);
1499  ASSERT_EQ(
1500  uia_node->GetPropertyValue(UIA_AriaPropertiesPropertyId, &native_state),
1501  S_OK);
1502  EXPECT_NE(std::wcsstr(native_state.bstrVal, L"pressed=false"), nullptr);
1503  }
1504 }
1505 
1506 TEST(FlutterWindowsViewTest, TooltipNodeData) {
1507  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1508  EngineModifier modifier(engine.get());
1509  modifier.embedder_api().UpdateSemanticsEnabled =
1510  [](FLUTTER_API_SYMBOL(FlutterEngine) engine, bool enabled) {
1511  return kSuccess;
1512  };
1513 
1514  std::unique_ptr<FlutterWindowsView> view =
1515  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1516  /*is_sized_to_content=*/false, BoxConstraints(),
1517  /*allow_implicit_view=*/true);
1518 
1519  // Enable semantics to instantiate accessibility bridge.
1520  view->OnUpdateSemanticsEnabled(true);
1521 
1522  auto bridge = view->accessibility_bridge().lock();
1523  ASSERT_TRUE(bridge);
1524 
1525  FlutterSemanticsNode2 root{sizeof(FlutterSemanticsNode2), 0};
1526  root.id = 0;
1527  root.label = "root";
1528  root.hint = "";
1529  root.value = "";
1530  root.increased_value = "";
1531  root.decreased_value = "";
1532  root.tooltip = "tooltip";
1533  root.child_count = 0;
1534  root.custom_accessibility_actions_count = 0;
1535  auto flags = FlutterSemanticsFlags{
1536  .is_text_field = true,
1537  };
1538  root.flags2 = &flags;
1539  bridge->AddFlutterSemanticsNodeUpdate(root);
1540 
1541  bridge->CommitUpdates();
1542  auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
1543  std::string tooltip = root_node->GetData().GetStringAttribute(
1544  ax::mojom::StringAttribute::kTooltip);
1545  EXPECT_EQ(tooltip, "tooltip");
1546 
1547  // Check that MSAA name contains the tooltip.
1548  IAccessible* native_view = bridge->GetFlutterPlatformNodeDelegateFromID(0)
1549  .lock()
1550  ->GetNativeViewAccessible();
1551  VARIANT varchild = {.vt = VT_I4, .lVal = CHILDID_SELF};
1552  BSTR bname;
1553  ASSERT_EQ(native_view->get_accName(varchild, &bname), S_OK);
1554  EXPECT_NE(std::wcsstr(bname, L"tooltip"), nullptr);
1555 
1556  // Check that UIA help text is equal to the tooltip.
1557  IRawElementProviderSimple* uia_node;
1558  native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
1559  VARIANT varname{};
1560  ASSERT_EQ(uia_node->GetPropertyValue(UIA_HelpTextPropertyId, &varname), S_OK);
1561  std::string uia_tooltip = _com_util::ConvertBSTRToString(varname.bstrVal);
1562  EXPECT_EQ(uia_tooltip, "tooltip");
1563 }
1564 
1565 // Don't block until the v-blank if it is disabled by the window.
1566 // The surface is updated on the platform thread at startup.
1567 TEST(FlutterWindowsViewTest, DisablesVSyncAtStartup) {
1568  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
1569  auto engine = std::make_unique<MockFlutterWindowsEngine>(windows_proc_table);
1570  auto egl_manager = std::make_unique<egl::MockManager>();
1571  egl::MockContext render_context;
1572  auto surface = std::make_unique<egl::MockWindowSurface>();
1573  auto surface_ptr = surface.get();
1574 
1575  EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(false));
1576  EXPECT_CALL(*engine.get(), PostRasterThreadTask).Times(0);
1577 
1578  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1579  .WillOnce(Return(true));
1580 
1581  EXPECT_CALL(*egl_manager.get(), render_context)
1582  .WillOnce(Return(&render_context));
1583  EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(true));
1584 
1585  InSequence s;
1586  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface)
1587  .WillOnce(Return(std::move(surface)));
1588  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
1589  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(false)).WillOnce(Return(true));
1590  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
1591 
1592  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
1593 
1594  EngineModifier modifier{engine.get()};
1595  modifier.SetEGLManager(std::move(egl_manager));
1596 
1597  std::unique_ptr<FlutterWindowsView> view =
1598  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1599  /*is_sized_to_content=*/false, BoxConstraints(),
1600  /*allow_implicit_view=*/true);
1601 }
1602 
1603 // Blocks until the v-blank if it is enabled by the window.
1604 // The surface is updated on the platform thread at startup.
1605 TEST(FlutterWindowsViewTest, EnablesVSyncAtStartup) {
1606  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
1607  auto engine = std::make_unique<MockFlutterWindowsEngine>(windows_proc_table);
1608  auto egl_manager = std::make_unique<egl::MockManager>();
1609  egl::MockContext render_context;
1610  auto surface = std::make_unique<egl::MockWindowSurface>();
1611  auto surface_ptr = surface.get();
1612 
1613  EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(false));
1614  EXPECT_CALL(*engine.get(), PostRasterThreadTask).Times(0);
1615  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1616  .WillOnce(Return(false));
1617 
1618  EXPECT_CALL(*egl_manager.get(), render_context)
1619  .WillOnce(Return(&render_context));
1620  EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(true));
1621 
1622  InSequence s;
1623  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface)
1624  .WillOnce(Return(std::move(surface)));
1625  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
1626  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(true)).WillOnce(Return(true));
1627  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
1628 
1629  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
1630 
1631  EngineModifier modifier{engine.get()};
1632  modifier.SetEGLManager(std::move(egl_manager));
1633 
1634  std::unique_ptr<FlutterWindowsView> view =
1635  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1636  /*is_sized_to_content=*/false, BoxConstraints(),
1637  /*allow_implicit_view=*/true);
1638 }
1639 
1640 // Don't block until the v-blank if it is disabled by the window.
1641 // The surface is updated on the raster thread if the engine is running.
1642 TEST(FlutterWindowsViewTest, DisablesVSyncAfterStartup) {
1643  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
1644  auto engine = std::make_unique<MockFlutterWindowsEngine>(windows_proc_table);
1645  auto egl_manager = std::make_unique<egl::MockManager>();
1646  egl::MockContext render_context;
1647  auto surface = std::make_unique<egl::MockWindowSurface>();
1648  auto surface_ptr = surface.get();
1649 
1650  EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(true));
1651  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1652  .WillOnce(Return(true));
1653 
1654  EXPECT_CALL(*egl_manager.get(), render_context)
1655  .WillOnce(Return(&render_context));
1656  EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(true));
1657 
1658  InSequence s;
1659  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface)
1660  .WillOnce(Return(std::move(surface)));
1661  EXPECT_CALL(*engine.get(), PostRasterThreadTask)
1662  .WillOnce([](fml::closure callback) {
1663  callback();
1664  return true;
1665  });
1666  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
1667  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(false)).WillOnce(Return(true));
1668  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
1669  EXPECT_CALL(*engine.get(), PostRasterThreadTask)
1670  .WillOnce([](fml::closure callback) {
1671  callback();
1672  return true;
1673  });
1674  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
1675 
1676  EngineModifier modifier{engine.get()};
1677  modifier.SetEGLManager(std::move(egl_manager));
1678 
1679  std::unique_ptr<FlutterWindowsView> view =
1680  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1681  /*is_sized_to_content=*/false, BoxConstraints(),
1682  /*allow_implicit_view=*/true);
1683 }
1684 
1685 // Blocks until the v-blank if it is enabled by the window.
1686 // The surface is updated on the raster thread if the engine is running.
1687 TEST(FlutterWindowsViewTest, EnablesVSyncAfterStartup) {
1688  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
1689  auto engine = std::make_unique<MockFlutterWindowsEngine>(windows_proc_table);
1690  auto egl_manager = std::make_unique<egl::MockManager>();
1691  egl::MockContext render_context;
1692  auto surface = std::make_unique<egl::MockWindowSurface>();
1693  auto surface_ptr = surface.get();
1694 
1695  EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(true));
1696 
1697  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1698  .WillOnce(Return(false));
1699 
1700  EXPECT_CALL(*egl_manager.get(), render_context)
1701  .WillOnce(Return(&render_context));
1702  EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(true));
1703 
1704  InSequence s;
1705  EXPECT_CALL(*egl_manager.get(), CreateWindowSurface)
1706  .WillOnce(Return(std::move(surface)));
1707  EXPECT_CALL(*engine.get(), PostRasterThreadTask)
1708  .WillOnce([](fml::closure callback) {
1709  callback();
1710  return true;
1711  });
1712 
1713  EXPECT_CALL(*surface_ptr, MakeCurrent).WillOnce(Return(true));
1714  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(true)).WillOnce(Return(true));
1715  EXPECT_CALL(render_context, ClearCurrent).WillOnce(Return(true));
1716 
1717  EXPECT_CALL(*engine.get(), PostRasterThreadTask)
1718  .WillOnce([](fml::closure callback) {
1719  callback();
1720  return true;
1721  });
1722  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
1723 
1724  EngineModifier modifier{engine.get()};
1725  modifier.SetEGLManager(std::move(egl_manager));
1726 
1727  std::unique_ptr<FlutterWindowsView> view =
1728  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1729  /*is_sized_to_content=*/false, BoxConstraints(),
1730  /*allow_implicit_view=*/true);
1731 }
1732 
1733 // Desktop Window Manager composition can be disabled on Windows 7.
1734 // If this happens, the app must synchronize with the vsync to prevent
1735 // screen tearing.
1736 TEST(FlutterWindowsViewTest, UpdatesVSyncOnDwmUpdates) {
1737  auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
1738  auto engine = std::make_unique<MockFlutterWindowsEngine>(windows_proc_table);
1739  auto egl_manager = std::make_unique<egl::MockManager>();
1740  egl::MockContext render_context;
1741  auto surface = std::make_unique<egl::MockWindowSurface>();
1742  auto surface_ptr = surface.get();
1743 
1744  EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(true));
1745 
1746  EXPECT_CALL(*engine.get(), PostRasterThreadTask)
1747  .WillRepeatedly([](fml::closure callback) {
1748  callback();
1749  return true;
1750  });
1751 
1752  EXPECT_CALL(*egl_manager.get(), render_context)
1753  .WillRepeatedly(Return(&render_context));
1754 
1755  EXPECT_CALL(*surface_ptr, IsValid).WillRepeatedly(Return(true));
1756  EXPECT_CALL(*surface_ptr, MakeCurrent).WillRepeatedly(Return(true));
1757  EXPECT_CALL(*surface_ptr, Destroy).Times(1);
1758  EXPECT_CALL(render_context, ClearCurrent).WillRepeatedly(Return(true));
1759 
1760  InSequence s;
1761 
1762  // Mock render surface initialization.
1763  std::unique_ptr<FlutterWindowsView> view;
1764  {
1765  EXPECT_CALL(*egl_manager, CreateWindowSurface)
1766  .WillOnce(Return(std::move(surface)));
1767  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1768  .WillOnce(Return(true));
1769  EXPECT_CALL(*surface_ptr, SetVSyncEnabled).WillOnce(Return(true));
1770 
1771  EngineModifier engine_modifier{engine.get()};
1772  engine_modifier.SetEGLManager(std::move(egl_manager));
1773 
1774  view = engine->CreateView(
1775  std::make_unique<NiceMock<MockWindowBindingHandler>>(), false,
1776  BoxConstraints(),
1777  /*allow_implicit_view=*/true);
1778  }
1779 
1780  // Disabling DWM composition should enable vsync blocking on the surface.
1781  {
1782  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1783  .WillOnce(Return(false));
1784  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(true)).WillOnce(Return(true));
1785 
1786  engine->OnDwmCompositionChanged();
1787  }
1788 
1789  // Enabling DWM composition should disable vsync blocking on the surface.
1790  {
1791  EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1792  .WillOnce(Return(true));
1793  EXPECT_CALL(*surface_ptr, SetVSyncEnabled(false)).WillOnce(Return(true));
1794 
1795  engine->OnDwmCompositionChanged();
1796  }
1797 }
1798 
1799 TEST(FlutterWindowsViewTest, FocusTriggersWindowFocus) {
1800  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1801  auto window_binding_handler =
1802  std::make_unique<NiceMock<MockWindowBindingHandler>>();
1803  EXPECT_CALL(*window_binding_handler, Focus()).WillOnce(Return(true));
1804  std::unique_ptr<FlutterWindowsView> view =
1805  engine->CreateView(std::move(window_binding_handler),
1806  /*is_sized_to_content=*/false, BoxConstraints(),
1807  /*allow_implicit_view=*/true);
1808  EXPECT_TRUE(view->Focus());
1809 }
1810 
1811 TEST(FlutterWindowsViewTest, OnFocusTriggersSendFocusViewEvent) {
1812  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1813  auto window_binding_handler =
1814  std::make_unique<NiceMock<MockWindowBindingHandler>>();
1815  std::unique_ptr<FlutterWindowsView> view =
1816  engine->CreateView(std::move(window_binding_handler),
1817  /*is_sized_to_content=*/false, BoxConstraints(),
1818  /*allow_implicit_view=*/true);
1819 
1820  EngineModifier modifier(engine.get());
1821  bool received_focus_event = false;
1822  modifier.embedder_api().SendViewFocusEvent = MOCK_ENGINE_PROC(
1823  SendViewFocusEvent, [&](FLUTTER_API_SYMBOL(FlutterEngine) raw_engine,
1824  FlutterViewFocusEvent const* event) {
1825  EXPECT_EQ(event->state, FlutterViewFocusState::kFocused);
1826  EXPECT_EQ(event->direction, FlutterViewFocusDirection::kUndefined);
1827  EXPECT_EQ(event->view_id, view->view_id());
1828  EXPECT_EQ(event->struct_size, sizeof(FlutterViewFocusEvent));
1829  received_focus_event = true;
1830  return kSuccess;
1831  });
1832  view->OnFocus(FlutterViewFocusState::kFocused,
1833  FlutterViewFocusDirection::kUndefined);
1834  EXPECT_TRUE(received_focus_event);
1835 }
1836 
1837 TEST(FlutterWindowsViewTest, WindowMetricsEventContainsDisplayId) {
1838  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1839  EngineModifier modifier(engine.get());
1840 
1841  auto window_binding_handler =
1842  std::make_unique<NiceMock<MockWindowBindingHandler>>();
1843  EXPECT_CALL(*window_binding_handler, GetDisplayId)
1844  .WillOnce(testing::Return(12));
1845  FlutterWindowsView view{kImplicitViewId, engine.get(),
1846  std::move(window_binding_handler), false,
1847  BoxConstraints()};
1848 
1849  FlutterWindowMetricsEvent event = view.CreateWindowMetricsEvent();
1850  EXPECT_EQ(event.display_id, 12);
1851 }
1852 
1853 TEST(FlutterWindowsViewTest, SizeChangeTriggersMetricsEventWhichHasDisplayId) {
1854  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1855  EngineModifier modifier(engine.get());
1856 
1857  auto window_binding_handler =
1858  std::make_unique<NiceMock<MockWindowBindingHandler>>();
1859  EXPECT_CALL(*window_binding_handler, GetDisplayId)
1860  .WillOnce(testing::Return(12));
1861  FlutterWindowsView view{kImplicitViewId, engine.get(),
1862  std::move(window_binding_handler), false,
1863  BoxConstraints()};
1864 
1865  bool received_metrics = false;
1866  modifier.embedder_api().SendWindowMetricsEvent = MOCK_ENGINE_PROC(
1867  SendWindowMetricsEvent,
1868  ([&received_metrics](auto engine,
1869  const FlutterWindowMetricsEvent* event) {
1870  received_metrics = true;
1871  EXPECT_EQ(event->display_id, 12);
1872  return kSuccess;
1873  }));
1874  view.OnWindowSizeChanged(100, 100);
1875  EXPECT_TRUE(received_metrics);
1876 }
1877 
1878 // Verify that the first frame callback fires after OnFramePresented (OpenGL
1879 // rendering path).
1880 TEST(FlutterWindowsViewTest, FirstFrameCallbackFiresOnFramePresented) {
1881  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1882 
1883  std::unique_ptr<FlutterWindowsView> view =
1884  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1885  /*is_sized_to_content=*/false, BoxConstraints(),
1886  /*allow_implicit_view=*/true);
1887 
1888  bool callback_fired = false;
1889  view->SetFirstFrameCallback([&callback_fired]() { callback_fired = true; });
1890 
1891  // Simulate the raster thread presenting a frame.
1892  view->OnFramePresented();
1893 
1894  // The callback is posted to the platform thread's task runner.
1895  // Process pending tasks to execute it.
1896  engine->task_runner()->ProcessTasks();
1897 
1898  EXPECT_TRUE(callback_fired);
1899 }
1900 
1901 // Verify that the first frame callback fires after PresentSoftwareBitmap
1902 // (software rendering path).
1903 TEST(FlutterWindowsViewTest, FirstFrameCallbackFiresOnSoftwareBitmapPresent) {
1904  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1905 
1906  auto window_binding_handler =
1907  std::make_unique<NiceMock<MockWindowBindingHandler>>();
1908  EXPECT_CALL(*window_binding_handler, OnBitmapSurfaceUpdated)
1909  .WillOnce(Return(true));
1910 
1911  std::unique_ptr<FlutterWindowsView> view =
1912  engine->CreateView(std::move(window_binding_handler),
1913  /*is_sized_to_content=*/false, BoxConstraints(),
1914  /*allow_implicit_view=*/true);
1915 
1916  bool callback_fired = false;
1917  view->SetFirstFrameCallback([&callback_fired]() { callback_fired = true; });
1918 
1919  // Simulate software rendering presenting a bitmap.
1920  const uint32_t pixel = 0;
1921  view->PresentSoftwareBitmap(&pixel, sizeof(pixel), 1);
1922 
1923  // Process pending tasks.
1924  engine->task_runner()->ProcessTasks();
1925 
1926  EXPECT_TRUE(callback_fired);
1927 }
1928 
1929 // Verify that the first frame callback fires only once, even if multiple
1930 // frames are presented.
1931 TEST(FlutterWindowsViewTest, FirstFrameCallbackFiresOnlyOnce) {
1932  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1933 
1934  std::unique_ptr<FlutterWindowsView> view =
1935  engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1936  /*is_sized_to_content=*/false, BoxConstraints(),
1937  /*allow_implicit_view=*/true);
1938 
1939  int callback_count = 0;
1940  view->SetFirstFrameCallback([&callback_count]() { callback_count++; });
1941 
1942  // Present two frames.
1943  view->OnFramePresented();
1944  view->OnFramePresented();
1945 
1946  // Process all pending tasks.
1947  engine->task_runner()->ProcessTasks();
1948 
1949  EXPECT_EQ(callback_count, 1);
1950 }
1951 
1952 // Verify that the first frame callback does not fire if PresentSoftwareBitmap
1953 // fails.
1954 TEST(FlutterWindowsViewTest, FirstFrameCallbackSkippedOnFailedSoftwarePresent) {
1955  std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1956 
1957  auto window_binding_handler =
1958  std::make_unique<NiceMock<MockWindowBindingHandler>>();
1959  EXPECT_CALL(*window_binding_handler, OnBitmapSurfaceUpdated)
1960  .WillOnce(Return(false));
1961 
1962  std::unique_ptr<FlutterWindowsView> view =
1963  engine->CreateView(std::move(window_binding_handler),
1964  /*is_sized_to_content=*/false, BoxConstraints(),
1965  /*allow_implicit_view=*/true);
1966 
1967  bool callback_fired = false;
1968  view->SetFirstFrameCallback([&callback_fired]() { callback_fired = true; });
1969 
1970  const uint32_t pixel = 0;
1971  view->PresentSoftwareBitmap(&pixel, sizeof(pixel), 1);
1972 
1973  engine->task_runner()->ProcessTasks();
1974 
1975  EXPECT_FALSE(callback_fired);
1976 }
1977 
1978 } // namespace testing
1979 } // namespace flutter
std::shared_ptr< FlutterPlatformNodeDelegateWindows > node_delegate
Controls a view that displays Flutter content.
static const JsonMessageCodec & GetInstance()
std::unique_ptr< std::vector< uint8_t > > EncodeMessage(const T &message) const
Definition: message_codec.h:45
const char * name
void(* FlutterDesktopBinaryReply)(const uint8_t *data, size_t data_size, void *user_data)
void(* VoidCallback)(void *)
@ DefaultImpeller
FlutterDesktopBinaryReply callback
TEST(AccessibilityBridgeWindows, GetParent)
int64_t FlutterViewId
constexpr FlutterViewId kImplicitViewId
FlutterDesktopImpellerSwitch impeller_switch