8 #include <wrl/client.h>
11 #include "flutter/fml/synchronization/count_down_latch.h"
12 #include "flutter/fml/synchronization/waitable_event.h"
14 #include "flutter/shell/platform/embedder/test_utils/proc_table_replacement.h"
17 #include "flutter/shell/platform/windows/testing/engine_modifier.h"
18 #include "flutter/shell/platform/windows/testing/mock_window_binding_handler.h"
19 #include "flutter/shell/platform/windows/testing/windows_test.h"
20 #include "flutter/shell/platform/windows/testing/windows_test_config_builder.h"
21 #include "flutter/shell/platform/windows/testing/windows_test_context.h"
23 #include "flutter/testing/stream_capture.h"
24 #include "gmock/gmock.h"
25 #include "gtest/gtest.h"
26 #include "third_party/tonic/converter/dart_converter.h"
34 class HalfBrokenEGLManager :
public egl::Manager {
36 HalfBrokenEGLManager()
40 std::unique_ptr<egl::WindowSurface>
41 CreateWindowSurface(HWND hwnd,
size_t width,
size_t height)
override {
46 class MockWindowsLifecycleManager :
public WindowsLifecycleManager {
58 if (::GetMessage(&msg,
nullptr, 0, 0)) {
59 ::TranslateMessage(&msg);
60 ::DispatchMessage(&msg);
68 TEST(WindowsNoFixtureTest, GetTextureRegistrar) {
74 ASSERT_NE(engine,
nullptr);
76 EXPECT_NE(texture_registrar,
nullptr);
82 auto& context = GetContext();
83 WindowsConfigBuilder builder(context);
84 ViewControllerPtr controller{builder.Run()};
85 ASSERT_NE(controller,
nullptr);
89 TEST_F(WindowsTest, LaunchMainHasNoOutput) {
92 StreamCapture stderr_capture(&std::cerr);
94 auto& context = GetContext();
95 WindowsConfigBuilder builder(context);
96 ViewControllerPtr controller{builder.Run()};
97 ASSERT_NE(controller,
nullptr);
99 stderr_capture.Stop();
102 EXPECT_TRUE(stderr_capture.GetOutput().empty());
106 TEST_F(WindowsTest, LaunchCustomEntrypoint) {
107 auto& context = GetContext();
108 WindowsConfigBuilder builder(context);
109 builder.SetDartEntrypoint(
"customEntrypoint");
110 ViewControllerPtr controller{builder.Run()};
111 ASSERT_NE(controller,
nullptr);
119 TEST_F(WindowsTest, LaunchCustomEntrypointInEngineRunInvocation) {
120 auto& context = GetContext();
121 WindowsConfigBuilder builder(context);
122 EnginePtr engine{builder.InitializeEngine()};
123 ASSERT_NE(engine,
nullptr);
129 TEST_F(WindowsTest, LaunchHeadlessEngine) {
130 auto& context = GetContext();
131 WindowsConfigBuilder builder(context);
132 builder.SetDartEntrypoint(
"signalViewIds");
133 EnginePtr engine{builder.RunHeadless()};
134 ASSERT_NE(engine,
nullptr);
136 std::string view_ids;
137 bool signaled =
false;
138 context.AddFfiNativeFunction(
139 "SignalStringValue", CREATE_FFI_LAMBDA([&](Dart_Handle handle) {
140 ASSERT_FALSE(Dart_IsError(handle));
141 view_ids = tonic::DartConverter<std::string>::FromDart(handle);
145 ViewControllerPtr controller{builder.Run()};
146 ASSERT_NE(controller,
nullptr);
153 EXPECT_EQ(view_ids,
"View IDs: [0]");
157 TEST_F(WindowsTest, EngineCanTransitionToHeadless) {
158 auto& context = GetContext();
159 WindowsConfigBuilder builder(context);
160 EnginePtr engine{builder.RunHeadless()};
161 ASSERT_NE(engine,
nullptr);
167 ViewControllerPtr controller{
170 ASSERT_NE(controller,
nullptr);
174 ASSERT_NE(engine,
nullptr);
177 ASSERT_TRUE(engine_ptr->running());
181 TEST_F(WindowsTest, LaunchRefreshesAccessibility) {
182 auto& context = GetContext();
183 WindowsConfigBuilder builder(context);
184 EnginePtr engine{builder.InitializeEngine()};
185 EngineModifier modifier{
190 UpdateAccessibilityFeatures, ([&called](
auto engine,
auto flags) {
195 ViewControllerPtr controller{
206 TEST_F(WindowsTest, LaunchConflictingCustomEntrypoints) {
207 auto& context = GetContext();
208 WindowsConfigBuilder builder(context);
209 builder.SetDartEntrypoint(
"customEntrypoint");
210 EnginePtr engine{builder.InitializeEngine()};
211 ASSERT_NE(engine,
nullptr);
217 TEST_F(WindowsTest, VerifyNativeFunction) {
218 auto& context = GetContext();
219 WindowsConfigBuilder builder(context);
220 builder.SetDartEntrypoint(
"verifyNativeFunction");
222 bool signaled =
false;
223 auto native_entry = CREATE_FFI_LAMBDA([&]() { signaled =
true; });
224 context.AddFfiNativeFunction(
"Signal", native_entry);
226 ViewControllerPtr controller{builder.Run()};
227 ASSERT_NE(controller,
nullptr);
237 TEST_F(WindowsTest, VerifyNativeFunctionWithParameters) {
238 auto& context = GetContext();
239 WindowsConfigBuilder builder(context);
240 builder.SetDartEntrypoint(
"verifyNativeFunctionWithParameters");
242 bool bool_value =
false;
243 bool signaled =
false;
244 auto native_entry = CREATE_FFI_LAMBDA([&](
bool value) {
248 context.AddFfiNativeFunction(
"SignalBoolValue", native_entry);
250 ViewControllerPtr controller{builder.Run()};
251 ASSERT_NE(controller,
nullptr);
257 EXPECT_TRUE(bool_value);
261 TEST_F(WindowsTest, PlatformExecutable) {
262 auto& context = GetContext();
263 WindowsConfigBuilder builder(context);
264 builder.SetDartEntrypoint(
"readPlatformExecutable");
266 std::string executable_name;
267 bool signaled =
false;
268 auto native_entry = CREATE_FFI_LAMBDA([&](Dart_Handle handle) {
269 ASSERT_FALSE(Dart_IsError(handle));
270 executable_name = tonic::DartConverter<std::string>::FromDart(handle);
273 context.AddFfiNativeFunction(
"SignalStringValue", native_entry);
275 ViewControllerPtr controller{builder.Run()};
276 ASSERT_NE(controller,
nullptr);
282 EXPECT_EQ(executable_name,
"flutter_windows_unittests.exe");
287 TEST_F(WindowsTest, VerifyNativeFunctionWithReturn) {
288 auto& context = GetContext();
289 WindowsConfigBuilder builder(context);
290 builder.SetDartEntrypoint(
"verifyNativeFunctionWithReturn");
292 bool bool_value_to_return =
true;
294 auto bool_return_entry = CREATE_FFI_LAMBDA([&]() {
296 return bool_value_to_return;
298 context.AddFfiNativeFunction(
"SignalBoolReturn", bool_return_entry);
300 bool bool_value_passed =
false;
301 auto bool_pass_entry = CREATE_FFI_LAMBDA([&](
bool value) {
302 bool_value_passed = value;
305 context.AddFfiNativeFunction(
"SignalBoolValue", bool_pass_entry);
307 ViewControllerPtr controller{builder.Run()};
308 ASSERT_NE(controller,
nullptr);
314 EXPECT_TRUE(bool_value_passed);
320 fml::AutoResetWaitableEvent frame_scheduled_latch;
321 std::thread::id thread_id;
326 auto platform_thread = std::make_unique<fml::Thread>(
"test_platform_thread");
327 platform_thread->GetTaskRunner()->PostTask([&]() {
328 captures.thread_id = std::this_thread::get_id();
330 auto& context = GetContext();
331 WindowsConfigBuilder builder(context);
332 builder.SetDartEntrypoint(
"drawHelloWorld");
335 CREATE_FFI_LAMBDA([&]() { captures.frame_scheduled_latch.Signal(); });
336 context.AddFfiNativeFunction(
"NotifyFirstFrameScheduled", native_entry);
338 ViewControllerPtr controller{builder.Run()};
339 EXPECT_NE(controller,
nullptr);
346 auto captures =
static_cast<Captures*
>(
user_data);
348 EXPECT_TRUE(captures->frame_scheduled_latch.IsSignaledForTest());
351 EXPECT_EQ(std::this_thread::get_id(), captures->thread_id);
354 captures->done =
true;
359 while (!captures.done) {
365 platform_thread->Join();
371 auto& context = GetContext();
372 WindowsConfigBuilder builder(context);
373 builder.SetDartEntrypoint(
"renderImplicitView");
375 EnginePtr engine{builder.RunHeadless()};
376 ASSERT_NE(engine,
nullptr);
383 auto done = reinterpret_cast<std::atomic<bool>*>(user_data);
392 FlutterWindowMetricsEvent metrics = {};
393 metrics.struct_size =
sizeof(FlutterWindowMetricsEvent);
395 metrics.height = 100;
396 metrics.pixel_ratio = 1.0;
398 engine_ptr->SendWindowMetricsEvent(metrics);
408 auto& context = GetContext();
409 WindowsConfigBuilder builder(context);
411 EnginePtr engine{builder.RunHeadless()};
412 ASSERT_NE(engine,
nullptr);
418 TEST_F(WindowsTest, IsNotPlatformThread) {
419 auto& context = GetContext();
420 WindowsConfigBuilder builder(context);
422 EnginePtr engine{builder.RunHeadless()};
423 ASSERT_NE(engine,
nullptr);
426 std::thread background(
430 EXPECT_FALSE(result);
435 TEST_F(WindowsTest, PostPlatformThreadTaskFromPlatformThread) {
436 auto& context = GetContext();
437 WindowsConfigBuilder builder(context);
439 EnginePtr engine{builder.RunHeadless()};
440 ASSERT_NE(engine,
nullptr);
443 std::thread::id thread_id;
450 auto captures = static_cast<Captures*>(user_data);
451 captures->thread_id = std::this_thread::get_id();
452 captures->done = true;
456 while (!captures.done) {
460 EXPECT_EQ(captures.thread_id, std::this_thread::get_id());
465 TEST_F(WindowsTest, PostPlatformThreadTaskFromBackgroundThread) {
466 auto& context = GetContext();
467 WindowsConfigBuilder builder(context);
469 EnginePtr engine{builder.RunHeadless()};
470 ASSERT_NE(engine,
nullptr);
472 std::mutex background_thread_id_mutex;
474 std::thread::id background_thread_id;
475 std::thread::id platform_thread_id;
479 std::thread background([&]() {
481 std::scoped_lock lock{background_thread_id_mutex};
482 captures.background_thread_id = std::this_thread::get_id();
488 auto captures = static_cast<Captures*>(user_data);
489 captures->platform_thread_id = std::this_thread::get_id();
490 captures->done = true;
496 while (!captures.done) {
500 std::scoped_lock lock{background_thread_id_mutex};
501 EXPECT_NE(captures.background_thread_id, std::thread::id{});
502 EXPECT_NE(captures.background_thread_id, captures.platform_thread_id);
503 EXPECT_EQ(captures.platform_thread_id, std::this_thread::get_id());
508 TEST_F(WindowsTest, PostPlatformThreadTaskCancelledOnEngineDestroy) {
509 auto& context = GetContext();
510 WindowsConfigBuilder builder(context);
512 EnginePtr engine{builder.RunHeadless()};
513 ASSERT_NE(engine,
nullptr);
516 bool callback_called =
false;
517 bool cancel_called =
false;
523 static_cast<Captures*>(user_data)->callback_called = true;
526 static_cast<Captures*>(user_data)->cancel_called = true;
534 EXPECT_FALSE(captures.callback_called);
535 EXPECT_TRUE(captures.cancel_called);
539 TEST_F(WindowsTest, PostPlatformThreadTaskNotCancelledWhenRun) {
540 auto& context = GetContext();
541 WindowsConfigBuilder builder(context);
543 EnginePtr engine{builder.RunHeadless()};
544 ASSERT_NE(engine,
nullptr);
547 bool callback_called =
false;
548 bool cancel_called =
false;
554 static_cast<Captures*>(user_data)->callback_called = true;
557 static_cast<Captures*>(user_data)->cancel_called = true;
561 EXPECT_FALSE(captures.cancel_called);
563 while (!captures.callback_called) {
571 EXPECT_TRUE(captures.callback_called);
572 EXPECT_FALSE(captures.cancel_called);
577 auto& context = GetContext();
578 WindowsConfigBuilder builder(context);
579 ViewControllerPtr controller{builder.Run()};
580 ASSERT_NE(controller,
nullptr);
587 TEST_F(WindowsTest, GetGraphicsAdapter) {
588 auto& context = GetContext();
589 WindowsConfigBuilder builder(context);
590 ViewControllerPtr controller{builder.Run()};
591 ASSERT_NE(controller,
nullptr);
594 Microsoft::WRL::ComPtr<IDXGIAdapter> dxgi_adapter;
596 ASSERT_NE(dxgi_adapter,
nullptr);
597 DXGI_ADAPTER_DESC desc{};
598 ASSERT_TRUE(SUCCEEDED(dxgi_adapter->GetDesc(&desc)));
601 TEST_F(WindowsTest, GetEngineGraphicsAdapter) {
602 auto& context = GetContext();
603 WindowsConfigBuilder builder(context);
604 ViewControllerPtr controller{builder.Run()};
605 ASSERT_NE(controller,
nullptr);
609 IDXGIAdapter* dxgi_adapter;
611 ASSERT_NE(dxgi_adapter,
nullptr);
612 DXGI_ADAPTER_DESC desc{};
613 ASSERT_TRUE(SUCCEEDED(dxgi_adapter->GetDesc(&desc)));
616 TEST_F(WindowsTest, GetGraphicsAdapterWithLowPowerPreference) {
619 GTEST_SKIP() <<
"Not able to find low power GPU, nothing to check.";
622 auto& context = GetContext();
623 WindowsConfigBuilder builder(context);
625 ViewControllerPtr controller{builder.Run()};
626 ASSERT_NE(controller,
nullptr);
629 Microsoft::WRL::ComPtr<IDXGIAdapter> dxgi_adapter;
631 ASSERT_NE(dxgi_adapter,
nullptr);
632 DXGI_ADAPTER_DESC desc{};
633 ASSERT_TRUE(SUCCEEDED(dxgi_adapter->GetDesc(&desc)));
634 ASSERT_EQ(desc.AdapterLuid.HighPart, luid->HighPart);
635 ASSERT_EQ(desc.AdapterLuid.LowPart, luid->LowPart);
638 TEST_F(WindowsTest, GetGraphicsAdapterWithHighPerformancePreference) {
641 GTEST_SKIP() <<
"Not able to find high performance GPU, nothing to check.";
644 auto& context = GetContext();
645 WindowsConfigBuilder builder(context);
646 builder.SetGpuPreference(
648 ViewControllerPtr controller{builder.Run()};
649 ASSERT_NE(controller,
nullptr);
652 Microsoft::WRL::ComPtr<IDXGIAdapter> dxgi_adapter;
654 ASSERT_NE(dxgi_adapter,
nullptr);
655 DXGI_ADAPTER_DESC desc{};
656 ASSERT_TRUE(SUCCEEDED(dxgi_adapter->GetDesc(&desc)));
657 ASSERT_EQ(desc.AdapterLuid.HighPart, luid->HighPart);
658 ASSERT_EQ(desc.AdapterLuid.LowPart, luid->LowPart);
661 TEST_F(WindowsTest, GetEngineGraphicsAdapterWithLowPowerPreference) {
664 GTEST_SKIP() <<
"Not able to find low power GPU, nothing to check.";
667 auto& context = GetContext();
668 WindowsConfigBuilder builder(context);
670 ViewControllerPtr controller{builder.Run()};
671 ASSERT_NE(controller,
nullptr);
675 IDXGIAdapter* dxgi_adapter;
677 ASSERT_NE(dxgi_adapter,
nullptr);
678 DXGI_ADAPTER_DESC desc{};
679 ASSERT_TRUE(SUCCEEDED(dxgi_adapter->GetDesc(&desc)));
680 ASSERT_EQ(desc.AdapterLuid.HighPart, luid->HighPart);
681 ASSERT_EQ(desc.AdapterLuid.LowPart, luid->LowPart);
684 TEST_F(WindowsTest, GetEngineGraphicsAdapterWithHighPerformancePreference) {
687 GTEST_SKIP() <<
"Not able to find high performance GPU, nothing to check.";
690 auto& context = GetContext();
691 WindowsConfigBuilder builder(context);
692 builder.SetGpuPreference(
694 ViewControllerPtr controller{builder.Run()};
695 ASSERT_NE(controller,
nullptr);
699 IDXGIAdapter* dxgi_adapter;
701 ASSERT_NE(dxgi_adapter,
nullptr);
702 DXGI_ADAPTER_DESC desc{};
703 ASSERT_TRUE(SUCCEEDED(dxgi_adapter->GetDesc(&desc)));
704 ASSERT_EQ(desc.AdapterLuid.HighPart, luid->HighPart);
705 ASSERT_EQ(desc.AdapterLuid.LowPart, luid->LowPart);
709 TEST_F(WindowsTest, PluginRegistrarGetImplicitView) {
710 auto& context = GetContext();
711 WindowsConfigBuilder builder(context);
712 ViewControllerPtr controller{builder.Run()};
713 ASSERT_NE(controller,
nullptr);
722 ASSERT_NE(implicit_view,
nullptr);
725 TEST_F(WindowsTest, PluginRegistrarGetView) {
726 auto& context = GetContext();
727 WindowsConfigBuilder builder(context);
728 ViewControllerPtr controller{builder.Run()};
729 ASSERT_NE(controller,
nullptr);
744 ASSERT_NE(view,
nullptr);
745 ASSERT_EQ(view_123,
nullptr);
748 TEST_F(WindowsTest, PluginRegistrarGetViewHeadless) {
749 auto& context = GetContext();
750 WindowsConfigBuilder builder(context);
751 EnginePtr engine{builder.RunHeadless()};
752 ASSERT_NE(engine,
nullptr);
762 ASSERT_EQ(implicit_view,
nullptr);
763 ASSERT_EQ(view_123,
nullptr);
769 auto& context = GetContext();
770 WindowsConfigBuilder builder(context);
771 EnginePtr engine{builder.InitializeEngine()};
772 EngineModifier modifier{
775 auto egl_manager = std::make_unique<HalfBrokenEGLManager>();
776 ASSERT_TRUE(egl_manager->IsValid());
777 modifier.SetEGLManager(std::move(egl_manager));
779 ViewControllerPtr controller{
782 ASSERT_NE(controller,
nullptr);
787 auto& context = GetContext();
788 WindowsConfigBuilder builder(context);
789 EnginePtr engine{builder.InitializeEngine()};
791 EngineModifier modifier{windows_engine};
793 auto lifecycle_manager =
794 std::make_unique<MockWindowsLifecycleManager>(windows_engine);
795 auto lifecycle_manager_ptr = lifecycle_manager.get();
796 modifier.SetLifecycleManager(std::move(lifecycle_manager));
798 EXPECT_CALL(*lifecycle_manager_ptr,
801 lifecycle_manager_ptr->WindowsLifecycleManager::SetLifecycleState(
805 EXPECT_CALL(*lifecycle_manager_ptr,
808 lifecycle_manager_ptr->WindowsLifecycleManager::SetLifecycleState(
816 ViewControllerPtr controller{
821 ASSERT_NE(view,
nullptr);
824 ASSERT_NE(hwnd,
nullptr);
829 ::MoveWindow(hwnd, 0, 0, 100, 100,
832 while (lifecycle_manager_ptr->IsUpdateStateScheduled()) {
839 while (lifecycle_manager_ptr->IsUpdateStateScheduled()) {
844 TEST_F(WindowsTest, GetKeyboardStateHeadless) {
845 auto& context = GetContext();
846 WindowsConfigBuilder builder(context);
847 builder.SetDartEntrypoint(
"sendGetKeyboardState");
849 std::atomic<bool> done =
false;
850 context.AddFfiNativeFunction(
851 "SignalStringValue", CREATE_FFI_LAMBDA([&](Dart_Handle handle) {
852 ASSERT_FALSE(Dart_IsError(handle));
853 auto value = tonic::DartConverter<std::string>::FromDart(handle);
854 EXPECT_EQ(value,
"Success");
858 ViewControllerPtr controller{builder.Run()};
859 ASSERT_NE(controller,
nullptr);
871 std::string view_ids;
873 auto& context = GetContext();
874 WindowsConfigBuilder builder(context);
875 builder.SetDartEntrypoint(
"onMetricsChangedSignalViewIds");
878 context.AddFfiNativeFunction(
"Signal",
879 CREATE_FFI_LAMBDA([&]() { ready =
true; }));
881 context.AddFfiNativeFunction(
882 "SignalStringValue", CREATE_FFI_LAMBDA([&](Dart_Handle handle) {
883 ASSERT_FALSE(Dart_IsError(handle));
885 std::scoped_lock lock{mutex};
886 view_ids = tonic::DartConverter<std::string>::FromDart(handle);
890 ViewControllerPtr first_controller{builder.Run()};
891 ASSERT_NE(first_controller,
nullptr);
901 properties.
width = 100;
903 ViewControllerPtr second_controller{
905 ASSERT_NE(second_controller,
nullptr);
910 std::scoped_lock lock{mutex};
911 if (view_ids ==
"View IDs: [0, 1]") {
918 second_controller.reset();
921 std::scoped_lock lock{mutex};
922 if (view_ids ==
"View IDs: [0]") {
929 auto& context = GetContext();
930 WindowsConfigBuilder builder(context);
931 builder.SetDartEntrypoint(
"testEngineId");
933 std::optional<int64_t> engineId;
934 context.AddFfiNativeFunction(
935 "NotifyEngineId", CREATE_FFI_LAMBDA([&](Dart_Handle argument) {
936 if (!Dart_IsNull(argument)) {
937 const auto handle = tonic::DartConverter<int64_t>::FromDart(argument);
942 ViewControllerPtr first_controller{builder.Run()};
943 ASSERT_NE(first_controller,
nullptr);
945 while (!engineId.has_value()) {
954 auto& context = GetContext();
955 WindowsConfigBuilder builder(context);
956 builder.SetAccessibilityMode(
958 builder.SetDartEntrypoint(
"sendSemanticsTree");
962 auto native_entry = CREATE_FFI_LAMBDA([&]() { done =
true; });
963 context.AddFfiNativeFunction(
"Signal", native_entry);
966 ViewControllerPtr controller{builder.Run()};
967 ASSERT_NE(controller,
nullptr);
970 ASSERT_NE(view,
nullptr);
982 ASSERT_NE(hwnd,
nullptr);
984 LRESULT lres = SendMessage(hwnd, WM_GETOBJECT, 0, OBJID_CLIENT);
990 HRESULT hr = ObjectFromLresult(lres, IID_IAccessible, 0, (
void**)&accessible);
991 ASSERT_TRUE(SUCCEEDED(hr));
992 ASSERT_NE(accessible,
nullptr);
995 hr = ObjectFromLresult(lres, IID_IAccessibleEx, 0, (
void**)&accessible_ex);
996 ASSERT_TRUE(FAILED(hr));
997 ASSERT_EQ(accessible_ex,
nullptr);
1001 auto& context = GetContext();
1002 WindowsConfigBuilder builder(context);
1003 builder.SetAccessibilityMode(
1005 builder.SetDartEntrypoint(
"sendSemanticsTree");
1009 auto native_entry = CREATE_FFI_LAMBDA([&]() { done =
true; });
1010 context.AddFfiNativeFunction(
"Signal", native_entry);
1013 ViewControllerPtr controller{builder.Run()};
1014 ASSERT_NE(controller,
nullptr);
1017 ASSERT_NE(view,
nullptr);
1029 ASSERT_NE(hwnd,
nullptr);
1031 LRESULT lres = SendMessage(hwnd, WM_GETOBJECT, 0, OBJID_CLIENT);
1038 ObjectFromLresult(lres, IID_IAccessibleEx, 0, (
void**)&accessible_ex);
1039 ASSERT_TRUE(SUCCEEDED(hr));
1040 ASSERT_NE(accessible_ex,
nullptr);
1041 accessible_ex->Release();
void UpdateAccessibilityFeatures()
virtual void OnUpdateSemanticsEnabled(bool enabled) override
WindowsLifecycleManager(FlutterWindowsEngine *engine)
virtual void SetLifecycleState(AppLifecycleState state)
static std::optional< LUID > GetLowPowerGpuLuid()
static std::optional< LUID > GetHighPerformanceGpuLuid()
MOCK_METHOD(void, Quit,(std::optional< HWND >, std::optional< WPARAM >, std::optional< LPARAM >, UINT),(override))
MockWindowsLifecycleManager(FlutterWindowsEngine *engine)
bool FlutterDesktopEngineGetGraphicsAdapter(FlutterDesktopEngineRef engine, IDXGIAdapter **adapter_out)
FlutterDesktopEngineRef FlutterDesktopEngineCreate(const FlutterDesktopEngineProperties *engine_properties)
FLUTTER_EXPORT FlutterDesktopEngineRef FlutterDesktopEngineForId(int64_t engine_id)
FlutterDesktopViewRef FlutterDesktopPluginRegistrarGetViewById(FlutterDesktopPluginRegistrarRef registrar, FlutterDesktopViewId view_id)
FlutterDesktopPluginRegistrarRef FlutterDesktopEngineGetPluginRegistrar(FlutterDesktopEngineRef engine, const char *plugin_name)
bool FlutterDesktopEngineIsPlatformThread(FlutterDesktopEngineRef engine)
FlutterDesktopViewControllerRef FlutterDesktopViewControllerCreate(int width, int height, FlutterDesktopEngineRef engine)
bool FlutterDesktopEngineDestroy(FlutterDesktopEngineRef engine_ref)
void FlutterDesktopEnginePostPlatformThreadTask(FlutterDesktopEngineRef engine, VoidCallback callback, VoidCallback on_cancel, void *user_data)
FlutterDesktopTextureRegistrarRef FlutterDesktopEngineGetTextureRegistrar(FlutterDesktopEngineRef engine)
IDXGIAdapter * FlutterDesktopViewGetGraphicsAdapter(FlutterDesktopViewRef view)
FlutterDesktopViewId FlutterDesktopViewControllerGetViewId(FlutterDesktopViewControllerRef ref)
FlutterDesktopEngineRef FlutterDesktopViewControllerGetEngine(FlutterDesktopViewControllerRef ref)
void FlutterDesktopEngineSetNextFrameCallback(FlutterDesktopEngineRef engine, VoidCallback callback, void *user_data)
HWND FlutterDesktopViewGetHWND(FlutterDesktopViewRef view)
FlutterDesktopViewRef FlutterDesktopViewControllerGetView(FlutterDesktopViewControllerRef ref)
FlutterDesktopViewRef FlutterDesktopPluginRegistrarGetView(FlutterDesktopPluginRegistrarRef registrar)
FlutterDesktopViewControllerRef FlutterDesktopEngineCreateViewController(FlutterDesktopEngineRef engine, const FlutterDesktopViewControllerProperties *properties)
bool FlutterDesktopEngineRun(FlutterDesktopEngineRef engine, const char *entry_point)
struct FlutterDesktopEngine * FlutterDesktopEngineRef
int64_t FlutterDesktopViewId
struct FlutterDesktopView * FlutterDesktopViewRef
@ HighPerformancePreference
TEST_F(AccessibilityPluginTest, DirectAnnounceCall)
TEST(AccessibilityBridgeWindows, GetParent)
constexpr FlutterViewId kImplicitViewId
const wchar_t * icu_data_path
const wchar_t * assets_path
FlutterDesktopImpellerSwitch impeller_switch