7 #include <UIAutomation.h>
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"
32 #include "gmock/gmock.h"
33 #include "gtest/gtest.h"
39 using ::testing::InSequence;
40 using ::testing::NiceMock;
41 using ::testing::Return;
52 struct TestResponseHandle {
57 static bool test_response =
false;
59 constexpr uint64_t kKeyEventFromChannel = 0x11;
60 constexpr uint64_t kKeyEventFromEmbedder = 0x22;
61 static std::vector<int> key_event_logs;
63 std::unique_ptr<std::vector<uint8_t>> keyHandlingResponse(
bool handled) {
64 rapidjson::Document document;
65 auto& allocator = document.GetAllocator();
67 document.AddMember(
"handled", test_response, allocator);
73 FlutterProjectBundle GetTestProject() {
75 properties.
assets_path = L
"C:\\foo\\flutter_assets";
80 return FlutterProjectBundle{properties};
83 class ViewTestEGLManager :
public egl::MockManager {
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));
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));
101 NiceMock<egl::MockContext> mock_context_;
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));
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) {
119 reinterpret_cast<FLUTTER_API_SYMBOL(FlutterEngine)
>(0x12345678);
123 modifier.embedder_api().Shutdown = MOCK_ENGINE_PROC(
125 ([](FLUTTER_API_SYMBOL(FlutterEngine) engine) {
return kSuccess; }));
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; }));
132 modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
133 UpdateAccessibilityFeatures,
134 ([](FLUTTER_API_SYMBOL(FlutterEngine) engine,
135 FlutterAccessibilityFeature flags) {
return kSuccess; }));
137 modifier.embedder_api().PostRenderThreadTask = MOCK_ENGINE_PROC(
138 PostRenderThreadTask, ([](
auto engine,
auto callback,
auto context) {
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);
149 key_response_controller->SetEmbedderResponse(
150 [](
const FlutterKeyEvent* event,
151 MockKeyResponseController::ResponseCallback
callback) {
152 key_event_logs.push_back(kKeyEventFromEmbedder);
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; }));
163 MockEmbedderApiForKeyboard(modifier, key_response_controller);
169 class MockFlutterWindowsEngine :
public FlutterWindowsEngine {
171 explicit MockFlutterWindowsEngine(
172 std::shared_ptr<WindowsProcTable> windows_proc_table =
nullptr)
173 : FlutterWindowsEngine(GetTestProject(), std::move(windows_proc_table)) {}
175 MOCK_METHOD(
bool, running, (), (
const));
176 MOCK_METHOD(
bool, Stop, (), ());
178 MOCK_METHOD(
bool, PostRasterThreadTask, (fml::closure), (
const));
181 FML_DISALLOW_COPY_AND_ASSIGN(MockFlutterWindowsEngine);
188 TEST(FlutterWindowsViewTest, SubMenuExpandedState) {
189 std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
190 EngineModifier modifier(engine.get());
191 modifier.embedder_api().UpdateSemanticsEnabled =
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 false, BoxConstraints(),
204 view->OnUpdateSemanticsEnabled(
true);
206 auto bridge = view->accessibility_bridge().lock();
209 FlutterSemanticsNode2 root{
sizeof(FlutterSemanticsNode2), 0};
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,
221 root.flags2 = &flags;
223 bridge->AddFlutterSemanticsNodeUpdate(root);
225 bridge->CommitUpdates();
228 auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
229 EXPECT_TRUE(root_node->GetData().HasState(ax::mojom::State::kExpanded));
232 IAccessible* native_view = root_node->GetNativeViewAccessible();
233 ASSERT_TRUE(native_view !=
nullptr);
236 VARIANT varchild = {};
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);
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);
252 ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
253 UIA_AriaPropertiesPropertyId, &native_state)));
254 EXPECT_NE(std::wcsstr(native_state.bstrVal, L
"expanded=true"),
nullptr);
258 auto updated_flags = FlutterSemanticsFlags{
259 .is_expanded = FlutterTristate::kFlutterTristateFalse,
261 root.flags2 = &updated_flags;
263 bridge->AddFlutterSemanticsNodeUpdate(root);
264 bridge->CommitUpdates();
267 auto root_node = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
268 EXPECT_TRUE(root_node->GetData().HasState(ax::mojom::State::kCollapsed));
271 IAccessible* native_view = root_node->GetNativeViewAccessible();
272 ASSERT_TRUE(native_view !=
nullptr);
275 VARIANT varchild = {};
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);
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);
291 ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
292 UIA_AriaPropertiesPropertyId, &native_state)));
293 EXPECT_NE(std::wcsstr(native_state.bstrVal, L
"expanded=false"),
nullptr);
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;
307 auto engine_ptr = engine.get();
308 auto surface_ptr = surface.get();
309 auto egl_manager_ptr = egl_manager.get();
311 EngineModifier modifier{engine.get()};
312 modifier.SetEGLManager(std::move(egl_manager));
315 std::unique_ptr<FlutterWindowsView> view;
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));
329 view = engine->CreateView(std::move(window_binding_handler),
false,
330 BoxConstraints(),
true);
335 auto view_id = view->view_id();
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) {
346 EXPECT_CALL(*surface_ptr, Destroy).Times(1);
350 TEST(FlutterWindowsViewTest, KeySequence) {
351 std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
353 test_response =
false;
355 std::unique_ptr<FlutterWindowsView> view =
356 engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
357 false, BoxConstraints(),
361 [](
bool handled) {});
363 EXPECT_EQ(key_event_logs.size(), 2);
364 EXPECT_EQ(key_event_logs[0], kKeyEventFromEmbedder);
365 EXPECT_EQ(key_event_logs[1], kKeyEventFromChannel);
367 key_event_logs.clear();
370 TEST(FlutterWindowsViewTest, KeyEventCallback) {
371 std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
373 std::unique_ptr<FlutterWindowsView> view =
374 engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
375 false, BoxConstraints(),
380 MOCK_METHOD(
void, Call, ());
383 NiceMock<MockCallback> callback_with_valid_view;
384 NiceMock<MockCallback> callback_with_invalid_view;
386 auto trigger_key_event = [&](NiceMock<MockCallback>&
callback) {
391 EXPECT_CALL(callback_with_valid_view, Call()).Times(1);
392 EXPECT_CALL(callback_with_invalid_view, Call()).Times(0);
394 trigger_key_event(callback_with_valid_view);
395 engine->RemoveView(view->view_id());
396 trigger_key_event(callback_with_invalid_view);
398 key_event_logs.clear();
401 TEST(FlutterWindowsViewTest, EnableSemantics) {
402 std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
403 EngineModifier modifier(engine.get());
405 bool semantics_enabled =
false;
406 modifier.embedder_api().UpdateSemanticsEnabled = MOCK_ENGINE_PROC(
407 UpdateSemanticsEnabled,
408 [&semantics_enabled](FLUTTER_API_SYMBOL(
FlutterEngine) engine,
410 semantics_enabled = enabled;
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 false, BoxConstraints(),
421 view->OnUpdateSemanticsEnabled(
true);
422 EXPECT_TRUE(semantics_enabled);
425 TEST(FlutterWindowsViewTest, AddSemanticsNodeUpdate) {
426 std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
427 EngineModifier modifier(engine.get());
428 modifier.embedder_api().UpdateSemanticsEnabled =
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 false, BoxConstraints(),
441 view->OnUpdateSemanticsEnabled(
true);
443 auto bridge = view->accessibility_bridge().lock();
447 FlutterSemanticsNode2 node{
sizeof(FlutterSemanticsNode2), 0};
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();
457 auto node_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
463 ASSERT_TRUE(native_view !=
nullptr);
468 varchild.lVal = CHILDID_SELF;
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");
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");
485 ASSERT_EQ(native_view->get_accRole(varchild, &varrole), S_OK);
486 EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_STATICTEXT);
489 IRawElementProviderSimple* uia_view;
490 native_view->QueryInterface(IID_PPV_ARGS(&uia_view));
491 ASSERT_TRUE(uia_view !=
nullptr);
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");
502 ASSERT_EQ(uia_view->GetPropertyValue(UIA_ValueValuePropertyId, &varvalue),
504 EXPECT_EQ(varvalue.vt, VT_BSTR);
505 value = _com_util::ConvertBSTRToString(varvalue.bstrVal);
506 EXPECT_EQ(value,
"value");
510 ASSERT_EQ(uia_view->GetPropertyValue(UIA_ControlTypePropertyId, &varrole),
512 EXPECT_EQ(varrole.vt, VT_I4);
513 EXPECT_EQ(varrole.lVal, UIA_TextControlTypeId);
528 TEST(FlutterWindowsViewTest, AddSemanticsNodeUpdateWithChildren) {
529 std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
530 EngineModifier modifier(engine.get());
531 modifier.embedder_api().UpdateSemanticsEnabled =
536 std::unique_ptr<FlutterWindowsView> view =
537 engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
538 false, BoxConstraints(),
542 view->OnUpdateSemanticsEnabled(
true);
544 auto bridge = view->accessibility_bridge().lock();
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;
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";
569 node3.flags2 = &empty_flags;
571 bridge->AddFlutterSemanticsNodeUpdate(node0);
572 bridge->AddFlutterSemanticsNodeUpdate(node1);
573 bridge->AddFlutterSemanticsNodeUpdate(node2);
574 bridge->AddFlutterSemanticsNodeUpdate(node3);
575 bridge->CommitUpdates();
578 auto node_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
584 ASSERT_TRUE(node0_accessible !=
nullptr);
589 varchild.lVal = CHILDID_SELF;
594 ASSERT_EQ(node0_accessible->get_accRole(varchild, &varrole), S_OK);
595 EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_GROUPING);
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);
605 IDispatch* node1_dispatch =
nullptr;
606 ASSERT_EQ(node0_accessible->get_accChild(varchild, &node1_dispatch), S_OK);
607 ASSERT_TRUE(node1_dispatch !=
nullptr);
609 ASSERT_EQ(node1_dispatch->QueryInterface(
610 IID_IAccessible,
reinterpret_cast<void**
>(&node1_accessible)),
612 ASSERT_TRUE(node1_accessible !=
nullptr);
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");
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");
630 ASSERT_EQ(node1_accessible->get_accRole(varchild, &varrole), S_OK);
631 EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_STATICTEXT);
634 IDispatch* parent_dispatch;
635 node1_accessible->get_accParent(&parent_dispatch);
638 parent_dispatch->QueryInterface(
639 IID_IAccessible,
reinterpret_cast<void**
>(&parent_accessible)),
641 EXPECT_EQ(parent_accessible, node0_accessible);
646 IDispatch* node2_dispatch =
nullptr;
647 ASSERT_EQ(node0_accessible->get_accChild(varchild, &node2_dispatch), S_OK);
648 ASSERT_TRUE(node2_dispatch !=
nullptr);
650 ASSERT_EQ(node2_dispatch->QueryInterface(
651 IID_IAccessible,
reinterpret_cast<void**
>(&node2_accessible)),
653 ASSERT_TRUE(node2_accessible !=
nullptr);
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);
662 varchild.lVal = CHILDID_SELF;
665 ASSERT_EQ(node2_accessible->get_accRole(varchild, &varrole), S_OK);
666 EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_GROUPING);
669 IDispatch* parent_dispatch;
670 node2_accessible->get_accParent(&parent_dispatch);
673 parent_dispatch->QueryInterface(
674 IID_IAccessible,
reinterpret_cast<void**
>(&parent_accessible)),
676 EXPECT_EQ(parent_accessible, node0_accessible);
682 IDispatch* node3_dispatch =
nullptr;
683 ASSERT_EQ(node2_accessible->get_accChild(varchild, &node3_dispatch), S_OK);
684 ASSERT_TRUE(node3_dispatch !=
nullptr);
686 ASSERT_EQ(node3_dispatch->QueryInterface(
687 IID_IAccessible,
reinterpret_cast<void**
>(&node3_accessible)),
689 ASSERT_TRUE(node3_accessible !=
nullptr);
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");
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");
707 ASSERT_EQ(node3_accessible->get_accRole(varchild, &varrole), S_OK);
708 EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_STATICTEXT);
711 IDispatch* parent_dispatch;
712 node3_accessible->get_accParent(&parent_dispatch);
715 parent_dispatch->QueryInterface(
716 IID_IAccessible,
reinterpret_cast<void**
>(&parent_accessible)),
718 EXPECT_EQ(parent_accessible, node2_accessible);
731 TEST(FlutterWindowsViewTest, NonZeroSemanticsRoot) {
732 std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
733 EngineModifier modifier(engine.get());
734 modifier.embedder_api().UpdateSemanticsEnabled =
739 std::unique_ptr<FlutterWindowsView> view =
740 engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
741 false, BoxConstraints(),
745 view->OnUpdateSemanticsEnabled(
true);
747 auto bridge = view->accessibility_bridge().lock();
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;
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();
768 auto root_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(1).lock();
769 ASSERT_TRUE(root_delegate);
770 EXPECT_EQ(root_delegate->GetChildCount(), 1);
773 auto child_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(2).lock();
774 ASSERT_TRUE(child_delegate);
775 EXPECT_EQ(child_delegate->GetChildCount(), 0);
778 auto fake_delegate = bridge->GetFlutterPlatformNodeDelegateFromID(0).lock();
779 ASSERT_FALSE(fake_delegate);
782 IAccessible* node1_accessible = root_delegate->GetNativeViewAccessible();
783 ASSERT_TRUE(node1_accessible !=
nullptr);
788 varchild.lVal = CHILDID_SELF;
793 ASSERT_EQ(node1_accessible->get_accRole(varchild, &varrole), S_OK);
794 EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_GROUPING);
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);
804 IDispatch* node2_dispatch =
nullptr;
805 ASSERT_EQ(node1_accessible->get_accChild(varchild, &node2_dispatch), S_OK);
806 ASSERT_TRUE(node2_dispatch !=
nullptr);
808 ASSERT_EQ(node2_dispatch->QueryInterface(
809 IID_IAccessible,
reinterpret_cast<void**
>(&node2_accessible)),
811 ASSERT_TRUE(node2_accessible !=
nullptr);
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");
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");
829 ASSERT_EQ(node2_accessible->get_accRole(varchild, &varrole), S_OK);
830 EXPECT_EQ(varrole.lVal, ROLE_SYSTEM_STATICTEXT);
833 IDispatch* parent_dispatch;
834 node2_accessible->get_accParent(&parent_dispatch);
837 parent_dispatch->QueryInterface(
838 IID_IAccessible,
reinterpret_cast<void**
>(&parent_accessible)),
840 EXPECT_EQ(parent_accessible, node1_accessible);
861 TEST(FlutterWindowsViewTest, AccessibilityHitTesting) {
862 constexpr FlutterTransformation kIdentityTransform = {1, 0, 0,
866 std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
867 EngineModifier modifier(engine.get());
868 modifier.embedder_api().UpdateSemanticsEnabled =
873 std::unique_ptr<FlutterWindowsView> view =
874 engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
875 false, BoxConstraints(),
879 view->OnUpdateSemanticsEnabled(
true);
881 auto bridge = view->accessibility_bridge().lock();
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;
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;
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;
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";
919 node3.flags2 = &empty_flags;
921 bridge->AddFlutterSemanticsNodeUpdate(node0);
922 bridge->AddFlutterSemanticsNodeUpdate(node1);
923 bridge->AddFlutterSemanticsNodeUpdate(node2);
924 bridge->AddFlutterSemanticsNodeUpdate(node3);
925 bridge->CommitUpdates();
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);
938 IAccessible* node0_accessible = node0_delegate->GetNativeViewAccessible();
939 ASSERT_TRUE(node0_accessible !=
nullptr);
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());
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());
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());
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);
965 EngineModifier engine_modifier{engine.get()};
966 engine_modifier.embedder_api().PostRenderThreadTask = MOCK_ENGINE_PROC(
967 PostRenderThreadTask,
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;
978 auto surface_ptr = surface.get();
979 auto resized_surface_ptr = resized_surface.get();
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));
991 EXPECT_CALL(*surface_ptr, Destroy).WillOnce(Return(
true));
992 EXPECT_CALL(*egl_manager.get(),
993 CreateWindowSurface(_, 500, 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));
999 EXPECT_CALL(*resized_surface_ptr, Destroy).WillOnce(Return(
true));
1001 engine_modifier.SetEGLManager(std::move(egl_manager));
1003 std::unique_ptr<FlutterWindowsView> view =
1004 engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1005 false, BoxConstraints(),
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();
1018 std::thread frame_thread([&metrics_sent_latch, &view]() {
1019 metrics_sent_latch.Wait();
1021 EXPECT_TRUE(view->OnFrameGenerated(500, 500));
1022 view->OnFramePresented();
1028 EXPECT_TRUE(view->OnWindowSizeChanged(500, 500));
1029 frame_thread.join();
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);
1038 EngineModifier engine_modifier{engine.get()};
1039 engine_modifier.embedder_api().PostRenderThreadTask = MOCK_ENGINE_PROC(
1040 PostRenderThreadTask,
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();
1051 EXPECT_CALL(*surface.get(), IsValid).WillRepeatedly(Return(
true));
1052 EXPECT_CALL(*surface.get(), Destroy).WillOnce(Return(
true));
1054 EXPECT_CALL(*egl_manager.get(),
1055 CreateWindowSurface(_, 500, 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));
1061 EXPECT_CALL(*resized_surface_ptr, Destroy).WillOnce(Return(
true));
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();
1072 std::unique_ptr<FlutterWindowsView> view =
1073 engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1074 false, BoxConstraints(),
1077 ViewModifier view_modifier{view.get()};
1078 engine_modifier.SetEGLManager(std::move(egl_manager));
1079 view_modifier.SetSurface(std::move(surface));
1082 std::thread frame_thread([&metrics_sent_latch, &view]() {
1083 metrics_sent_latch.Wait();
1086 EXPECT_TRUE(view->OnEmptyFrameGenerated());
1087 view->OnFramePresented();
1092 EXPECT_TRUE(view->OnWindowSizeChanged(500, 300));
1093 frame_thread.join();
1099 TEST(FlutterWindowsViewTest, WindowResizeRace) {
1100 std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1102 EngineModifier engine_modifier(engine.get());
1103 engine_modifier.embedder_api().PostRenderThreadTask = MOCK_ENGINE_PROC(
1104 PostRenderThreadTask,
1110 auto egl_manager = std::make_unique<egl::MockManager>();
1111 auto surface = std::make_unique<egl::MockWindowSurface>();
1113 EXPECT_CALL(*surface.get(), IsValid).WillRepeatedly(Return(
true));
1114 EXPECT_CALL(*surface.get(), Destroy).WillOnce(Return(
true));
1116 std::unique_ptr<FlutterWindowsView> view =
1117 engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1118 false, BoxConstraints(),
1121 ViewModifier view_modifier{view.get()};
1122 engine_modifier.SetEGLManager(std::move(egl_manager));
1123 view_modifier.SetSurface(std::move(surface));
1126 ASSERT_TRUE(view->OnFrameGenerated(100, 100));
1130 EXPECT_FALSE(view->OnWindowSizeChanged(500, 500));
1135 view->OnFramePresented();
1140 TEST(FlutterWindowsViewTest, WindowResizeInvalidSurface) {
1141 std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1143 EngineModifier engine_modifier(engine.get());
1144 engine_modifier.embedder_api().PostRenderThreadTask = MOCK_ENGINE_PROC(
1145 PostRenderThreadTask,
1151 auto egl_manager = std::make_unique<egl::MockManager>();
1152 auto surface = std::make_unique<egl::MockWindowSurface>();
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));
1158 std::unique_ptr<FlutterWindowsView> view =
1159 engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1160 false, BoxConstraints(),
1163 ViewModifier view_modifier{view.get()};
1164 engine_modifier.SetEGLManager(std::move(egl_manager));
1165 view_modifier.SetSurface(std::move(surface));
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;
1175 view->OnWindowSizeChanged(500, 500);
1180 TEST(FlutterWindowsViewTest, WindowResizeWithoutSurface) {
1181 std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1182 EngineModifier modifier(engine.get());
1184 auto egl_manager = std::make_unique<egl::MockManager>();
1186 EXPECT_CALL(*egl_manager.get(), CreateWindowSurface).Times(0);
1188 std::unique_ptr<FlutterWindowsView> view =
1189 engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1190 false, BoxConstraints(),
1193 modifier.SetEGLManager(std::move(egl_manager));
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;
1203 view->OnWindowSizeChanged(500, 500);
1206 TEST(FlutterWindowsViewTest, WindowRepaintTests) {
1207 std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1208 EngineModifier modifier(engine.get());
1211 std::make_unique<flutter::FlutterWindow>(
1212 100, 100, engine->display_manager()),
1213 false, BoxConstraints()};
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;
1222 view.OnWindowRepaint();
1223 EXPECT_TRUE(schedule_frame_called);
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) {
1240 std::unique_ptr<FlutterWindowsView> view =
1241 engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1242 false, BoxConstraints(),
1246 view->OnUpdateSemanticsEnabled(
true);
1248 auto bridge = view->accessibility_bridge().lock();
1249 ASSERT_TRUE(bridge);
1251 FlutterSemanticsNode2 root{
sizeof(FlutterSemanticsNode2), 0};
1253 root.label =
"root";
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,
1263 root.flags2 = &flags;
1264 bridge->AddFlutterSemanticsNodeUpdate(root);
1266 bridge->CommitUpdates();
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);
1275 IAccessible* native_view = root_node->GetNativeViewAccessible();
1276 ASSERT_TRUE(native_view !=
nullptr);
1279 VARIANT varchild = {};
1280 varchild.vt = VT_I4;
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);
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);
1295 ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
1296 UIA_AriaPropertiesPropertyId, &native_state)));
1297 EXPECT_NE(std::wcsstr(native_state.bstrVal, L
"checked=true"),
nullptr);
1301 auto updated_flags = FlutterSemanticsFlags{
1302 .is_checked = FlutterCheckState::kFlutterCheckStateFalse,
1304 root.flags2 = &updated_flags;
1305 bridge->AddFlutterSemanticsNodeUpdate(root);
1306 bridge->CommitUpdates();
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);
1315 IAccessible* native_view = root_node->GetNativeViewAccessible();
1316 ASSERT_TRUE(native_view !=
nullptr);
1319 VARIANT varchild = {};
1320 varchild.vt = VT_I4;
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);
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);
1335 ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
1336 UIA_AriaPropertiesPropertyId, &native_state)));
1337 EXPECT_NE(std::wcsstr(native_state.bstrVal, L
"checked=false"),
nullptr);
1341 auto updated_mixe_flags = FlutterSemanticsFlags{
1342 .is_checked = FlutterCheckState::kFlutterCheckStateMixed,
1344 root.flags2 = &updated_mixe_flags;
1345 bridge->AddFlutterSemanticsNodeUpdate(root);
1346 bridge->CommitUpdates();
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);
1355 IAccessible* native_view = root_node->GetNativeViewAccessible();
1356 ASSERT_TRUE(native_view !=
nullptr);
1359 VARIANT varchild = {};
1360 varchild.vt = VT_I4;
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);
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);
1375 ASSERT_TRUE(SUCCEEDED(uia_node->GetPropertyValue(
1376 UIA_AriaPropertiesPropertyId, &native_state)));
1377 EXPECT_NE(std::wcsstr(native_state.bstrVal, L
"checked=mixed"),
nullptr);
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) {
1390 std::unique_ptr<FlutterWindowsView> view =
1391 engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1392 false, BoxConstraints(),
1396 view->OnUpdateSemanticsEnabled(
true);
1398 auto bridge = view->accessibility_bridge().lock();
1399 ASSERT_TRUE(bridge);
1401 FlutterSemanticsNode2 root{
sizeof(FlutterSemanticsNode2), 0};
1403 root.label =
"root";
1406 root.increased_value =
"";
1407 root.decreased_value =
"";
1408 root.child_count = 0;
1409 root.custom_accessibility_actions_count = 0;
1411 auto flags = FlutterSemanticsFlags{
1412 .is_toggled = FlutterTristate::kFlutterTristateTrue,
1414 root.flags2 = &flags;
1415 bridge->AddFlutterSemanticsNodeUpdate(root);
1417 bridge->CommitUpdates();
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);
1426 IAccessible* native_view = root_node->GetNativeViewAccessible();
1427 ASSERT_TRUE(native_view !=
nullptr);
1430 VARIANT varchild = {};
1431 varchild.vt = VT_I4;
1433 varchild.lVal = CHILDID_SELF;
1434 VARIANT varrole = {};
1437 ASSERT_EQ(native_view->get_accRole(varchild, &varrole), S_OK);
1438 ASSERT_EQ(varrole.lVal, ROLE_SYSTEM_CHECKBUTTON);
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);
1447 IRawElementProviderSimple* uia_node;
1448 native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
1449 ASSERT_EQ(uia_node->GetPropertyValue(UIA_ControlTypePropertyId, &varrole),
1451 EXPECT_EQ(varrole.lVal, UIA_ButtonControlTypeId);
1452 ASSERT_EQ(uia_node->GetPropertyValue(UIA_ToggleToggleStatePropertyId,
1455 EXPECT_EQ(native_state.lVal, ToggleState_On);
1457 uia_node->GetPropertyValue(UIA_AriaPropertiesPropertyId, &native_state),
1459 EXPECT_NE(std::wcsstr(native_state.bstrVal, L
"pressed=true"),
nullptr);
1463 auto updated_flags = FlutterSemanticsFlags{
1464 .is_toggled = FlutterTristate::kFlutterTristateFalse,
1466 root.flags2 = &updated_flags;
1468 bridge->AddFlutterSemanticsNodeUpdate(root);
1469 bridge->CommitUpdates();
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);
1478 IAccessible* native_view = root_node->GetNativeViewAccessible();
1479 ASSERT_TRUE(native_view !=
nullptr);
1482 VARIANT varchild = {};
1483 varchild.vt = VT_I4;
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);
1493 IRawElementProviderSimple* uia_node;
1494 native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
1495 ASSERT_EQ(uia_node->GetPropertyValue(UIA_ToggleToggleStatePropertyId,
1498 EXPECT_EQ(native_state.lVal, ToggleState_Off);
1500 uia_node->GetPropertyValue(UIA_AriaPropertiesPropertyId, &native_state),
1502 EXPECT_NE(std::wcsstr(native_state.bstrVal, L
"pressed=false"),
nullptr);
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) {
1514 std::unique_ptr<FlutterWindowsView> view =
1515 engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1516 false, BoxConstraints(),
1520 view->OnUpdateSemanticsEnabled(
true);
1522 auto bridge = view->accessibility_bridge().lock();
1523 ASSERT_TRUE(bridge);
1525 FlutterSemanticsNode2 root{
sizeof(FlutterSemanticsNode2), 0};
1527 root.label =
"root";
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,
1538 root.flags2 = &flags;
1539 bridge->AddFlutterSemanticsNodeUpdate(root);
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");
1548 IAccessible* native_view = bridge->GetFlutterPlatformNodeDelegateFromID(0)
1550 ->GetNativeViewAccessible();
1551 VARIANT varchild = {.vt = VT_I4, .lVal = CHILDID_SELF};
1553 ASSERT_EQ(native_view->get_accName(varchild, &bname), S_OK);
1554 EXPECT_NE(std::wcsstr(bname, L
"tooltip"),
nullptr);
1557 IRawElementProviderSimple* uia_node;
1558 native_view->QueryInterface(IID_PPV_ARGS(&uia_node));
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");
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();
1575 EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(
false));
1576 EXPECT_CALL(*engine.get(), PostRasterThreadTask).Times(0);
1578 EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1579 .WillOnce(Return(
true));
1581 EXPECT_CALL(*egl_manager.get(), render_context)
1582 .WillOnce(Return(&render_context));
1583 EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(
true));
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));
1592 EXPECT_CALL(*surface_ptr, Destroy).Times(1);
1594 EngineModifier modifier{engine.get()};
1595 modifier.SetEGLManager(std::move(egl_manager));
1597 std::unique_ptr<FlutterWindowsView> view =
1598 engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1599 false, BoxConstraints(),
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();
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));
1618 EXPECT_CALL(*egl_manager.get(), render_context)
1619 .WillOnce(Return(&render_context));
1620 EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(
true));
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));
1629 EXPECT_CALL(*surface_ptr, Destroy).Times(1);
1631 EngineModifier modifier{engine.get()};
1632 modifier.SetEGLManager(std::move(egl_manager));
1634 std::unique_ptr<FlutterWindowsView> view =
1635 engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1636 false, BoxConstraints(),
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();
1650 EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(
true));
1651 EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1652 .WillOnce(Return(
true));
1654 EXPECT_CALL(*egl_manager.get(), render_context)
1655 .WillOnce(Return(&render_context));
1656 EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(
true));
1659 EXPECT_CALL(*egl_manager.get(), CreateWindowSurface)
1660 .WillOnce(Return(std::move(surface)));
1661 EXPECT_CALL(*engine.get(), PostRasterThreadTask)
1662 .WillOnce([](fml::closure
callback) {
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) {
1674 EXPECT_CALL(*surface_ptr, Destroy).Times(1);
1676 EngineModifier modifier{engine.get()};
1677 modifier.SetEGLManager(std::move(egl_manager));
1679 std::unique_ptr<FlutterWindowsView> view =
1680 engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1681 false, BoxConstraints(),
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();
1695 EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(
true));
1697 EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1698 .WillOnce(Return(
false));
1700 EXPECT_CALL(*egl_manager.get(), render_context)
1701 .WillOnce(Return(&render_context));
1702 EXPECT_CALL(*surface_ptr, IsValid).WillOnce(Return(
true));
1705 EXPECT_CALL(*egl_manager.get(), CreateWindowSurface)
1706 .WillOnce(Return(std::move(surface)));
1707 EXPECT_CALL(*engine.get(), PostRasterThreadTask)
1708 .WillOnce([](fml::closure
callback) {
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));
1717 EXPECT_CALL(*engine.get(), PostRasterThreadTask)
1718 .WillOnce([](fml::closure
callback) {
1722 EXPECT_CALL(*surface_ptr, Destroy).Times(1);
1724 EngineModifier modifier{engine.get()};
1725 modifier.SetEGLManager(std::move(egl_manager));
1727 std::unique_ptr<FlutterWindowsView> view =
1728 engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1729 false, BoxConstraints(),
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();
1744 EXPECT_CALL(*engine.get(), running).WillRepeatedly(Return(
true));
1746 EXPECT_CALL(*engine.get(), PostRasterThreadTask)
1747 .WillRepeatedly([](fml::closure
callback) {
1752 EXPECT_CALL(*egl_manager.get(), render_context)
1753 .WillRepeatedly(Return(&render_context));
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));
1763 std::unique_ptr<FlutterWindowsView> view;
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));
1771 EngineModifier engine_modifier{engine.get()};
1772 engine_modifier.SetEGLManager(std::move(egl_manager));
1774 view = engine->CreateView(
1775 std::make_unique<NiceMock<MockWindowBindingHandler>>(),
false,
1782 EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1783 .WillOnce(Return(
false));
1784 EXPECT_CALL(*surface_ptr, SetVSyncEnabled(
true)).WillOnce(Return(
true));
1786 engine->OnDwmCompositionChanged();
1791 EXPECT_CALL(*windows_proc_table.get(), DwmIsCompositionEnabled)
1792 .WillOnce(Return(
true));
1793 EXPECT_CALL(*surface_ptr, SetVSyncEnabled(
false)).WillOnce(Return(
true));
1795 engine->OnDwmCompositionChanged();
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 false, BoxConstraints(),
1808 EXPECT_TRUE(view->Focus());
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 false, BoxConstraints(),
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;
1832 view->OnFocus(FlutterViewFocusState::kFocused,
1833 FlutterViewFocusDirection::kUndefined);
1834 EXPECT_TRUE(received_focus_event);
1837 TEST(FlutterWindowsViewTest, WindowMetricsEventContainsDisplayId) {
1838 std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1839 EngineModifier modifier(engine.get());
1841 auto window_binding_handler =
1842 std::make_unique<NiceMock<MockWindowBindingHandler>>();
1843 EXPECT_CALL(*window_binding_handler, GetDisplayId)
1844 .WillOnce(testing::Return(12));
1846 std::move(window_binding_handler),
false,
1849 FlutterWindowMetricsEvent
event = view.CreateWindowMetricsEvent();
1850 EXPECT_EQ(event.display_id, 12);
1853 TEST(FlutterWindowsViewTest, SizeChangeTriggersMetricsEventWhichHasDisplayId) {
1854 std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1855 EngineModifier modifier(engine.get());
1857 auto window_binding_handler =
1858 std::make_unique<NiceMock<MockWindowBindingHandler>>();
1859 EXPECT_CALL(*window_binding_handler, GetDisplayId)
1860 .WillOnce(testing::Return(12));
1862 std::move(window_binding_handler),
false,
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);
1874 view.OnWindowSizeChanged(100, 100);
1875 EXPECT_TRUE(received_metrics);
1880 TEST(FlutterWindowsViewTest, FirstFrameCallbackFiresOnFramePresented) {
1881 std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1883 std::unique_ptr<FlutterWindowsView> view =
1884 engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1885 false, BoxConstraints(),
1888 bool callback_fired =
false;
1889 view->SetFirstFrameCallback([&callback_fired]() { callback_fired =
true; });
1892 view->OnFramePresented();
1896 engine->task_runner()->ProcessTasks();
1898 EXPECT_TRUE(callback_fired);
1903 TEST(FlutterWindowsViewTest, FirstFrameCallbackFiresOnSoftwareBitmapPresent) {
1904 std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1906 auto window_binding_handler =
1907 std::make_unique<NiceMock<MockWindowBindingHandler>>();
1908 EXPECT_CALL(*window_binding_handler, OnBitmapSurfaceUpdated)
1909 .WillOnce(Return(
true));
1911 std::unique_ptr<FlutterWindowsView> view =
1912 engine->CreateView(std::move(window_binding_handler),
1913 false, BoxConstraints(),
1916 bool callback_fired =
false;
1917 view->SetFirstFrameCallback([&callback_fired]() { callback_fired =
true; });
1920 const uint32_t pixel = 0;
1921 view->PresentSoftwareBitmap(&pixel,
sizeof(pixel), 1);
1924 engine->task_runner()->ProcessTasks();
1926 EXPECT_TRUE(callback_fired);
1931 TEST(FlutterWindowsViewTest, FirstFrameCallbackFiresOnlyOnce) {
1932 std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1934 std::unique_ptr<FlutterWindowsView> view =
1935 engine->CreateView(std::make_unique<NiceMock<MockWindowBindingHandler>>(),
1936 false, BoxConstraints(),
1939 int callback_count = 0;
1940 view->SetFirstFrameCallback([&callback_count]() { callback_count++; });
1943 view->OnFramePresented();
1944 view->OnFramePresented();
1947 engine->task_runner()->ProcessTasks();
1949 EXPECT_EQ(callback_count, 1);
1954 TEST(FlutterWindowsViewTest, FirstFrameCallbackSkippedOnFailedSoftwarePresent) {
1955 std::unique_ptr<FlutterWindowsEngine> engine = GetTestEngine();
1957 auto window_binding_handler =
1958 std::make_unique<NiceMock<MockWindowBindingHandler>>();
1959 EXPECT_CALL(*window_binding_handler, OnBitmapSurfaceUpdated)
1960 .WillOnce(Return(
false));
1962 std::unique_ptr<FlutterWindowsView> view =
1963 engine->CreateView(std::move(window_binding_handler),
1964 false, BoxConstraints(),
1967 bool callback_fired =
false;
1968 view->SetFirstFrameCallback([&callback_fired]() { callback_fired =
true; });
1970 const uint32_t pixel = 0;
1971 view->PresentSoftwareBitmap(&pixel,
sizeof(pixel), 1);
1973 engine->task_runner()->ProcessTasks();
1975 EXPECT_FALSE(callback_fired);
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
void(* FlutterDesktopBinaryReply)(const uint8_t *data, size_t data_size, void *user_data)
void(* VoidCallback)(void *)
FlutterDesktopBinaryReply callback
constexpr uint64_t kScanCodeKeyA
TEST(AccessibilityBridgeWindows, GetParent)
constexpr uint64_t kVirtualKeyA
constexpr FlutterViewId kImplicitViewId
const wchar_t * icu_data_path
const wchar_t * assets_path
FlutterDesktopImpellerSwitch impeller_switch
const wchar_t * aot_library_path