7 #include "flutter/fml/macros.h"
8 #include "flutter/shell/platform/embedder/embedder.h"
9 #include "flutter/shell/platform/embedder/test_utils/proc_table_replacement.h"
12 #include "flutter/shell/platform/windows/testing/engine_modifier.h"
13 #include "flutter/shell/platform/windows/testing/flutter_windows_engine_builder.h"
14 #include "flutter/shell/platform/windows/testing/mock_window_binding_handler.h"
15 #include "flutter/shell/platform/windows/testing/test_keyboard.h"
16 #include "flutter/shell/platform/windows/testing/windows_test.h"
17 #include "flutter/third_party/accessibility/ax/platform/ax_platform_node_win.h"
18 #include "fml/synchronization/waitable_event.h"
19 #include "gmock/gmock.h"
20 #include "gtest/gtest.h"
31 FlutterWindowsEngineBuilder builder{GetContext()};
32 builder.AddDartEntrypointArgument(
"arg1");
33 builder.AddDartEntrypointArgument(
"arg2");
35 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
36 EngineModifier modifier(engine.get());
39 bool run_called =
false;
40 modifier.embedder_api().Run = MOCK_ENGINE_PROC(
41 Run, ([&run_called, engine_instance = engine.get()](
42 size_t version,
const FlutterRendererConfig* config,
43 const FlutterProjectArgs* args,
void*
user_data,
46 *engine_out =
reinterpret_cast<FLUTTER_API_SYMBOL(
FlutterEngine)
>(1);
48 EXPECT_EQ(version, FLUTTER_ENGINE_VERSION);
49 EXPECT_NE(config,
nullptr);
51 EXPECT_EQ(config->type, kOpenGL);
54 EXPECT_NE(args->assets_path,
nullptr);
55 EXPECT_NE(args->icu_data_path,
nullptr);
56 EXPECT_EQ(args->dart_entrypoint_argc, 2U);
57 EXPECT_EQ(strcmp(args->dart_entrypoint_argv[0],
"arg1"), 0);
58 EXPECT_EQ(strcmp(args->dart_entrypoint_argv[1],
"arg2"), 0);
59 EXPECT_NE(args->platform_message_callback,
nullptr);
60 EXPECT_NE(args->custom_task_runners,
nullptr);
61 EXPECT_NE(args->custom_task_runners->thread_priority_setter,
nullptr);
62 EXPECT_EQ(args->custom_dart_entrypoint,
nullptr);
63 EXPECT_NE(args->vsync_callback,
nullptr);
64 EXPECT_EQ(args->update_semantics_callback,
nullptr);
65 EXPECT_NE(args->update_semantics_callback2,
nullptr);
66 EXPECT_EQ(args->update_semantics_node_callback,
nullptr);
67 EXPECT_EQ(args->update_semantics_custom_action_callback,
nullptr);
69 args->custom_task_runners->thread_priority_setter(
70 FlutterThreadPriority::kRaster);
71 EXPECT_EQ(GetThreadPriority(GetCurrentThread()),
72 THREAD_PRIORITY_ABOVE_NORMAL);
76 modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
77 UpdateAccessibilityFeatures,
79 FlutterAccessibilityFeature flags) {
return kSuccess; });
82 bool update_locales_called =
false;
83 modifier.embedder_api().UpdateLocales = MOCK_ENGINE_PROC(
85 ([&update_locales_called](
auto engine,
const FlutterLocale** locales,
86 size_t locales_count) {
87 update_locales_called =
true;
89 EXPECT_GT(locales_count, 0);
90 EXPECT_NE(locales,
nullptr);
96 bool settings_message_sent =
false;
97 modifier.embedder_api().SendPlatformMessage = MOCK_ENGINE_PROC(
99 ([&settings_message_sent](
auto engine,
auto message) {
100 if (std::string(
message->channel) == std::string(
"flutter/settings")) {
101 settings_message_sent = true;
108 bool notify_display_update_called =
false;
109 modifier.SetFrameInterval(16600000);
110 modifier.embedder_api().NotifyDisplayUpdate = MOCK_ENGINE_PROC(
112 ([¬ify_display_update_called, engine_instance = engine.get()](
114 const FlutterEngineDisplaysUpdateType update_type,
115 const FlutterEngineDisplay* embedder_displays,
116 size_t display_count) {
117 EXPECT_EQ(update_type, kFlutterEngineDisplaysUpdateTypeStartup);
118 EXPECT_EQ(display_count, 1);
120 FlutterEngineDisplay display = embedder_displays[0];
122 EXPECT_EQ(display.display_id, 0);
123 EXPECT_EQ(display.single_display,
true);
124 EXPECT_EQ(std::floor(display.refresh_rate), 60.0);
126 notify_display_update_called =
true;
135 EXPECT_TRUE(run_called);
136 EXPECT_TRUE(update_locales_called);
137 EXPECT_TRUE(settings_message_sent);
138 EXPECT_TRUE(notify_display_update_called);
142 modifier.embedder_api().Shutdown = [](
auto engine) {
return kSuccess; };
143 modifier.ReleaseSurfaceManager();
147 FlutterWindowsEngineBuilder builder{GetContext()};
148 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
149 EngineModifier modifier(engine.get());
150 bool on_vsync_called =
false;
152 modifier.embedder_api().GetCurrentTime =
153 MOCK_ENGINE_PROC(GetCurrentTime, ([]() -> uint64_t {
return 1; }));
154 modifier.embedder_api().OnVsync = MOCK_ENGINE_PROC(
156 ([&on_vsync_called, engine_instance = engine.get()](
158 uint64_t frame_start_time_nanos, uint64_t frame_target_time_nanos) {
160 EXPECT_EQ(frame_start_time_nanos, 16600000);
161 EXPECT_EQ(frame_target_time_nanos, 33200000);
162 on_vsync_called =
true;
165 modifier.SetStartTime(0);
166 modifier.SetFrameInterval(16600000);
170 EXPECT_TRUE(on_vsync_called);
174 FlutterWindowsEngineBuilder builder{GetContext()};
175 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
176 EngineModifier modifier(engine.get());
178 modifier.embedder_api().NotifyDisplayUpdate =
179 MOCK_ENGINE_PROC(NotifyDisplayUpdate,
180 ([engine_instance = engine.get()](
182 const FlutterEngineDisplaysUpdateType update_type,
183 const FlutterEngineDisplay* embedder_displays,
184 size_t display_count) {
return kSuccess; }));
187 bool run_called =
false;
188 modifier.embedder_api().Run = MOCK_ENGINE_PROC(
189 Run, ([&run_called, engine_instance = engine.get()](
190 size_t version,
const FlutterRendererConfig* config,
191 const FlutterProjectArgs* args,
void*
user_data,
194 *engine_out =
reinterpret_cast<FLUTTER_API_SYMBOL(
FlutterEngine)
>(1);
196 EXPECT_EQ(config->type, kSoftware);
200 modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
201 UpdateAccessibilityFeatures,
203 FlutterAccessibilityFeature flags) {
return kSuccess; });
207 modifier.embedder_api().UpdateLocales = MOCK_ENGINE_PROC(
208 UpdateLocales, ([](
auto engine,
const FlutterLocale** locales,
209 size_t locales_count) {
return kSuccess; }));
210 modifier.embedder_api().SendPlatformMessage =
211 MOCK_ENGINE_PROC(SendPlatformMessage,
212 ([](
auto engine,
auto message) {
return kSuccess; }));
215 modifier.SetSurfaceManager(
nullptr);
219 EXPECT_TRUE(run_called);
223 modifier.embedder_api().Shutdown = [](
auto engine) {
return kSuccess; };
227 FlutterWindowsEngineBuilder builder{GetContext()};
228 builder.SetSwitches({
"--enable-impeller=true"});
229 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
230 EngineModifier modifier(engine.get());
232 modifier.embedder_api().NotifyDisplayUpdate =
233 MOCK_ENGINE_PROC(NotifyDisplayUpdate,
234 ([engine_instance = engine.get()](
236 const FlutterEngineDisplaysUpdateType update_type,
237 const FlutterEngineDisplay* embedder_displays,
238 size_t display_count) {
return kSuccess; }));
241 modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
242 UpdateAccessibilityFeatures,
244 FlutterAccessibilityFeature flags) {
return kSuccess; });
248 modifier.embedder_api().UpdateLocales = MOCK_ENGINE_PROC(
249 UpdateLocales, ([](
auto engine,
const FlutterLocale** locales,
250 size_t locales_count) {
return kSuccess; }));
251 modifier.embedder_api().SendPlatformMessage =
252 MOCK_ENGINE_PROC(SendPlatformMessage,
253 ([](
auto engine,
auto message) {
return kSuccess; }));
256 modifier.SetSurfaceManager(
nullptr);
258 EXPECT_FALSE(engine->
Run());
262 FlutterWindowsEngineBuilder builder{GetContext()};
263 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
264 EngineModifier modifier(engine.get());
266 const char* channel =
"test";
267 const std::vector<uint8_t> test_message = {1, 2, 3, 4};
271 modifier.embedder_api().SendPlatformMessage = MOCK_ENGINE_PROC(
272 SendPlatformMessage, ([&called, test_message](
auto engine,
auto message) {
274 EXPECT_STREQ(
message->channel,
"test");
275 EXPECT_EQ(
message->message_size, test_message.size());
276 EXPECT_EQ(memcmp(
message->message, test_message.data(),
279 EXPECT_EQ(
message->response_handle,
nullptr);
283 engine->SendPlatformMessage(channel, test_message.data(), test_message.size(),
289 FlutterWindowsEngineBuilder builder{GetContext()};
290 builder.SetDartEntrypoint(
"hiPlatformChannels");
292 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
293 EngineModifier modifier(engine.get());
294 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
296 auto binary_messenger =
297 std::make_unique<BinaryMessengerImpl>(engine->messenger());
300 bool did_call_callback =
false;
301 bool did_call_reply =
false;
302 bool did_call_dart_reply =
false;
303 std::string channel =
"hi";
304 binary_messenger->SetMessageHandler(
306 [&did_call_callback, &did_call_dart_reply](
308 if (message_size == 5) {
309 EXPECT_EQ(
message[0],
static_cast<uint8_t
>(
'h'));
310 char response[] = {
'b',
'y',
'e'};
311 reply(
reinterpret_cast<uint8_t*
>(response), 3);
312 did_call_callback =
true;
314 EXPECT_EQ(message_size, 3);
315 EXPECT_EQ(
message[0],
static_cast<uint8_t
>(
'b'));
316 did_call_dart_reply =
true;
319 char payload[] = {
'h',
'e',
'l',
'l',
'o'};
320 binary_messenger->Send(
321 channel,
reinterpret_cast<uint8_t*
>(payload), 5,
322 [&did_call_reply](
const uint8_t* reply,
size_t reply_size) {
323 EXPECT_EQ(reply_size, 5);
324 EXPECT_EQ(reply[0],
static_cast<uint8_t
>(
'h'));
325 did_call_reply =
true;
328 while (!did_call_callback || !did_call_reply || !did_call_dart_reply) {
329 engine->task_runner()->ProcessTasks();
334 FlutterWindowsEngineBuilder builder{GetContext()};
335 builder.SetDartEntrypoint(
"hiPlatformChannels");
337 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
339 EngineModifier modifier(engine.get());
340 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
342 auto binary_messenger =
343 std::make_unique<BinaryMessengerImpl>(engine->messenger());
346 bool did_call_callback =
false;
347 bool did_call_reply =
false;
348 bool did_call_dart_reply =
false;
349 std::string channel =
"hi";
350 std::unique_ptr<std::thread> reply_thread;
351 binary_messenger->SetMessageHandler(
353 [&did_call_callback, &did_call_dart_reply, &reply_thread](
355 if (message_size == 5) {
356 EXPECT_EQ(
message[0],
static_cast<uint8_t
>(
'h'));
357 reply_thread.reset(
new std::thread([reply = std::move(reply)]() {
358 char response[] = {
'b',
'y',
'e'};
359 reply(
reinterpret_cast<uint8_t*
>(response), 3);
361 did_call_callback =
true;
363 EXPECT_EQ(message_size, 3);
364 EXPECT_EQ(
message[0],
static_cast<uint8_t
>(
'b'));
365 did_call_dart_reply =
true;
368 char payload[] = {
'h',
'e',
'l',
'l',
'o'};
369 binary_messenger->Send(
370 channel,
reinterpret_cast<uint8_t*
>(payload), 5,
371 [&did_call_reply](
const uint8_t* reply,
size_t reply_size) {
372 EXPECT_EQ(reply_size, 5);
373 EXPECT_EQ(reply[0],
static_cast<uint8_t
>(
'h'));
374 did_call_reply =
true;
377 while (!did_call_callback || !did_call_reply || !did_call_dart_reply) {
378 engine->task_runner()->ProcessTasks();
380 ASSERT_TRUE(reply_thread);
381 reply_thread->join();
385 FlutterWindowsEngineBuilder builder{GetContext()};
386 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
387 EngineModifier modifier(engine.get());
389 const char* channel =
"test";
390 const std::vector<uint8_t> test_message = {1, 2, 3, 4};
391 auto* dummy_response_handle =
392 reinterpret_cast<FlutterPlatformMessageResponseHandle*
>(5);
394 void* reply_user_data =
reinterpret_cast<void*
>(6);
398 bool create_response_handle_called =
false;
399 modifier.embedder_api().PlatformMessageCreateResponseHandle =
401 PlatformMessageCreateResponseHandle,
402 ([&create_response_handle_called, &reply_handler, reply_user_data,
403 dummy_response_handle](
auto engine,
auto reply,
auto user_data,
404 auto response_handle) {
405 create_response_handle_called =
true;
406 EXPECT_EQ(reply, reply_handler);
408 EXPECT_NE(response_handle,
nullptr);
409 *response_handle = dummy_response_handle;
412 bool release_response_handle_called =
false;
413 modifier.embedder_api().PlatformMessageReleaseResponseHandle =
415 PlatformMessageReleaseResponseHandle,
416 ([&release_response_handle_called, dummy_response_handle](
417 auto engine,
auto response_handle) {
418 release_response_handle_called =
true;
419 EXPECT_EQ(response_handle, dummy_response_handle);
422 bool send_message_called =
false;
423 modifier.embedder_api().SendPlatformMessage = MOCK_ENGINE_PROC(
424 SendPlatformMessage, ([&send_message_called, test_message,
425 dummy_response_handle](
auto engine,
auto message) {
426 send_message_called =
true;
427 EXPECT_STREQ(
message->channel,
"test");
428 EXPECT_EQ(
message->message_size, test_message.size());
429 EXPECT_EQ(memcmp(
message->message, test_message.data(),
432 EXPECT_EQ(
message->response_handle, dummy_response_handle);
436 engine->SendPlatformMessage(channel, test_message.data(), test_message.size(),
437 reply_handler, reply_user_data);
438 EXPECT_TRUE(create_response_handle_called);
439 EXPECT_TRUE(release_response_handle_called);
440 EXPECT_TRUE(send_message_called);
444 FlutterWindowsEngineBuilder builder{GetContext()};
445 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
446 EngineModifier modifier(engine.get());
450 modifier.embedder_api().DispatchSemanticsAction = MOCK_ENGINE_PROC(
451 DispatchSemanticsAction,
452 ([&called, &
message](
auto engine,
auto target,
auto action,
auto data,
455 EXPECT_EQ(target, 42);
456 EXPECT_EQ(
action, kFlutterSemanticsActionDismiss);
458 EXPECT_EQ(data_length,
message.size());
462 auto data = fml::MallocMapping::Copy(
message.c_str(),
message.size());
463 engine->DispatchSemanticsAction(42, kFlutterSemanticsActionDismiss,
470 EXPECT_EQ(GetThreadPriority(GetCurrentThread()),
471 THREAD_PRIORITY_BELOW_NORMAL);
474 EXPECT_EQ(GetThreadPriority(GetCurrentThread()),
475 THREAD_PRIORITY_ABOVE_NORMAL);
478 EXPECT_EQ(GetThreadPriority(GetCurrentThread()),
479 THREAD_PRIORITY_ABOVE_NORMAL);
483 SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL);
486 EXPECT_EQ(GetThreadPriority(GetCurrentThread()), THREAD_PRIORITY_NORMAL);
490 FlutterWindowsEngineBuilder builder{GetContext()};
491 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
492 EngineModifier modifier(engine.get());
494 MockEmbedderApiForKeyboard(modifier,
495 std::make_shared<MockKeyResponseController>());
502 engine->AddPluginRegistrarDestructionCallback(
504 auto result =
reinterpret_cast<int*
>(ref);
508 engine->AddPluginRegistrarDestructionCallback(
510 auto result =
reinterpret_cast<int*
>(ref);
516 EXPECT_EQ(result1, 1);
517 EXPECT_EQ(result2, 2);
521 FlutterWindowsEngineBuilder builder{GetContext()};
522 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
523 EngineModifier modifier(engine.get());
526 modifier.embedder_api().ScheduleFrame =
527 MOCK_ENGINE_PROC(ScheduleFrame, ([&called](
auto engine) {
532 engine->ScheduleFrame();
537 FlutterWindowsEngineBuilder builder{GetContext()};
538 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
539 EngineModifier modifier(engine.get());
542 modifier.embedder_api().SetNextFrameCallback = MOCK_ENGINE_PROC(
543 SetNextFrameCallback, ([&called](
auto engine,
auto callback,
auto data) {
548 engine->SetNextFrameCallback([]() {});
553 FlutterWindowsEngineBuilder builder{GetContext()};
554 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
555 EXPECT_EQ(engine->GetExecutableName(),
"flutter_windows_unittests.exe");
561 FlutterWindowsEngineBuilder builder{GetContext()};
562 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
563 EngineModifier modifier(engine.get());
566 modifier.embedder_api().UpdateAccessibilityFeatures = MOCK_ENGINE_PROC(
567 UpdateAccessibilityFeatures, ([&called](
auto engine,
auto flags) {
572 engine->UpdateHighContrastEnabled(
true);
574 engine->EnabledAccessibilityFeatures() &
575 FlutterAccessibilityFeature::kFlutterAccessibilityFeatureHighContrast);
576 EXPECT_TRUE(engine->high_contrast_enabled());
579 engine->UpdateHighContrastEnabled(
false);
581 engine->EnabledAccessibilityFeatures() &
582 FlutterAccessibilityFeature::kFlutterAccessibilityFeatureHighContrast);
583 EXPECT_FALSE(engine->high_contrast_enabled());
587 FlutterWindowsEngineBuilder builder{GetContext()};
588 std::unique_ptr<FlutterWindowsEngine> engine = builder.Build();
589 EngineModifier modifier(engine.get());
591 modifier.embedder_api().PostRenderThreadTask = MOCK_ENGINE_PROC(
592 PostRenderThreadTask, ([](
auto engine,
auto callback,
auto context) {
598 engine->PostRasterThreadTask([&called]() { called =
true; });
610 NotifyWinEventWrapper,
611 (ui::AXPlatformNodeWin*, ax::mojom::Event),
613 MOCK_METHOD(
PlatformWindow, GetPlatformWindow, (), (
const,
override));
616 FML_DISALLOW_COPY_AND_ASSIGN(MockFlutterWindowsView);
620 FlutterWindowsEngineBuilder builder{GetContext()};
621 builder.SetDartEntrypoint(
"alertPlatformChannel");
623 auto window_binding_handler =
624 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
625 ui::AXPlatformNodeDelegateBase parent_delegate;
627 ON_CALL(*window_binding_handler, GetAlertDelegate).WillByDefault([&delegate] {
630 MockFlutterWindowsView view(std::move(window_binding_handler));
631 view.SetEngine(builder.Build());
634 EngineModifier modifier(engine);
635 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
637 auto binary_messenger =
638 std::make_unique<BinaryMessengerImpl>(engine->
messenger());
639 binary_messenger->SetMessageHandler(
640 "semantics", [&engine](
const uint8_t*
message,
size_t message_size,
643 char response[] =
"";
644 reply(
reinterpret_cast<uint8_t*
>(response), 0);
647 bool did_call =
false;
648 ON_CALL(view, NotifyWinEventWrapper)
649 .WillByDefault([&did_call](ui::AXPlatformNodeWin* node,
650 ax::mojom::Event event) { did_call =
true; });
670 (std::optional<HWND>, std::optional<WPARAM>, std::optional<LPARAM>, UINT),
687 FlutterWindowsEngineBuilder builder{GetContext()};
688 builder.SetDartEntrypoint(
"exitTestExit");
689 bool finished =
false;
691 auto window_binding_handler =
692 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
693 MockFlutterWindowsView view(std::move(window_binding_handler));
694 view.SetEngine(builder.Build());
697 EngineModifier modifier(engine);
698 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
699 auto handler = std::make_unique<MockWindowsLifecycleManager>(engine);
700 ON_CALL(*handler, Quit)
702 [&finished](std::optional<HWND> hwnd, std::optional<WPARAM> wparam,
703 std::optional<LPARAM> lparam,
704 UINT exit_code) { finished = exit_code == 0; });
705 ON_CALL(*handler, IsLastWindowOfProcess).WillByDefault([]() {
return true; });
706 EXPECT_CALL(*handler, Quit).Times(1);
707 modifier.SetLifecycleManager(std::move(handler));
724 FlutterWindowsEngineBuilder builder{GetContext()};
725 builder.SetDartEntrypoint(
"exitTestCancel");
726 bool finished =
false;
727 bool did_call =
false;
729 auto window_binding_handler =
730 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
731 MockFlutterWindowsView view(std::move(window_binding_handler));
732 view.SetEngine(builder.Build());
735 EngineModifier modifier(engine);
736 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
737 auto handler = std::make_unique<MockWindowsLifecycleManager>(engine);
738 ON_CALL(*handler, Quit)
739 .WillByDefault([&finished](std::optional<HWND> hwnd,
740 std::optional<WPARAM> wparam,
741 std::optional<LPARAM> lparam,
742 UINT exit_code) { finished =
true; });
743 ON_CALL(*handler, IsLastWindowOfProcess).WillByDefault([]() {
return true; });
744 EXPECT_CALL(*handler, Quit).Times(0);
745 modifier.SetLifecycleManager(std::move(handler));
748 auto binary_messenger =
749 std::make_unique<BinaryMessengerImpl>(engine->
messenger());
750 binary_messenger->SetMessageHandler(
751 "flutter/platform", [&did_call](
const uint8_t*
message,
754 EXPECT_NE(contents.find(
"\"method\":\"System.exitApplication\""),
756 EXPECT_NE(contents.find(
"\"type\":\"required\""), std::string::npos);
757 EXPECT_NE(contents.find(
"\"exitCode\":0"), std::string::npos);
759 char response[] =
"";
760 reply(
reinterpret_cast<uint8_t*
>(response), 0);
772 EXPECT_FALSE(finished);
776 FlutterWindowsEngineBuilder builder{GetContext()};
777 builder.SetDartEntrypoint(
"exitTestExit");
778 bool second_close =
false;
780 auto window_binding_handler =
781 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
782 MockFlutterWindowsView view(std::move(window_binding_handler));
783 view.SetEngine(builder.Build());
786 EngineModifier modifier(engine);
787 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
788 auto handler = std::make_unique<MockWindowsLifecycleManager>(engine);
789 auto& handler_obj = *handler;
790 ON_CALL(handler_obj, IsLastWindowOfProcess).WillByDefault([]() {
793 ON_CALL(handler_obj, Quit)
795 [&handler_obj](std::optional<HWND> hwnd, std::optional<WPARAM> wparam,
796 std::optional<LPARAM> lparam, UINT exit_code) {
797 handler_obj.WindowsLifecycleManager::Quit(hwnd, wparam, lparam,
800 ON_CALL(handler_obj, DispatchMessage)
802 [&engine](HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) {
804 hwnd, msg, wparam, lparam);
806 modifier.SetLifecycleManager(std::move(handler));
820 bool* called =
reinterpret_cast<bool*
>(
user_data);
827 reinterpret_cast<void*
>(&second_close));
832 while (!second_close) {
838 FlutterWindowsEngineBuilder builder{GetContext()};
839 builder.SetDartEntrypoint(
"exitTestExit");
840 bool finished =
false;
842 auto window_binding_handler =
843 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
844 MockFlutterWindowsView view(std::move(window_binding_handler));
845 view.SetEngine(builder.Build());
848 EngineModifier modifier(engine);
849 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
850 auto handler = std::make_unique<MockWindowsLifecycleManager>(engine);
851 ON_CALL(*handler, IsLastWindowOfProcess).WillByDefault([&finished]() {
856 EXPECT_CALL(*handler, Quit).Times(0);
857 modifier.SetLifecycleManager(std::move(handler));
871 FlutterWindowsEngineBuilder builder{GetContext()};
873 auto window_binding_handler =
874 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
875 MockFlutterWindowsView view(std::move(window_binding_handler));
876 view.SetEngine(builder.Build());
879 EngineModifier modifier(engine);
880 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
881 auto handler = std::make_unique<MockWindowsLifecycleManager>(engine);
882 EXPECT_CALL(*handler, IsLastWindowOfProcess).Times(0);
883 modifier.SetLifecycleManager(std::move(handler));
890 FlutterWindowsEngineBuilder builder{GetContext()};
892 auto window_binding_handler =
893 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
894 MockFlutterWindowsView view(std::move(window_binding_handler));
895 view.SetEngine(builder.Build());
898 EngineModifier modifier(engine);
899 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
900 auto handler = std::make_unique<MockWindowsLifecycleManager>(engine);
901 ON_CALL(*handler, IsLastWindowOfProcess).WillByDefault([]() {
904 EXPECT_CALL(*handler, IsLastWindowOfProcess).Times(1);
905 modifier.SetLifecycleManager(std::move(handler));
913 FlutterWindowsEngineBuilder builder{GetContext()};
915 auto window_binding_handler =
916 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
917 MockFlutterWindowsView view(std::move(window_binding_handler));
918 view.SetEngine(builder.Build());
921 EngineModifier modifier(engine);
922 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
923 auto handler = std::make_unique<MockWindowsLifecycleManager>(engine);
924 ON_CALL(*handler, IsLastWindowOfProcess).WillByDefault([]() {
927 EXPECT_CALL(*handler, IsLastWindowOfProcess).Times(1);
928 modifier.SetLifecycleManager(std::move(handler));
935 FlutterWindowsEngineBuilder builder{GetContext()};
937 auto window_binding_handler =
938 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
939 MockFlutterWindowsView view(std::move(window_binding_handler));
940 view.SetEngine(builder.Build());
943 EngineModifier modifier(engine);
944 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
945 auto handler = std::make_unique<MockWindowsLifecycleManager>(engine);
948 modifier.SetLifecycleManager(std::move(handler));
953 FlutterWindowsEngineBuilder builder{GetContext()};
955 auto window_binding_handler =
956 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
957 MockFlutterWindowsView view(std::move(window_binding_handler));
958 view.SetEngine(builder.Build());
961 EngineModifier modifier(engine);
962 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
966 (HWND)1, WM_SIZE, SIZE_RESTORED, 0);
971 (HWND)1, WM_SIZE, SIZE_MINIMIZED, 0);
976 (HWND)1, WM_SIZE, SIZE_RESTORED, 0);
982 FlutterWindowsEngineBuilder builder{GetContext()};
984 auto window_binding_handler =
985 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
986 MockFlutterWindowsView view(std::move(window_binding_handler));
987 view.SetEngine(builder.Build());
990 EngineModifier modifier(engine);
991 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
1006 FlutterWindowsEngineBuilder builder{GetContext()};
1007 HWND outer =
reinterpret_cast<HWND
>(1);
1008 HWND inner =
reinterpret_cast<HWND
>(2);
1010 auto window_binding_handler =
1011 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1012 MockFlutterWindowsView view(std::move(window_binding_handler));
1013 ON_CALL(view, GetPlatformWindow).WillByDefault([=]() {
return inner; });
1014 view.SetEngine(builder.Build());
1017 EngineModifier modifier(engine);
1018 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
1024 outer, WM_SHOWWINDOW, TRUE, NULL);
1040 FlutterWindowsEngineBuilder builder{GetContext()};
1041 builder.SetDartEntrypoint(
"enableLifecycleTest");
1042 bool finished =
false;
1044 auto window_binding_handler =
1045 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1046 MockFlutterWindowsView view(std::move(window_binding_handler));
1047 view.SetEngine(builder.Build());
1050 EngineModifier modifier(engine);
1051 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
1052 auto handler = std::make_unique<MockWindowsLifecycleManager>(engine);
1053 ON_CALL(*handler, SetLifecycleState)
1055 handler_ptr->WindowsLifecycleManager::SetLifecycleState(state);
1057 modifier.SetLifecycleManager(std::move(handler));
1059 auto binary_messenger =
1060 std::make_unique<BinaryMessengerImpl>(engine->
messenger());
1062 binary_messenger->SetMessageHandler(
1063 "flutter/unittest", [&finished](
const uint8_t*
message,
1066 EXPECT_NE(contents.find(
"AppLifecycleState.inactive"),
1069 char response[] =
"";
1070 reply(
reinterpret_cast<uint8_t*
>(response), 0);
1076 HWND hwnd =
reinterpret_cast<HWND
>(1);
1079 EXPECT_FALSE(finished);
1092 FlutterWindowsEngineBuilder builder{GetContext()};
1093 builder.SetDartEntrypoint(
"enableLifecycleToFrom");
1094 bool enabled_lifecycle =
false;
1095 bool dart_responded =
false;
1097 auto window_binding_handler =
1098 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1099 MockFlutterWindowsView view(std::move(window_binding_handler));
1100 view.SetEngine(builder.Build());
1103 EngineModifier modifier(engine);
1104 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
1105 auto handler = std::make_unique<MockWindowsLifecycleManager>(engine);
1106 ON_CALL(*handler, SetLifecycleState)
1108 handler_ptr->WindowsLifecycleManager::SetLifecycleState(state);
1110 handler->begin_processing_callback = [&]() { enabled_lifecycle =
true; };
1111 modifier.SetLifecycleManager(std::move(handler));
1113 auto binary_messenger =
1114 std::make_unique<BinaryMessengerImpl>(engine->
messenger());
1115 binary_messenger->SetMessageHandler(
1119 EXPECT_NE(contents.find(
"AppLifecycleState."), std::string::npos);
1120 dart_responded =
true;
1121 char response[] =
"";
1122 reply(
reinterpret_cast<uint8_t*
>(response), 0);
1127 while (!enabled_lifecycle) {
1131 HWND hwnd =
reinterpret_cast<HWND
>(1);
1135 while (!dart_responded) {
1141 FlutterWindowsEngineBuilder builder{GetContext()};
1142 builder.SetDartEntrypoint(
"enableLifecycleToFrom");
1144 auto window_binding_handler =
1145 std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>();
1146 MockFlutterWindowsView view(std::move(window_binding_handler));
1147 view.SetEngine(builder.Build());
1149 EngineModifier modifier(engine);
1150 modifier.embedder_api().RunsAOTCompiledDartCode = []() {
return false; };
1152 bool lifecycle_began =
false;
1153 auto handler = std::make_unique<MockWindowsLifecycleManager>(engine);
1154 handler->begin_processing_callback = [&]() { lifecycle_began =
true; };
1155 modifier.SetLifecycleManager(std::move(handler));
1159 while (!lifecycle_began) {