10 #include "flutter/fml/logging.h"
11 #include "flutter/fml/macros.h"
12 #include "flutter/shell/platform/embedder/embedder.h"
13 #include "flutter/shell/platform/embedder/test_utils/proc_table_replacement.h"
16 #include "flutter/shell/platform/windows/testing/egl/mock_manager.h"
17 #include "flutter/shell/platform/windows/testing/engine_modifier.h"
18 #include "flutter/shell/platform/windows/testing/flutter_windows_engine_builder.h"
19 #include "flutter/shell/platform/windows/testing/mock_platform_view_manager.h"
20 #include "flutter/shell/platform/windows/testing/mock_window_binding_handler.h"
21 #include "flutter/shell/platform/windows/testing/mock_windows_proc_table.h"
22 #include "flutter/shell/platform/windows/testing/test_keyboard.h"
23 #include "flutter/shell/platform/windows/testing/windows_test.h"
24 #include "flutter/shell/platform/windows/testing/windows_test_config_builder.h"
25 #include "flutter/third_party/accessibility/ax/platform/ax_platform_node_win.h"
26 #include "fml/synchronization/waitable_event.h"
27 #include "gmock/gmock.h"
28 #include "gtest/gtest.h"
38 if (::GetMessage(&msg,
nullptr, 0, 0)) {
39 ::TranslateMessage(&msg);
40 ::DispatchMessage(&msg);
49 using ::testing::DoAll;
50 using ::testing::NiceMock;
51 using ::testing::Return;
52 using ::testing::SetArgPointee;
58 FlutterWindowsEngineBuilder builder{GetContext()};
59 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
61 EngineModifier modifier(engine.get());
62 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
64 ASSERT_TRUE(engine->Run());
66 ASSERT_EQ(engine->view(123),
nullptr);
70 bool finished =
false;
71 auto runner = std::make_unique<TaskRunner>(
73 return static_cast<uint64_t
>(
74 fml::TimePoint::Now().ToEpochDelta().ToNanoseconds());
76 [&](
const FlutterTask*) { finished =
true; });
77 runner->PostFlutterTask(
79 static_cast<uint64_t
>((fml::TimePoint::Now().ToEpochDelta() +
80 fml::TimeDelta::FromMilliseconds(50))
82 auto start = fml::TimePoint::Now();
86 auto duration = fml::TimePoint::Now() - start;
87 EXPECT_GE(duration, fml::TimeDelta::FromMilliseconds(50));
92 auto runner = std::make_unique<TaskRunner>(
94 return static_cast<uint64_t
>(
95 fml::TimePoint::Now().ToEpochDelta().ToNanoseconds());
97 [&](
const FlutterTask*) {});
100 void PostTaskLoop() {
101 runner->PostTask([
this] { PostTaskLoop(); });
103 std::unique_ptr<TaskRunner> runner;
106 RunnerHolder container{.runner = std::move(runner)};
108 container.PostTaskLoop();
110 const LPCWSTR class_name = L
"FlutterTestWindowClass";
112 wc.lpfnWndProc = DefWindowProc;
113 wc.lpszClassName = class_name;
117 container.runner->PostTask([&] {
118 window = CreateWindowEx(0, class_name, L
"Empty Window", WS_OVERLAPPEDWINDOW,
119 CW_USEDEFAULT, CW_USEDEFAULT, 800, 600,
nullptr,
120 nullptr,
nullptr,
nullptr);
121 ShowWindow(window, SW_SHOW);
126 if (::GetMessage(&msg,
nullptr, 0, 0)) {
127 if (msg.message == WM_PAINT) {
130 ::TranslateMessage(&msg);
131 ::DispatchMessage(&msg);
135 DestroyWindow(window);
136 UnregisterClassW(class_name,
nullptr);
140 FlutterWindowsEngineBuilder builder{GetContext()};
141 builder.AddDartEntrypointArgument(
"arg1");
142 builder.AddDartEntrypointArgument(
"arg2");
144 auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
146 HMONITOR mock_monitor =
reinterpret_cast<HMONITOR
>(1);
148 MONITORINFOEXW monitor_info = {};
149 monitor_info.cbSize =
sizeof(MONITORINFOEXW);
150 monitor_info.rcMonitor = {0, 0, 1920, 1080};
151 monitor_info.rcWork = {0, 0, 1920, 1080};
152 monitor_info.dwFlags = MONITORINFOF_PRIMARY;
153 wcscpy_s(monitor_info.szDevice, L
"\\\\.\\DISPLAY1");
155 EXPECT_CALL(*windows_proc_table, GetMonitorInfoW(mock_monitor, _))
156 .WillRepeatedly(DoAll(SetArgPointee<1>(monitor_info), Return(TRUE)));
158 EXPECT_CALL(*windows_proc_table, EnumDisplayMonitors(
nullptr,
nullptr, _, _))
159 .WillRepeatedly([&](HDC hdc, LPCRECT lprcClip, MONITORENUMPROC lpfnEnum,
161 lpfnEnum(mock_monitor,
nullptr, &monitor_info.rcMonitor, dwData);
166 .WillRepeatedly(Return(96));
169 EXPECT_CALL(*windows_proc_table, GetThreadPreferredUILanguages(_, _, _, _))
171 [](DWORD flags, PULONG count, PZZWSTR languages, PULONG length) {
175 if (languages ==
nullptr) {
184 wchar_t* lang_buffer = languages;
185 wcscpy(lang_buffer, L
"fr-FR");
187 lang_buffer += wcslen(L
"fr-FR") + 1;
188 *lang_buffer = L
'\0';
193 builder.SetWindowsProcTable(windows_proc_table);
195 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
196 EngineModifier modifier(engine.get());
199 bool run_called =
false;
200 modifier.embedder_api().Run = MOCK_ENGINE_PROC(
201 Run, ([&run_called, engine_instance = engine.get()](
202 size_t version,
const FlutterRendererConfig* config,
203 const FlutterProjectArgs* args,
void*
user_data,
206 *engine_out =
reinterpret_cast<FLUTTER_API_SYMBOL(
FlutterEngine)
>(1);
208 EXPECT_EQ(version, FLUTTER_ENGINE_VERSION);
209 EXPECT_NE(config,
nullptr);
211 EXPECT_EQ(config->type, kOpenGL);
214 EXPECT_NE(args->assets_path,
nullptr);
215 EXPECT_NE(args->icu_data_path,
nullptr);
216 EXPECT_EQ(args->dart_entrypoint_argc, 2U);
217 EXPECT_EQ(strcmp(args->dart_entrypoint_argv[0],
"arg1"), 0);
218 EXPECT_EQ(strcmp(args->dart_entrypoint_argv[1],
"arg2"), 0);
219 EXPECT_NE(args->platform_message_callback,
nullptr);
220 EXPECT_NE(args->custom_task_runners,
nullptr);
221 EXPECT_NE(args->custom_task_runners->thread_priority_setter,
nullptr);
222 EXPECT_EQ(args->custom_dart_entrypoint,
nullptr);
223 EXPECT_NE(args->vsync_callback,
nullptr);
224 EXPECT_EQ(args->update_semantics_callback,
nullptr);
225 EXPECT_NE(args->update_semantics_callback2,
nullptr);
226 EXPECT_EQ(args->update_semantics_node_callback,
nullptr);
227 EXPECT_EQ(args->update_semantics_custom_action_callback,
nullptr);
228 EXPECT_NE(args->view_focus_change_request_callback,
nullptr);
230 args->custom_task_runners->thread_priority_setter(
231 FlutterThreadPriority::kRaster);
232 EXPECT_EQ(GetThreadPriority(GetCurrentThread()),
233 THREAD_PRIORITY_ABOVE_NORMAL);
237 modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
238 UpdateAccessibilityFeatures,
240 FlutterAccessibilityFeature flags) {
return kSuccess; });
243 bool update_locales_called =
false;
244 modifier.embedder_api().UpdateLocales = MOCK_ENGINE_PROC(
246 ([&update_locales_called](
auto engine,
const FlutterLocale** locales,
247 size_t locales_count) {
248 update_locales_called =
true;
250 EXPECT_GT(locales_count, 0);
251 EXPECT_NE(locales,
nullptr);
257 bool settings_message_sent =
false;
258 modifier.embedder_api().SendPlatformMessage = MOCK_ENGINE_PROC(
260 ([&settings_message_sent](
auto engine,
auto message) {
261 if (std::string(
message->channel) == std::string(
"flutter/settings")) {
262 settings_message_sent = true;
269 bool notify_display_update_called =
false;
271 modifier.embedder_api().NotifyDisplayUpdate = MOCK_ENGINE_PROC(
273 ([¬ify_display_update_called](
275 const FlutterEngineDisplaysUpdateType update_type,
276 const FlutterEngineDisplay* embedder_displays,
277 size_t display_count) {
278 EXPECT_EQ(update_type, kFlutterEngineDisplaysUpdateTypeStartup);
279 notify_display_update_called =
true;
284 modifier.SetEGLManager(std::make_unique<egl::MockManager>());
288 EXPECT_TRUE(run_called);
289 EXPECT_TRUE(update_locales_called);
290 EXPECT_TRUE(settings_message_sent);
291 EXPECT_TRUE(notify_display_update_called);
295 modifier.embedder_api().Shutdown = [](
auto engine) {
return kSuccess; };
296 modifier.ReleaseEGLManager();
300 FlutterWindowsEngineBuilder builder{GetContext()};
301 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
302 EngineModifier modifier(engine.get());
303 bool on_vsync_called =
false;
305 modifier.embedder_api().GetCurrentTime =
306 MOCK_ENGINE_PROC(GetCurrentTime, ([]() -> uint64_t {
return 1; }));
307 modifier.embedder_api().OnVsync = MOCK_ENGINE_PROC(
309 ([&on_vsync_called, engine_instance = engine.get()](
311 uint64_t frame_start_time_nanos, uint64_t frame_target_time_nanos) {
313 EXPECT_EQ(frame_start_time_nanos, 16600000);
314 EXPECT_EQ(frame_target_time_nanos, 33200000);
315 on_vsync_called =
true;
318 modifier.SetStartTime(0);
319 modifier.SetFrameInterval(16600000);
323 EXPECT_TRUE(on_vsync_called);
327 FlutterWindowsEngineBuilder builder{GetContext()};
329 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
330 EngineModifier modifier(engine.get());
332 modifier.embedder_api().NotifyDisplayUpdate =
333 MOCK_ENGINE_PROC(NotifyDisplayUpdate,
334 ([engine_instance = engine.get()](
336 const FlutterEngineDisplaysUpdateType update_type,
337 const FlutterEngineDisplay* embedder_displays,
338 size_t display_count) {
return kSuccess; }));
341 bool run_called =
false;
342 modifier.embedder_api().Run = MOCK_ENGINE_PROC(
343 Run, ([&run_called, engine_instance = engine.get()](
344 size_t version,
const FlutterRendererConfig* config,
345 const FlutterProjectArgs* args,
void*
user_data,
348 *engine_out =
reinterpret_cast<FLUTTER_API_SYMBOL(
FlutterEngine)
>(1);
350 EXPECT_EQ(config->type, kSoftware);
354 modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
355 UpdateAccessibilityFeatures,
357 FlutterAccessibilityFeature flags) {
return kSuccess; });
361 modifier.embedder_api().UpdateLocales = MOCK_ENGINE_PROC(
362 UpdateLocales, ([](
auto engine,
const FlutterLocale** locales,
363 size_t locales_count) {
return kSuccess; }));
364 modifier.embedder_api().SendPlatformMessage =
365 MOCK_ENGINE_PROC(SendPlatformMessage,
366 ([](
auto engine,
auto message) {
return kSuccess; }));
369 modifier.SetEGLManager(
nullptr);
373 EXPECT_TRUE(run_called);
377 modifier.embedder_api().Shutdown = [](
auto engine) {
return kSuccess; };
381 FlutterWindowsEngineBuilder builder{GetContext()};
382 builder.SetSwitches({
"--enable-impeller=true"});
383 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
384 EngineModifier modifier(engine.get());
386 modifier.embedder_api().NotifyDisplayUpdate =
387 MOCK_ENGINE_PROC(NotifyDisplayUpdate,
388 ([engine_instance = engine.get()](
390 const FlutterEngineDisplaysUpdateType update_type,
391 const FlutterEngineDisplay* embedder_displays,
392 size_t display_count) {
return kSuccess; }));
395 modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
396 UpdateAccessibilityFeatures,
398 FlutterAccessibilityFeature flags) {
return kSuccess; });
402 modifier.embedder_api().UpdateLocales = MOCK_ENGINE_PROC(
403 UpdateLocales, ([](
auto engine,
const FlutterLocale** locales,
404 size_t locales_count) {
return kSuccess; }));
405 modifier.embedder_api().SendPlatformMessage =
406 MOCK_ENGINE_PROC(SendPlatformMessage,
407 ([](
auto engine,
auto message) {
return kSuccess; }));
410 modifier.SetEGLManager(
nullptr);
412 EXPECT_FALSE(engine->Run());
416 FlutterWindowsEngineBuilder builder{GetContext()};
418 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
419 EngineModifier modifier(engine.get());
421 modifier.embedder_api().NotifyDisplayUpdate =
422 MOCK_ENGINE_PROC(NotifyDisplayUpdate,
423 ([engine_instance = engine.get()](
425 const FlutterEngineDisplaysUpdateType update_type,
426 const FlutterEngineDisplay* embedder_displays,
427 size_t display_count) {
return kSuccess; }));
429 modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
430 UpdateAccessibilityFeatures,
432 FlutterAccessibilityFeature flags) {
return kSuccess; });
434 modifier.embedder_api().UpdateLocales = MOCK_ENGINE_PROC(
435 UpdateLocales, ([](
auto engine,
const FlutterLocale** locales,
436 size_t locales_count) {
return kSuccess; }));
438 modifier.embedder_api().SendPlatformMessage =
439 MOCK_ENGINE_PROC(SendPlatformMessage,
440 ([](
auto engine,
auto message) {
return kSuccess; }));
442 bool run_called =
false;
443 modifier.embedder_api().Run = MOCK_ENGINE_PROC(
444 Run, ([&run_called, engine_instance = engine.get()](
445 size_t version,
const FlutterRendererConfig* config,
446 const FlutterProjectArgs* args,
void*
user_data,
449 *engine_out =
reinterpret_cast<FLUTTER_API_SYMBOL(
FlutterEngine)
>(1);
451 bool has_impeller_switch =
false;
452 bool has_sdf_switch =
false;
453 for (
int i = 0; i < args->command_line_argc; ++i) {
454 if (strcmp(args->command_line_argv[i],
"--enable-impeller") == 0) {
455 has_impeller_switch = true;
457 if (strcmp(args->command_line_argv[i],
"--impeller-use-sdfs=true") ==
459 has_sdf_switch = true;
462 EXPECT_TRUE(has_impeller_switch);
463 EXPECT_TRUE(has_sdf_switch);
468 modifier.SetEGLManager(std::make_unique<egl::MockManager>());
472 EXPECT_TRUE(run_called);
474 modifier.embedder_api().Shutdown = [](
auto engine) {
return kSuccess; };
475 modifier.ReleaseEGLManager();
479 FlutterWindowsEngineBuilder builder{GetContext()};
481 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
482 EngineModifier modifier(engine.get());
484 modifier.embedder_api().NotifyDisplayUpdate =
485 MOCK_ENGINE_PROC(NotifyDisplayUpdate,
487 const FlutterEngineDisplaysUpdateType update_type,
488 const FlutterEngineDisplay* embedder_displays,
489 size_t display_count) {
return kSuccess; }));
491 modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
492 UpdateAccessibilityFeatures,
494 FlutterAccessibilityFeature flags) {
return kSuccess; });
496 modifier.embedder_api().UpdateLocales = MOCK_ENGINE_PROC(
497 UpdateLocales, ([](
auto engine,
const FlutterLocale** locales,
498 size_t locales_count) {
return kSuccess; }));
500 modifier.embedder_api().SendPlatformMessage =
501 MOCK_ENGINE_PROC(SendPlatformMessage,
502 ([](
auto engine,
auto message) {
return kSuccess; }));
504 bool run_called =
false;
505 modifier.embedder_api().Run = MOCK_ENGINE_PROC(
506 Run, ([&run_called](
size_t version,
const FlutterRendererConfig* config,
507 const FlutterProjectArgs* args,
void*
user_data,
510 *engine_out =
reinterpret_cast<FLUTTER_API_SYMBOL(
FlutterEngine)
>(1);
512 bool has_impeller_switch =
false;
513 bool has_sdf_switch =
false;
514 for (
int i = 0; i < args->command_line_argc; ++i) {
515 if (strcmp(args->command_line_argv[i],
"--enable-impeller") == 0) {
516 has_impeller_switch = true;
518 if (strcmp(args->command_line_argv[i],
"--impeller-use-sdfs=true") ==
520 has_sdf_switch = true;
523 EXPECT_TRUE(has_impeller_switch);
524 EXPECT_TRUE(has_sdf_switch);
529 modifier.SetEGLManager(std::make_unique<egl::MockManager>());
533 EXPECT_TRUE(run_called);
535 modifier.embedder_api().Shutdown = [](
auto engine) {
return kSuccess; };
536 modifier.ReleaseEGLManager();
543 std::vector<std::string> RunImpellerWithSurfaceOrigin(
546 EngineModifier modifier(engine);
547 modifier.embedder_api().NotifyDisplayUpdate = MOCK_ENGINE_PROC(
548 NotifyDisplayUpdate, ([](
auto engine,
auto update_type,
auto displays,
549 auto display_count) {
return kSuccess; }));
550 modifier.embedder_api().UpdateAccessibilityFeatures =
551 MOCK_ENGINE_PROC(UpdateAccessibilityFeatures,
552 ([](
auto engine,
auto flags) {
return kSuccess; }));
553 modifier.embedder_api().UpdateLocales = MOCK_ENGINE_PROC(
555 ([](
auto engine,
auto locales,
auto locales_count) {
return kSuccess; }));
556 modifier.embedder_api().SendPlatformMessage =
557 MOCK_ENGINE_PROC(SendPlatformMessage,
558 ([](
auto engine,
auto message) {
return kSuccess; }));
560 std::vector<std::string> switches;
561 modifier.embedder_api().Run = MOCK_ENGINE_PROC(
562 Run, ([&switches](
size_t version,
const FlutterRendererConfig* config,
563 const FlutterProjectArgs* args,
void*
user_data,
564 FLUTTER_API_SYMBOL(FlutterEngine)* engine_out) {
565 *engine_out =
reinterpret_cast<FLUTTER_API_SYMBOL(FlutterEngine)
>(1);
566 switches.assign(args->command_line_argv,
567 args->command_line_argv + args->command_line_argc);
571 auto egl_manager = std::make_unique<NiceMock<egl::MockManager>>();
572 ON_CALL(*egl_manager, surface_origin_is_top_left())
573 .WillByDefault(Return(top_left));
575 ::testing::Mock::AllowLeak(egl_manager.get());
576 modifier.SetEGLManager(std::move(egl_manager));
578 EXPECT_TRUE(engine->
Run());
580 modifier.embedder_api().Shutdown = [](
auto engine) {
return kSuccess; };
581 modifier.ReleaseEGLManager();
585 constexpr
char kTopLeftOriginSwitch[] =
586 "--impeller-top-left-default-framebuffer-origin";
590 RunWithTopLeftSurfaceOriginPassesTopLeftFramebufferSwitch) {
591 FlutterWindowsEngineBuilder builder{GetContext()};
593 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
595 std::vector<std::string> switches =
596 RunImpellerWithSurfaceOrigin(engine.get(),
true);
598 EXPECT_THAT(switches, ::testing::Contains(kTopLeftOriginSwitch));
602 RunWithBottomLeftSurfaceOriginOmitsTopLeftFramebufferSwitch) {
603 FlutterWindowsEngineBuilder builder{GetContext()};
605 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
607 std::vector<std::string> switches =
608 RunImpellerWithSurfaceOrigin(engine.get(),
false);
610 EXPECT_THAT(switches,
611 ::testing::Not(::testing::Contains(kTopLeftOriginSwitch)));
615 FlutterWindowsEngineBuilder builder{GetContext()};
616 builder.SetEnableFlutterGpu(
true);
617 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
618 EngineModifier modifier(engine.get());
620 modifier.embedder_api().NotifyDisplayUpdate =
621 MOCK_ENGINE_PROC(NotifyDisplayUpdate,
623 const FlutterEngineDisplaysUpdateType update_type,
624 const FlutterEngineDisplay* embedder_displays,
625 size_t display_count) {
return kSuccess; }));
627 modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
628 UpdateAccessibilityFeatures,
630 FlutterAccessibilityFeature flags) {
return kSuccess; });
632 modifier.embedder_api().UpdateLocales = MOCK_ENGINE_PROC(
633 UpdateLocales, ([](
auto engine,
const FlutterLocale** locales,
634 size_t locales_count) {
return kSuccess; }));
636 modifier.embedder_api().SendPlatformMessage =
637 MOCK_ENGINE_PROC(SendPlatformMessage,
638 ([](
auto engine,
auto message) {
return kSuccess; }));
640 bool run_called =
false;
641 modifier.embedder_api().Run = MOCK_ENGINE_PROC(
642 Run, ([&run_called](
size_t version,
const FlutterRendererConfig* config,
643 const FlutterProjectArgs* args,
void*
user_data,
646 *engine_out =
reinterpret_cast<FLUTTER_API_SYMBOL(
FlutterEngine)
>(1);
648 bool has_flutter_gpu_switch =
false;
649 for (
int i = 0; i < args->command_line_argc; ++i) {
650 if (strcmp(args->command_line_argv[i],
"--enable-flutter-gpu") == 0) {
651 has_flutter_gpu_switch = true;
654 EXPECT_TRUE(has_flutter_gpu_switch);
659 modifier.SetEGLManager(std::make_unique<egl::MockManager>());
663 EXPECT_TRUE(run_called);
665 modifier.embedder_api().Shutdown = [](
auto engine) {
return kSuccess; };
666 modifier.ReleaseEGLManager();
670 FlutterWindowsEngineBuilder builder{GetContext()};
671 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
672 EngineModifier modifier(engine.get());
674 modifier.embedder_api().NotifyDisplayUpdate =
675 MOCK_ENGINE_PROC(NotifyDisplayUpdate,
677 const FlutterEngineDisplaysUpdateType update_type,
678 const FlutterEngineDisplay* embedder_displays,
679 size_t display_count) {
return kSuccess; }));
681 modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
682 UpdateAccessibilityFeatures,
684 FlutterAccessibilityFeature flags) {
return kSuccess; });
686 modifier.embedder_api().UpdateLocales = MOCK_ENGINE_PROC(
687 UpdateLocales, ([](
auto engine,
const FlutterLocale** locales,
688 size_t locales_count) {
return kSuccess; }));
690 modifier.embedder_api().SendPlatformMessage =
691 MOCK_ENGINE_PROC(SendPlatformMessage,
692 ([](
auto engine,
auto message) {
return kSuccess; }));
694 bool run_called =
false;
695 modifier.embedder_api().Run = MOCK_ENGINE_PROC(
696 Run, ([&run_called](
size_t version,
const FlutterRendererConfig* config,
697 const FlutterProjectArgs* args,
void*
user_data,
700 *engine_out =
reinterpret_cast<FLUTTER_API_SYMBOL(
FlutterEngine)
>(1);
702 bool has_flutter_gpu_switch =
false;
703 for (
int i = 0; i < args->command_line_argc; ++i) {
704 if (strcmp(args->command_line_argv[i],
"--enable-flutter-gpu") == 0) {
705 has_flutter_gpu_switch = true;
708 EXPECT_FALSE(has_flutter_gpu_switch);
713 modifier.SetEGLManager(std::make_unique<egl::MockManager>());
717 EXPECT_TRUE(run_called);
719 modifier.embedder_api().Shutdown = [](
auto engine) {
return kSuccess; };
720 modifier.ReleaseEGLManager();
724 FlutterWindowsEngineBuilder builder{GetContext()};
726 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
727 EngineModifier modifier(engine.get());
729 modifier.embedder_api().NotifyDisplayUpdate =
730 MOCK_ENGINE_PROC(NotifyDisplayUpdate,
732 const FlutterEngineDisplaysUpdateType update_type,
733 const FlutterEngineDisplay* embedder_displays,
734 size_t display_count) {
return kSuccess; }));
736 modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
737 UpdateAccessibilityFeatures,
739 FlutterAccessibilityFeature flags) {
return kSuccess; });
741 modifier.embedder_api().UpdateLocales = MOCK_ENGINE_PROC(
742 UpdateLocales, ([](
auto engine,
const FlutterLocale** locales,
743 size_t locales_count) {
return kSuccess; }));
745 modifier.embedder_api().SendPlatformMessage =
746 MOCK_ENGINE_PROC(SendPlatformMessage,
747 ([](
auto engine,
auto message) {
return kSuccess; }));
749 bool run_called =
false;
750 modifier.embedder_api().Run = MOCK_ENGINE_PROC(
751 Run, ([&run_called](
size_t version,
const FlutterRendererConfig* config,
752 const FlutterProjectArgs* args,
void*
user_data,
755 *engine_out =
reinterpret_cast<FLUTTER_API_SYMBOL(
FlutterEngine)
>(1);
757 bool has_disable_impeller_switch =
false;
758 for (
int i = 0; i < args->command_line_argc; ++i) {
759 if (strcmp(args->command_line_argv[i],
"--enable-impeller=false") ==
761 has_disable_impeller_switch = true;
764 EXPECT_TRUE(has_disable_impeller_switch);
770 EXPECT_TRUE(run_called);
772 modifier.embedder_api().Shutdown = [](
auto engine) {
return kSuccess; };
776 FlutterWindowsEngineBuilder builder{GetContext()};
777 builder.SetSwitches({
"--enable-impeller=false"});
778 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
779 EngineModifier modifier(engine.get());
781 modifier.embedder_api().NotifyDisplayUpdate =
782 MOCK_ENGINE_PROC(NotifyDisplayUpdate,
784 const FlutterEngineDisplaysUpdateType update_type,
785 const FlutterEngineDisplay* embedder_displays,
786 size_t display_count) {
return kSuccess; }));
788 modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
789 UpdateAccessibilityFeatures,
791 FlutterAccessibilityFeature flags) {
return kSuccess; });
793 modifier.embedder_api().UpdateLocales = MOCK_ENGINE_PROC(
794 UpdateLocales, ([](
auto engine,
const FlutterLocale** locales,
795 size_t locales_count) {
return kSuccess; }));
797 modifier.embedder_api().SendPlatformMessage =
798 MOCK_ENGINE_PROC(SendPlatformMessage,
799 ([](
auto engine,
auto message) {
return kSuccess; }));
801 bool run_called =
false;
802 modifier.embedder_api().Run = MOCK_ENGINE_PROC(
803 Run, ([&run_called](
size_t version,
const FlutterRendererConfig* config,
804 const FlutterProjectArgs* args,
void*
user_data,
807 *engine_out =
reinterpret_cast<FLUTTER_API_SYMBOL(
FlutterEngine)
>(1);
809 bool has_disable_impeller_switch =
false;
810 for (
int i = 0; i < args->command_line_argc; ++i) {
811 if (strcmp(args->command_line_argv[i],
"--enable-impeller=false") ==
813 has_disable_impeller_switch = true;
816 EXPECT_TRUE(has_disable_impeller_switch);
822 EXPECT_TRUE(run_called);
824 modifier.embedder_api().Shutdown = [](
auto engine) {
return kSuccess; };
828 FlutterWindowsEngineBuilder builder{GetContext()};
829 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
830 EngineModifier modifier(engine.get());
832 const char* channel =
"test";
833 const std::vector<uint8_t> test_message = {1, 2, 3, 4};
837 modifier.embedder_api().SendPlatformMessage = MOCK_ENGINE_PROC(
838 SendPlatformMessage, ([&called, test_message](
auto engine,
auto message) {
840 EXPECT_STREQ(
message->channel,
"test");
841 EXPECT_EQ(
message->message_size, test_message.size());
842 EXPECT_EQ(memcmp(
message->message, test_message.data(),
845 EXPECT_EQ(
message->response_handle,
nullptr);
849 engine->SendPlatformMessage(channel, test_message.data(), test_message.size(),
855 FlutterWindowsEngineBuilder builder{GetContext()};
856 builder.SetDartEntrypoint(
"hiPlatformChannels");
858 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
859 EngineModifier modifier(engine.get());
860 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
862 auto binary_messenger =
863 std::make_unique<BinaryMessengerImpl>(engine->messenger());
866 bool did_call_callback =
false;
867 bool did_call_reply =
false;
868 bool did_call_dart_reply =
false;
869 std::string channel =
"hi";
870 binary_messenger->SetMessageHandler(
872 [&did_call_callback, &did_call_dart_reply](
874 if (message_size == 5) {
875 EXPECT_EQ(
message[0],
static_cast<uint8_t
>(
'h'));
876 char response[] = {
'b',
'y',
'e'};
877 reply(
reinterpret_cast<uint8_t*
>(response), 3);
878 did_call_callback =
true;
880 EXPECT_EQ(message_size, 3);
881 EXPECT_EQ(
message[0],
static_cast<uint8_t
>(
'b'));
882 did_call_dart_reply =
true;
885 char payload[] = {
'h',
'e',
'l',
'l',
'o'};
886 binary_messenger->Send(
887 channel,
reinterpret_cast<uint8_t*
>(payload), 5,
888 [&did_call_reply](
const uint8_t* reply,
size_t reply_size) {
889 EXPECT_EQ(reply_size, 5);
890 EXPECT_EQ(reply[0],
static_cast<uint8_t
>(
'h'));
891 did_call_reply =
true;
894 while (!did_call_callback || !did_call_reply || !did_call_dart_reply) {
895 engine->task_runner()->ProcessTasks();
900 FlutterWindowsEngineBuilder builder{GetContext()};
901 builder.SetDartEntrypoint(
"hiPlatformChannels");
903 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
905 EngineModifier modifier(engine.get());
906 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
908 auto binary_messenger =
909 std::make_unique<BinaryMessengerImpl>(engine->messenger());
912 bool did_call_callback =
false;
913 bool did_call_reply =
false;
914 bool did_call_dart_reply =
false;
915 std::string channel =
"hi";
916 std::unique_ptr<std::thread> reply_thread;
917 binary_messenger->SetMessageHandler(
919 [&did_call_callback, &did_call_dart_reply, &reply_thread](
921 if (message_size == 5) {
922 EXPECT_EQ(
message[0],
static_cast<uint8_t
>(
'h'));
923 reply_thread.reset(
new std::thread([reply = std::move(reply)]() {
924 char response[] = {
'b',
'y',
'e'};
925 reply(
reinterpret_cast<uint8_t*
>(response), 3);
927 did_call_callback =
true;
929 EXPECT_EQ(message_size, 3);
930 EXPECT_EQ(
message[0],
static_cast<uint8_t
>(
'b'));
931 did_call_dart_reply =
true;
934 char payload[] = {
'h',
'e',
'l',
'l',
'o'};
935 binary_messenger->Send(
936 channel,
reinterpret_cast<uint8_t*
>(payload), 5,
937 [&did_call_reply](
const uint8_t* reply,
size_t reply_size) {
938 EXPECT_EQ(reply_size, 5);
939 EXPECT_EQ(reply[0],
static_cast<uint8_t
>(
'h'));
940 did_call_reply =
true;
943 while (!did_call_callback || !did_call_reply || !did_call_dart_reply) {
944 engine->task_runner()->ProcessTasks();
946 ASSERT_TRUE(reply_thread);
947 reply_thread->join();
951 FlutterWindowsEngineBuilder builder{GetContext()};
952 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
953 EngineModifier modifier(engine.get());
955 const char* channel =
"test";
956 const std::vector<uint8_t> test_message = {1, 2, 3, 4};
957 auto* dummy_response_handle =
958 reinterpret_cast<FlutterPlatformMessageResponseHandle*
>(5);
960 void* reply_user_data =
reinterpret_cast<void*
>(6);
964 bool create_response_handle_called =
false;
965 modifier.embedder_api().PlatformMessageCreateResponseHandle =
967 PlatformMessageCreateResponseHandle,
968 ([&create_response_handle_called, &reply_handler, reply_user_data,
969 dummy_response_handle](
auto engine,
auto reply,
auto user_data,
970 auto response_handle) {
971 create_response_handle_called =
true;
972 EXPECT_EQ(reply, reply_handler);
974 EXPECT_NE(response_handle,
nullptr);
975 *response_handle = dummy_response_handle;
978 bool release_response_handle_called =
false;
979 modifier.embedder_api().PlatformMessageReleaseResponseHandle =
981 PlatformMessageReleaseResponseHandle,
982 ([&release_response_handle_called, dummy_response_handle](
983 auto engine,
auto response_handle) {
984 release_response_handle_called =
true;
985 EXPECT_EQ(response_handle, dummy_response_handle);
988 bool send_message_called =
false;
989 modifier.embedder_api().SendPlatformMessage = MOCK_ENGINE_PROC(
990 SendPlatformMessage, ([&send_message_called, test_message,
991 dummy_response_handle](
auto engine,
auto message) {
992 send_message_called =
true;
993 EXPECT_STREQ(
message->channel,
"test");
994 EXPECT_EQ(
message->message_size, test_message.size());
995 EXPECT_EQ(memcmp(
message->message, test_message.data(),
998 EXPECT_EQ(
message->response_handle, dummy_response_handle);
1002 engine->SendPlatformMessage(channel, test_message.data(), test_message.size(),
1003 reply_handler, reply_user_data);
1004 EXPECT_TRUE(create_response_handle_called);
1005 EXPECT_TRUE(release_response_handle_called);
1006 EXPECT_TRUE(send_message_called);
1010 FlutterWindowsEngineBuilder builder{GetContext()};
1011 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
1012 EngineModifier modifier(engine.get());
1014 bool called =
false;
1015 std::string
message =
"Hello";
1016 modifier.embedder_api().SendSemanticsAction = MOCK_ENGINE_PROC(
1017 SendSemanticsAction, ([&called, &
message](
auto engine,
auto info) {
1019 EXPECT_EQ(info->view_id, 456);
1020 EXPECT_EQ(info->node_id, 42);
1021 EXPECT_EQ(info->action, kFlutterSemanticsActionDismiss);
1022 EXPECT_EQ(memcmp(info->data,
message.c_str(),
message.size()), 0);
1023 EXPECT_EQ(info->data_length,
message.size());
1027 auto data = fml::MallocMapping::Copy(
message.c_str(),
message.size());
1028 engine->DispatchSemanticsAction(456, 42, kFlutterSemanticsActionDismiss,
1030 EXPECT_TRUE(called);
1035 EXPECT_EQ(GetThreadPriority(GetCurrentThread()),
1036 THREAD_PRIORITY_BELOW_NORMAL);
1039 EXPECT_EQ(GetThreadPriority(GetCurrentThread()),
1040 THREAD_PRIORITY_ABOVE_NORMAL);
1043 EXPECT_EQ(GetThreadPriority(GetCurrentThread()),
1044 THREAD_PRIORITY_ABOVE_NORMAL);
1048 SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL);
1051 EXPECT_EQ(GetThreadPriority(GetCurrentThread()), THREAD_PRIORITY_NORMAL);
1055 FlutterWindowsEngineBuilder builder{GetContext()};
1056 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
1057 EngineModifier modifier(engine.get());
1059 MockEmbedderApiForKeyboard(modifier,
1060 std::make_shared<MockKeyResponseController>());
1067 engine->AddPluginRegistrarDestructionCallback(
1069 auto result =
reinterpret_cast<int*
>(ref);
1073 engine->AddPluginRegistrarDestructionCallback(
1075 auto result =
reinterpret_cast<int*
>(ref);
1081 EXPECT_EQ(result1, 1);
1082 EXPECT_EQ(result2, 2);
1086 FlutterWindowsEngineBuilder builder{GetContext()};
1087 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
1088 EngineModifier modifier(engine.get());
1090 bool called =
false;
1091 modifier.embedder_api().ScheduleFrame =
1092 MOCK_ENGINE_PROC(ScheduleFrame, ([&called](
auto engine) {
1097 engine->ScheduleFrame();
1098 EXPECT_TRUE(called);
1102 FlutterWindowsEngineBuilder builder{GetContext()};
1103 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
1104 EngineModifier modifier(engine.get());
1106 bool called =
false;
1107 modifier.embedder_api().SetNextFrameCallback = MOCK_ENGINE_PROC(
1108 SetNextFrameCallback, ([&called](
auto engine,
auto callback,
auto data) {
1113 engine->SetNextFrameCallback([]() {});
1114 EXPECT_TRUE(called);
1118 FlutterWindowsEngineBuilder builder{GetContext()};
1119 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
1120 EXPECT_EQ(engine->GetExecutableName(),
"flutter_windows_unittests.exe");
1126 auto windows_proc_table = std::make_shared<MockWindowsProcTable>();
1127 EXPECT_CALL(*windows_proc_table, GetHighContrastEnabled)
1128 .WillOnce(Return(
true))
1129 .WillOnce(Return(
false));
1131 FlutterWindowsEngineBuilder builder{GetContext()};
1132 builder.SetWindowsProcTable(windows_proc_table);
1133 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
1134 EngineModifier modifier(engine.get());
1136 std::optional<FlutterAccessibilityFeature> engine_flags;
1137 modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
1138 UpdateAccessibilityFeatures, ([&engine_flags](
auto engine,
auto flags) {
1139 engine_flags = flags;
1142 modifier.embedder_api().SendPlatformMessage = MOCK_ENGINE_PROC(
1143 SendPlatformMessage,
1144 [](
auto engine,
const auto message) {
return kSuccess; });
1147 engine->UpdateHighContrastMode();
1149 EXPECT_TRUE(engine->high_contrast_enabled());
1150 EXPECT_TRUE(engine_flags.has_value());
1152 engine_flags.value() &
1153 FlutterAccessibilityFeature::kFlutterAccessibilityFeatureHighContrast);
1156 engine_flags.reset();
1157 engine->UpdateHighContrastMode();
1159 EXPECT_FALSE(engine->high_contrast_enabled());
1160 EXPECT_TRUE(engine_flags.has_value());
1162 engine_flags.value() &
1163 FlutterAccessibilityFeature::kFlutterAccessibilityFeatureHighContrast);
1167 FlutterWindowsEngineBuilder builder{GetContext()};
1168 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
1169 EngineModifier modifier(engine.get());
1171 modifier.embedder_api().PostRenderThreadTask = MOCK_ENGINE_PROC(
1172 PostRenderThreadTask, ([](
auto engine,
auto callback,
auto context) {
1177 bool called =
false;
1178 engine->PostRasterThreadTask([&called]() { called =
true; });
1180 EXPECT_TRUE(called);
1186 std::unique_ptr<WindowBindingHandler> wbh)
1191 BoxConstraints()) {}
1195 NotifyWinEventWrapper,
1196 (ui::AXPlatformNodeWin*, ax::mojom::Event),
1202 FML_DISALLOW_COPY_AND_ASSIGN(MockFlutterWindowsView);
1207 auto& context = GetContext();
1208 WindowsConfigBuilder builder{context};
1209 builder.SetDartEntrypoint(
"sendAccessibilityAnnouncement");
1212 auto native_entry = CREATE_FFI_LAMBDA([&]() { done =
true; });
1213 context.AddFfiNativeFunction(
"Signal", native_entry);
1215 EnginePtr engine{builder.RunHeadless()};
1216 ASSERT_NE(engine,
nullptr);
1218 ui::AXPlatformNodeDelegateBase parent_delegate;
1221 auto window_binding_handler =
1222 std::make_unique<NiceMock<MockWindowBindingHandler>>();
1223 EXPECT_CALL(*window_binding_handler, GetAlertDelegate)
1224 .WillOnce(Return(&delegate));
1227 MockFlutterWindowsView view{windows_engine,
1228 std::move(window_binding_handler)};
1229 EngineModifier modifier{windows_engine};
1230 modifier.SetImplicitView(&view);
1234 EXPECT_CALL(view, NotifyWinEventWrapper).Times(1);
1238 windows_engine->task_runner()->ProcessTasks();
1244 auto& context = GetContext();
1245 WindowsConfigBuilder builder{context};
1246 builder.SetDartEntrypoint(
"sendAccessibilityAnnouncement");
1249 auto native_entry = CREATE_FFI_LAMBDA([&]() { done =
true; });
1250 context.AddFfiNativeFunction(
"Signal", native_entry);
1252 EnginePtr engine{builder.RunHeadless()};
1253 ASSERT_NE(engine,
nullptr);
1260 windows_engine->task_runner()->ProcessTasks();
1267 fml::testing::LogCapture log_capture;
1269 auto& context = GetContext();
1270 WindowsConfigBuilder builder{context};
1271 builder.SetDartEntrypoint(
"sendAccessibilityTooltipEvent");
1274 auto native_entry = CREATE_FFI_LAMBDA([&]() { done =
true; });
1275 context.AddFfiNativeFunction(
"Signal", native_entry);
1277 ViewControllerPtr controller{builder.Run()};
1278 ASSERT_NE(controller,
nullptr);
1286 windows_engine->task_runner()->ProcessTasks();
1292 EXPECT_EQ(log_capture.str().find(
"tooltip"), std::string::npos);
1304 (std::optional<HWND>, std::optional<WPARAM>, std::optional<LPARAM>, UINT),
1321 FlutterWindowsEngineBuilder builder{GetContext()};
1322 builder.SetDartEntrypoint(
"exitTestExit");
1323 bool finished =
false;
1325 auto engine = builder.Build();
1326 auto window_binding_handler =
1327 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1328 MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1330 EngineModifier modifier(engine.get());
1331 modifier.SetImplicitView(&view);
1332 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
1333 auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
1334 EXPECT_CALL(*handler, Quit)
1335 .WillOnce([&finished](std::optional<HWND> hwnd,
1336 std::optional<WPARAM> wparam,
1337 std::optional<LPARAM> lparam,
1338 UINT exit_code) { finished = exit_code == 0; });
1339 EXPECT_CALL(*handler, IsLastWindowOfProcess).WillRepeatedly(Return(
true));
1340 modifier.SetLifecycleManager(std::move(handler));
1357 FlutterWindowsEngineBuilder builder{GetContext()};
1358 builder.SetDartEntrypoint(
"exitTestCancel");
1359 bool did_call =
false;
1361 auto engine = builder.Build();
1362 auto window_binding_handler =
1363 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1364 MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1366 EngineModifier modifier(engine.get());
1367 modifier.SetImplicitView(&view);
1368 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
1369 auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
1370 EXPECT_CALL(*handler, IsLastWindowOfProcess).WillRepeatedly(Return(
true));
1371 EXPECT_CALL(*handler, Quit).Times(0);
1372 modifier.SetLifecycleManager(std::move(handler));
1375 auto binary_messenger =
1376 std::make_unique<BinaryMessengerImpl>(engine->
messenger());
1377 binary_messenger->SetMessageHandler(
1378 "flutter/platform", [&did_call](
const uint8_t*
message,
1381 EXPECT_NE(contents.find(
"\"method\":\"System.exitApplication\""),
1383 EXPECT_NE(contents.find(
"\"type\":\"required\""), std::string::npos);
1384 EXPECT_NE(contents.find(
"\"exitCode\":0"), std::string::npos);
1386 char response[] =
"";
1387 reply(
reinterpret_cast<uint8_t*
>(response), 0);
1404 FlutterWindowsEngineBuilder builder{GetContext()};
1405 builder.SetDartEntrypoint(
"exitTestExit");
1406 bool second_close =
false;
1408 auto engine = builder.Build();
1409 auto window_binding_handler =
1410 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1411 MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1413 EngineModifier modifier(engine.get());
1414 modifier.SetImplicitView(&view);
1415 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
1416 auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
1417 EXPECT_CALL(*handler, IsLastWindowOfProcess).WillOnce(Return(
true));
1418 EXPECT_CALL(*handler, Quit)
1419 .WillOnce([handler_ptr = handler.get()](
1420 std::optional<HWND> hwnd, std::optional<WPARAM> wparam,
1421 std::optional<LPARAM> lparam, UINT exit_code) {
1422 handler_ptr->WindowsLifecycleManager::Quit(hwnd, wparam, lparam,
1425 EXPECT_CALL(*handler, DispatchMessage)
1427 [&engine](HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) {
1429 hwnd, msg, wparam, lparam);
1431 modifier.SetLifecycleManager(std::move(handler));
1445 bool* called =
reinterpret_cast<bool*
>(
user_data);
1452 reinterpret_cast<void*
>(&second_close));
1457 while (!second_close) {
1463 FlutterWindowsEngineBuilder builder{GetContext()};
1464 builder.SetDartEntrypoint(
"exitTestExit");
1465 bool finished =
false;
1467 auto engine = builder.Build();
1468 auto window_binding_handler =
1469 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1470 MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1472 EngineModifier modifier(engine.get());
1473 modifier.SetImplicitView(&view);
1474 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
1475 auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
1476 EXPECT_CALL(*handler, IsLastWindowOfProcess).WillOnce([&finished]() {
1481 EXPECT_CALL(*handler, Quit).Times(0);
1482 modifier.SetLifecycleManager(std::move(handler));
1496 FlutterWindowsEngineBuilder builder{GetContext()};
1498 auto engine = builder.Build();
1499 auto window_binding_handler =
1500 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1501 MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1503 EngineModifier modifier(engine.get());
1504 modifier.SetImplicitView(&view);
1505 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
1506 auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
1507 EXPECT_CALL(*handler, IsLastWindowOfProcess).Times(0);
1508 modifier.SetLifecycleManager(std::move(handler));
1515 FlutterWindowsEngineBuilder builder{GetContext()};
1517 auto engine = builder.Build();
1518 auto window_binding_handler =
1519 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1520 MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1522 EngineModifier modifier(engine.get());
1523 modifier.SetImplicitView(&view);
1524 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
1525 auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
1526 EXPECT_CALL(*handler, IsLastWindowOfProcess).WillOnce(Return(
false));
1527 modifier.SetLifecycleManager(std::move(handler));
1535 FlutterWindowsEngineBuilder builder{GetContext()};
1537 auto engine = builder.Build();
1538 auto window_binding_handler =
1539 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1540 MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1542 EngineModifier modifier(engine.get());
1543 modifier.SetImplicitView(&view);
1544 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
1545 auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
1546 EXPECT_CALL(*handler, IsLastWindowOfProcess).WillOnce(Return(
false));
1547 modifier.SetLifecycleManager(std::move(handler));
1554 FlutterWindowsEngineBuilder builder{GetContext()};
1556 auto engine = builder.Build();
1557 auto window_binding_handler =
1558 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1559 MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1561 EngineModifier modifier(engine.get());
1562 modifier.SetImplicitView(&view);
1563 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
1567 (HWND)1, WM_SIZE, SIZE_RESTORED, 0);
1587 (HWND)1, WM_SIZE, SIZE_MINIMIZED, 0);
1597 (HWND)1, WM_SIZE, SIZE_RESTORED, 0);
1608 FlutterWindowsEngineBuilder builder{GetContext()};
1610 auto engine = builder.Build();
1611 auto window_binding_handler =
1612 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1613 MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1615 EngineModifier modifier(engine.get());
1616 modifier.SetImplicitView(&view);
1617 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
1636 FlutterWindowsEngineBuilder builder{GetContext()};
1637 HWND outer =
reinterpret_cast<HWND
>(1);
1638 HWND inner =
reinterpret_cast<HWND
>(2);
1640 auto engine = builder.Build();
1641 auto window_binding_handler =
1642 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1643 MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1644 ON_CALL(view, GetWindowHandle).WillByDefault([=]() {
return inner; });
1646 EngineModifier modifier(engine.get());
1647 modifier.SetImplicitView(&view);
1648 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
1654 outer, WM_SHOWWINDOW, TRUE, NULL);
1678 FlutterWindowsEngineBuilder builder{GetContext()};
1679 builder.SetDartEntrypoint(
"enableLifecycleTest");
1680 bool finished =
false;
1682 auto engine = builder.Build();
1683 auto window_binding_handler =
1684 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1685 MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1687 EngineModifier modifier(engine.get());
1688 modifier.SetImplicitView(&view);
1689 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
1690 auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
1691 EXPECT_CALL(*handler, SetLifecycleState)
1693 handler_ptr->WindowsLifecycleManager::SetLifecycleState(state);
1695 modifier.SetLifecycleManager(std::move(handler));
1697 auto binary_messenger =
1698 std::make_unique<BinaryMessengerImpl>(engine->
messenger());
1700 binary_messenger->SetMessageHandler(
1701 "flutter/unittest", [&finished](
const uint8_t*
message,
1704 EXPECT_NE(contents.find(
"AppLifecycleState.inactive"),
1707 char response[] =
"";
1708 reply(
reinterpret_cast<uint8_t*
>(response), 0);
1714 HWND hwnd =
reinterpret_cast<HWND
>(1);
1717 EXPECT_FALSE(finished);
1730 FlutterWindowsEngineBuilder builder{GetContext()};
1731 builder.SetDartEntrypoint(
"enableLifecycleToFrom");
1732 bool enabled_lifecycle =
false;
1733 bool dart_responded =
false;
1735 auto engine = builder.Build();
1736 auto window_binding_handler =
1737 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1738 MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1740 EngineModifier modifier(engine.get());
1741 modifier.SetImplicitView(&view);
1742 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
1743 auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
1744 EXPECT_CALL(*handler, SetLifecycleState)
1746 handler_ptr->WindowsLifecycleManager::SetLifecycleState(state);
1748 handler->begin_processing_callback = [&]() { enabled_lifecycle =
true; };
1749 modifier.SetLifecycleManager(std::move(handler));
1751 auto binary_messenger =
1752 std::make_unique<BinaryMessengerImpl>(engine->
messenger());
1753 binary_messenger->SetMessageHandler(
1757 EXPECT_NE(contents.find(
"AppLifecycleState."), std::string::npos);
1758 dart_responded =
true;
1759 char response[] =
"";
1760 reply(
reinterpret_cast<uint8_t*
>(response), 0);
1765 while (!enabled_lifecycle) {
1769 HWND hwnd =
reinterpret_cast<HWND
>(1);
1773 while (!dart_responded) {
1779 FlutterWindowsEngineBuilder builder{GetContext()};
1780 builder.SetDartEntrypoint(
"enableLifecycleToFrom");
1782 auto engine = builder.Build();
1783 auto window_binding_handler =
1784 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1785 MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1787 EngineModifier modifier(engine.get());
1788 modifier.SetImplicitView(&view);
1789 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
1791 bool lifecycle_began =
false;
1792 auto handler = std::make_unique<MockWindowsLifecycleManager>(engine.get());
1793 handler->begin_processing_callback = [&]() { lifecycle_began =
true; };
1794 modifier.SetLifecycleManager(std::move(handler));
1798 while (!lifecycle_began) {
1804 FlutterWindowsEngineBuilder builder{GetContext()};
1805 builder.SetDartEntrypoint(
"sendCreatePlatformViewMethod");
1806 auto engine = builder.Build();
1808 EngineModifier modifier{engine.get()};
1809 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
1811 bool received_call =
false;
1813 auto manager = std::make_unique<MockPlatformViewManager>(engine.get());
1814 EXPECT_CALL(*manager, AddPlatformView)
1816 received_call =
true;
1819 modifier.SetPlatformViewPlugin(std::move(manager));
1823 while (!received_call) {
1829 FlutterWindowsEngineBuilder builder{GetContext()};
1830 auto engine = builder.Build();
1832 EngineModifier modifier{engine.get()};
1834 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
1835 modifier.embedder_api().AddView = MOCK_ENGINE_PROC(
1838 const FlutterAddViewInfo* info) {
return kInternalInconsistency; });
1840 ASSERT_TRUE(engine->
Run());
1844 auto implicit_window = std::make_unique<NiceMock<MockWindowBindingHandler>>();
1846 std::unique_ptr<FlutterWindowsView> implicit_view =
1847 engine->CreateView(std::move(implicit_window),
1848 false, BoxConstraints(),
1851 EXPECT_TRUE(implicit_view);
1854 auto second_window = std::make_unique<NiceMock<MockWindowBindingHandler>>();
1857 engine->CreateView(std::move(second_window),
1858 false, BoxConstraints(),
1860 "FlutterEngineAddView returned an unexpected result");
1864 FlutterWindowsEngineBuilder builder{GetContext()};
1865 builder.SetDartEntrypoint(
"sendCreatePlatformViewMethod");
1866 auto engine = builder.Build();
1868 EngineModifier modifier{engine.get()};
1870 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
1871 modifier.embedder_api().
RemoveView = MOCK_ENGINE_PROC(
1874 const FlutterRemoveViewInfo* info) {
return kInternalInconsistency; });
1876 ASSERT_TRUE(engine->
Run());
1877 EXPECT_DEBUG_DEATH(engine->RemoveView(123),
1878 "FlutterEngineRemoveView returned an unexpected result");
1882 auto& context = GetContext();
1883 WindowsConfigBuilder builder{context};
1884 builder.SetDartEntrypoint(
"mergedUIThread");
1887 std::optional<std::thread::id> ui_thread_id;
1890 CREATE_FFI_LAMBDA([&]() { ui_thread_id = std::this_thread::get_id(); });
1891 context.AddFfiNativeFunction(
"Signal", native_entry);
1893 EnginePtr engine{builder.RunHeadless()};
1894 while (!ui_thread_id) {
1897 ASSERT_EQ(*ui_thread_id, std::this_thread::get_id());
1901 FlutterWindowsEngineBuilder builder{GetContext()};
1902 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
1903 auto window_binding_handler =
1904 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1905 MockFlutterWindowsView view(engine.get(), std::move(window_binding_handler));
1907 EngineModifier modifier(engine.get());
1908 modifier.SetImplicitView(&view);
1910 FlutterViewFocusChangeRequest request;
1913 EXPECT_CALL(view, Focus()).WillOnce(Return(
true));
1914 modifier.OnViewFocusChangeRequest(&request);
1918 auto& context = GetContext();
1919 WindowsConfigBuilder builder{context};
1920 builder.SetDartEntrypoint(
"sendSemanticsTreeInfo");
1924 auto native_entry = CREATE_FFI_LAMBDA([&]() { done =
true; });
1925 context.AddFfiNativeFunction(
"Signal", native_entry);
1928 EnginePtr engine{builder.RunHeadless()};
1929 ASSERT_NE(engine,
nullptr);
1931 auto window_binding_handler1 =
1932 std::make_unique<NiceMock<MockWindowBindingHandler>>();
1933 auto window_binding_handler2 =
1934 std::make_unique<NiceMock<MockWindowBindingHandler>>();
1939 EXPECT_CALL(*window_binding_handler1, GetPhysicalWindowBounds)
1941 EXPECT_CALL(*window_binding_handler1, GetDpiScale)
1942 .WillRepeatedly(testing::Return(96.0));
1943 EXPECT_CALL(*window_binding_handler2, GetPhysicalWindowBounds)
1945 EXPECT_CALL(*window_binding_handler2, GetDpiScale)
1946 .WillRepeatedly(testing::Return(96.0));
1949 EngineModifier modifier{windows_engine};
1950 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
1955 auto view1 = windows_engine->
CreateView(std::move(window_binding_handler1),
1959 auto view2 = windows_engine->CreateView(std::move(window_binding_handler2),
1966 windows_engine->UpdateSemanticsEnabled(
true);
1969 windows_engine->task_runner()->ProcessTasks();
1972 auto accessibility_bridge1 = view1->accessibility_bridge().lock();
1973 auto accessibility_bridge2 = view2->accessibility_bridge().lock();
1978 !accessibility_bridge1->GetPlatformNodeFromTree(view1->view_id() + 1)) {
1979 windows_engine->task_runner()->ProcessTasks();
1983 !accessibility_bridge2->GetPlatformNodeFromTree(view2->view_id() + 1)) {
1984 windows_engine->task_runner()->ProcessTasks();
1988 auto tree1 = accessibility_bridge1->GetTree();
1989 auto tree2 = accessibility_bridge2->GetTree();
1990 EXPECT_NE(tree1->GetFromId(view1->view_id() + 1),
nullptr);
1991 EXPECT_NE(tree2->GetFromId(view2->view_id() + 1),
nullptr);
TaskRunner * task_runner()
FlutterDesktopMessengerRef messenger()
WindowsLifecycleManager * lifecycle_manager()
WindowProcDelegateManager * window_proc_delegate_manager()
std::optional< LRESULT > ProcessExternalWindowMessage(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
void UpdateSemanticsEnabled(bool enabled)
std::unique_ptr< FlutterWindowsView > CreateView(std::unique_ptr< WindowBindingHandler > window, bool is_sized_to_content, const BoxConstraints &box_constraints, bool allow_implicit_view, FlutterWindowsViewSizingDelegate *sizing_delegate=nullptr)
virtual void RemoveView(FlutterViewId view_id)
std::chrono::nanoseconds ProcessTasks()
std::optional< LRESULT > OnTopLevelWindowProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) const
void RegisterTopLevelWindowProcDelegate(FlutterDesktopWindowProcCallback callback, void *user_data)
virtual void OnWindowStateEvent(HWND hwnd, WindowStateEvent event)
bool IsUpdateStateScheduled() const
std::optional< LRESULT > ExternalWindowMessage(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
AppLifecycleState GetLifecycleState()
virtual void Quit(std::optional< HWND > window, std::optional< WPARAM > wparam, std::optional< LPARAM > lparam, UINT exit_code)
virtual void BeginProcessingLifecycle()
virtual void DispatchMessage(HWND window, UINT msg, WPARAM wparam, LPARAM lparam)
virtual bool IsLastWindowOfProcess()
virtual void SetLifecycleState(AppLifecycleState state)
virtual void BeginProcessingExit()
~MockFlutterWindowsView()
MOCK_METHOD(bool, Focus,(),(override))
MOCK_METHOD(void, NotifyWinEventWrapper,(ui::AXPlatformNodeWin *, ax::mojom::Event),(override))
MockFlutterWindowsView(FlutterWindowsEngine *engine, std::unique_ptr< WindowBindingHandler > wbh)
MOCK_METHOD(HWND, GetWindowHandle,(),(const, override))
virtual ~MockWindowsLifecycleManager()
std::function< void()> begin_processing_callback
MOCK_METHOD(void, DispatchMessage,(HWND, UINT, WPARAM, LPARAM),(override))
MOCK_METHOD(void, Quit,(std::optional< HWND >, std::optional< WPARAM >, std::optional< LPARAM >, UINT),(override))
MOCK_METHOD(void, SetLifecycleState,(AppLifecycleState),(override))
void BeginProcessingLifecycle() override
MOCK_METHOD(bool, IsLastWindowOfProcess,(),(override))
MockWindowsLifecycleManager(FlutterWindowsEngine *engine)
std::vector< FlutterEngineDisplay > * displays
void(* FlutterDesktopBinaryReply)(const uint8_t *data, size_t data_size, void *user_data)
FlutterDesktopEngineRef FlutterDesktopViewControllerGetEngine(FlutterDesktopViewControllerRef ref)
FlutterDesktopBinaryReply callback
TEST_F(AccessibilityPluginTest, DirectAnnounceCall)
UINT GetDpiForMonitor(HMONITOR monitor)
std::function< void(const uint8_t *reply, size_t reply_size)> BinaryReply
static void WindowsPlatformThreadPrioritySetter(FlutterThreadPriority priority)
constexpr FlutterViewId kImplicitViewId