From 4bdbda0ffb3ba736f9a025083174b0c7a0929fc9 Mon Sep 17 00:00:00 2001 From: Tong Mu Date: Wed, 30 Aug 2023 15:11:54 -0700 Subject: [PATCH 1/7] Impl --- shell/common/engine_unittests.cc | 130 +++++++++++++++++++------------ 1 file changed, 80 insertions(+), 50 deletions(-) diff --git a/shell/common/engine_unittests.cc b/shell/common/engine_unittests.cc index 9d8339321d999..2b7fde54012f8 100644 --- a/shell/common/engine_unittests.cc +++ b/shell/common/engine_unittests.cc @@ -15,64 +15,89 @@ #include "rapidjson/stringbuffer.h" #include "rapidjson/writer.h" -///\note Deprecated MOCK_METHOD macros used until this issue is resolved: -// https://github.com/google/googletest/issues/2490 - namespace flutter { namespace { class MockDelegate : public Engine::Delegate { public: - MOCK_METHOD2(OnEngineUpdateSemantics, - void(SemanticsNodeUpdates, CustomAccessibilityActionUpdates)); - MOCK_METHOD1(OnEngineHandlePlatformMessage, - void(std::unique_ptr)); - MOCK_METHOD0(OnPreEngineRestart, void()); - MOCK_METHOD0(OnRootIsolateCreated, void()); - MOCK_METHOD2(UpdateIsolateDescription, void(const std::string, int64_t)); - MOCK_METHOD1(SetNeedsReportTimings, void(bool)); - MOCK_METHOD1(ComputePlatformResolvedLocale, - std::unique_ptr>( - const std::vector&)); - MOCK_METHOD1(RequestDartDeferredLibrary, void(intptr_t)); - MOCK_METHOD0(GetCurrentTimePoint, fml::TimePoint()); - MOCK_CONST_METHOD0(GetPlatformMessageHandler, - const std::shared_ptr&()); - MOCK_METHOD2(OnEngineChannelUpdate, void(std::string, bool)); - MOCK_CONST_METHOD2(GetScaledFontSize, - double(double font_size, int configuration_id)); + MOCK_METHOD(void, + OnEngineUpdateSemantics, + (SemanticsNodeUpdates, CustomAccessibilityActionUpdates), + (override)); + MOCK_METHOD(void, + OnEngineHandlePlatformMessage, + (std::unique_ptr), + (override)); + MOCK_METHOD(void, OnPreEngineRestart, (), (override)); + MOCK_METHOD(void, OnRootIsolateCreated, (), (override)); + MOCK_METHOD(void, + UpdateIsolateDescription, + (const std::string, int64_t), + (override)); + MOCK_METHOD(void, SetNeedsReportTimings, (bool), (override)); + MOCK_METHOD(std::unique_ptr>, + ComputePlatformResolvedLocale, + (const std::vector&), + (override)); + MOCK_METHOD(void, RequestDartDeferredLibrary, (intptr_t), (override)); + MOCK_METHOD(fml::TimePoint, GetCurrentTimePoint, (), (override)); + MOCK_METHOD(const std::shared_ptr&, + GetPlatformMessageHandler, + (), + (const, override)); + MOCK_METHOD(void, OnEngineChannelUpdate, (std::string, bool), (override)); + MOCK_METHOD(double, + GetScaledFontSize, + (double font_size, int configuration_id), + (const, override)); }; class MockResponse : public PlatformMessageResponse { public: - MOCK_METHOD1(Complete, void(std::unique_ptr data)); - MOCK_METHOD0(CompleteEmpty, void()); + MOCK_METHOD(void, Complete, (std::unique_ptr data), (override)); + MOCK_METHOD(void, CompleteEmpty, (), (override)); }; class MockRuntimeDelegate : public RuntimeDelegate { public: - MOCK_METHOD0(ImplicitViewEnabled, bool()); - MOCK_METHOD0(DefaultRouteName, std::string()); - MOCK_METHOD1(ScheduleFrame, void(bool)); - MOCK_METHOD2(Render, void(std::unique_ptr, float)); - MOCK_METHOD2(UpdateSemantics, - void(SemanticsNodeUpdates, CustomAccessibilityActionUpdates)); - MOCK_METHOD1(HandlePlatformMessage, void(std::unique_ptr)); - MOCK_METHOD0(GetFontCollection, FontCollection&()); - MOCK_METHOD0(GetAssetManager, std::shared_ptr()); - MOCK_METHOD0(OnRootIsolateCreated, void()); - MOCK_METHOD2(UpdateIsolateDescription, void(const std::string, int64_t)); - MOCK_METHOD1(SetNeedsReportTimings, void(bool)); - MOCK_METHOD1(ComputePlatformResolvedLocale, - std::unique_ptr>( - const std::vector&)); - MOCK_METHOD1(RequestDartDeferredLibrary, void(intptr_t)); - MOCK_CONST_METHOD0(GetPlatformMessageHandler, - std::weak_ptr()); - MOCK_METHOD2(SendChannelUpdate, void(std::string, bool)); - MOCK_CONST_METHOD2(GetScaledFontSize, - double(double font_size, int configuration_id)); + MOCK_METHOD(bool, ImplicitViewEnabled, (), (override)); + MOCK_METHOD(std::string, DefaultRouteName, (), (override)); + MOCK_METHOD(void, ScheduleFrame, (bool), (override)); + MOCK_METHOD(void, + Render, + (std::unique_ptr, float), + (override)); + MOCK_METHOD(void, + UpdateSemantics, + (SemanticsNodeUpdates, CustomAccessibilityActionUpdates), + (override)); + MOCK_METHOD(void, + HandlePlatformMessage, + (std::unique_ptr), + (override)); + MOCK_METHOD(FontCollection&, GetFontCollection, (), (override)); + MOCK_METHOD(std::shared_ptr, GetAssetManager, (), (override)); + MOCK_METHOD(void, OnRootIsolateCreated, (), (override)); + MOCK_METHOD(void, + UpdateIsolateDescription, + (const std::string, int64_t), + (override)); + MOCK_METHOD(void, SetNeedsReportTimings, (bool), (override)); + MOCK_METHOD(std::unique_ptr>, + ComputePlatformResolvedLocale, + (const std::vector&), + (override)); + MOCK_METHOD(void, RequestDartDeferredLibrary, (intptr_t), (override)); + MOCK_METHOD(std::weak_ptr, + GetPlatformMessageHandler, + (), + (const, override)); + MOCK_METHOD(void, SendChannelUpdate, (std::string, bool), (override)); + MOCK_METHOD(double, + GetScaledFontSize, + (double font_size, int configuration_id), + (const, override)); }; class MockRuntimeController : public RuntimeController { @@ -80,12 +105,17 @@ class MockRuntimeController : public RuntimeController { MockRuntimeController(RuntimeDelegate& client, const TaskRunners& p_task_runners) : RuntimeController(client, p_task_runners) {} - MOCK_METHOD0(IsRootIsolateRunning, bool()); - MOCK_METHOD1(DispatchPlatformMessage, bool(std::unique_ptr)); - MOCK_METHOD3(LoadDartDeferredLibraryError, - void(intptr_t, const std::string, bool)); - MOCK_CONST_METHOD0(GetDartVM, DartVM*()); - MOCK_METHOD1(NotifyIdle, bool(fml::TimeDelta)); + MOCK_METHOD(bool, IsRootIsolateRunning, (), (override)); + MOCK_METHOD(bool, + DispatchPlatformMessage, + (std::unique_ptr), + (override)); + MOCK_METHOD(void, + LoadDartDeferredLibraryError, + (intptr_t, const std::string, bool), + (override)); + MOCK_METHOD(DartVM*, GetDartVM, (), (const, override)); + MOCK_METHOD(bool, NotifyIdle, (fml::TimeDelta), (override)); }; std::unique_ptr MakePlatformMessage( From 80d8bce9fefe3939d64127c4f005df94e7b49fb0 Mon Sep 17 00:00:00 2001 From: Tong Mu Date: Wed, 30 Aug 2023 22:24:18 +0000 Subject: [PATCH 2/7] Fix compile --- shell/common/engine_unittests.cc | 1 - 1 file changed, 1 deletion(-) diff --git a/shell/common/engine_unittests.cc b/shell/common/engine_unittests.cc index 2b7fde54012f8..b0393cb2d2490 100644 --- a/shell/common/engine_unittests.cc +++ b/shell/common/engine_unittests.cc @@ -61,7 +61,6 @@ class MockResponse : public PlatformMessageResponse { class MockRuntimeDelegate : public RuntimeDelegate { public: - MOCK_METHOD(bool, ImplicitViewEnabled, (), (override)); MOCK_METHOD(std::string, DefaultRouteName, (), (override)); MOCK_METHOD(void, ScheduleFrame, (bool), (override)); MOCK_METHOD(void, From a0f487dc1b9f0d32907af44a0534b8345a370536 Mon Sep 17 00:00:00 2001 From: Tong Mu Date: Thu, 31 Aug 2023 18:35:26 -0700 Subject: [PATCH 3/7] convert all --- flow/stopwatch_unittests.cc | 2 +- impeller/aiks/testing/context_mock.h | 74 ++++--- impeller/renderer/testing/mocks.h | 183 +++++++++++------- lib/ui/painting/image_encoding_unittests.cc | 21 +- shell/common/animator_unittests.cc | 18 +- shell/common/rasterizer_unittests.cc | 105 ++++++---- shell/common/shell_unittests.cc | 180 ++++++++++------- .../android_context_gl_impeller_unittests.cc | 7 +- .../android/android_shell_holder_unittests.cc | 146 ++++++++------ .../android/apk_asset_provider_unittests.cc | 7 +- .../standard_message_codec_unittests.cc | 13 +- .../platform_view_embedder_unittests.cc | 105 ++++++---- .../flutter/tests/platform_view_unittest.cc | 4 +- .../linux/testing/mock_binary_messenger.h | 76 ++++---- .../platform/linux/testing/mock_im_context.h | 53 ++--- shell/platform/linux/testing/mock_settings.h | 19 +- .../linux/testing/mock_signal_handler.h | 6 +- .../testing/mock_text_input_view_delegate.h | 13 +- .../windows/flutter_window_unittests.cc | 63 +++--- .../flutter_windows_engine_unittests.cc | 24 +-- .../windows/flutter_windows_view_unittests.cc | 18 +- .../windows/platform_handler_unittests.cc | 44 +++-- .../windows/settings_plugin_unittests.cc | 10 +- .../testing/mock_direct_manipulation.h | 2 +- .../windows/testing/mock_text_input_manager.h | 12 +- shell/platform/windows/testing/mock_window.h | 85 +++++--- .../testing/mock_window_binding_handler.h | 41 ++-- .../mock_window_binding_handler_delegate.h | 103 +++++----- .../windows/testing/mock_windows_proc_table.h | 14 +- .../windows/text_input_plugin_unittest.cc | 4 +- shell/profiling/sampling_profiler_unittest.cc | 18 +- 31 files changed, 898 insertions(+), 572 deletions(-) diff --git a/flow/stopwatch_unittests.cc b/flow/stopwatch_unittests.cc index 3ded5142a9fbb..e183f91e4cd9f 100644 --- a/flow/stopwatch_unittests.cc +++ b/flow/stopwatch_unittests.cc @@ -13,7 +13,7 @@ namespace testing { class MockRefreshRateUpdater : public Stopwatch::RefreshRateUpdater { public: - MOCK_CONST_METHOD0(GetFrameBudget, fml::Milliseconds()); + MOCK_METHOD(fml::Milliseconds, GetFrameBudget, (), (const, override)); }; TEST(Instrumentation, GetDefaultFrameBudgetTest) { diff --git a/impeller/aiks/testing/context_mock.h b/impeller/aiks/testing/context_mock.h index 14c7c5a1b807b..0b3ed6fe78c1b 100644 --- a/impeller/aiks/testing/context_mock.h +++ b/impeller/aiks/testing/context_mock.h @@ -21,15 +21,19 @@ class CommandBufferMock : public CommandBuffer { CommandBufferMock(std::weak_ptr context) : CommandBuffer(context) {} - MOCK_CONST_METHOD0(IsValid, bool()); + MOCK_METHOD(bool, IsValid, (), (const, override)); - MOCK_CONST_METHOD1(SetLabel, void(const std::string& label)); + MOCK_METHOD(void, SetLabel, (const std::string& label), (const, override)); - MOCK_METHOD1(SubmitCommandsAsync, - bool(std::shared_ptr render_pass)); + MOCK_METHOD(bool, + SubmitCommandsAsync, + (std::shared_ptr render_pass), + (override)); - MOCK_METHOD1(OnCreateRenderPass, - std::shared_ptr(RenderTarget render_target)); + MOCK_METHOD(std::shared_ptr, + OnCreateRenderPass, + (RenderTarget render_target), + (override)); static std::shared_ptr ForwardOnCreateRenderPass( CommandBuffer* command_buffer, @@ -37,24 +41,30 @@ class CommandBufferMock : public CommandBuffer { return command_buffer->OnCreateRenderPass(render_target); } - MOCK_METHOD0(OnCreateBlitPass, std::shared_ptr()); + MOCK_METHOD(std::shared_ptr, OnCreateBlitPass, (), (override)); static std::shared_ptr ForwardOnCreateBlitPass( CommandBuffer* command_buffer) { return command_buffer->OnCreateBlitPass(); } - MOCK_METHOD1(OnSubmitCommands, bool(CompletionCallback callback)); + MOCK_METHOD(bool, + OnSubmitCommands, + (CompletionCallback callback), + (override)); static bool ForwardOnSubmitCommands(CommandBuffer* command_buffer, CompletionCallback callback) { return command_buffer->OnSubmitCommands(callback); } - MOCK_METHOD0(OnWaitUntilScheduled, void()); + MOCK_METHOD(void, OnWaitUntilScheduled, (), (override)); static void ForwardOnWaitUntilScheduled(CommandBuffer* command_buffer) { return command_buffer->OnWaitUntilScheduled(); } - MOCK_METHOD0(OnCreateComputePass, std::shared_ptr()); + MOCK_METHOD(std::shared_ptr, + OnCreateComputePass, + (), + (override)); static std::shared_ptr ForwardOnCreateComputePass( CommandBuffer* command_buffer) { return command_buffer->OnCreateComputePass(); @@ -63,28 +73,48 @@ class CommandBufferMock : public CommandBuffer { class ContextMock : public Context { public: - MOCK_CONST_METHOD0(DescribeGpuModel, std::string()); + MOCK_METHOD(std::string, DescribeGpuModel, (), (const, override)); - MOCK_CONST_METHOD0(GetBackendType, Context::BackendType()); + MOCK_METHOD(Context::BackendType, GetBackendType, (), (const, override)); - MOCK_CONST_METHOD0(IsValid, bool()); + MOCK_METHOD(bool, IsValid, (), (const, override)); - MOCK_CONST_METHOD0(GetCapabilities, - const std::shared_ptr&()); + MOCK_METHOD(const std::shared_ptr&, + GetCapabilities, + (), + (const, override)); - MOCK_METHOD1(UpdateOffscreenLayerPixelFormat, bool(PixelFormat format)); + MOCK_METHOD(bool, + UpdateOffscreenLayerPixelFormat, + (PixelFormat format), + (override)); - MOCK_CONST_METHOD0(GetResourceAllocator, std::shared_ptr()); + MOCK_METHOD(std::shared_ptr, + GetResourceAllocator, + (), + (const, override)); - MOCK_CONST_METHOD0(GetShaderLibrary, std::shared_ptr()); + MOCK_METHOD(std::shared_ptr, + GetShaderLibrary, + (), + (const, override)); - MOCK_CONST_METHOD0(GetSamplerLibrary, std::shared_ptr()); + MOCK_METHOD(std::shared_ptr, + GetSamplerLibrary, + (), + (const, override)); - MOCK_CONST_METHOD0(GetPipelineLibrary, std::shared_ptr()); + MOCK_METHOD(std::shared_ptr, + GetPipelineLibrary, + (), + (const, override)); - MOCK_CONST_METHOD0(CreateCommandBuffer, std::shared_ptr()); + MOCK_METHOD(std::shared_ptr, + CreateCommandBuffer, + (), + (const, override)); - MOCK_METHOD0(Shutdown, void()); + MOCK_METHOD(void, Shutdown, (), (override)); }; } // namespace testing diff --git a/impeller/renderer/testing/mocks.h b/impeller/renderer/testing/mocks.h index cd3910b1a9737..7b61402d6405c 100644 --- a/impeller/renderer/testing/mocks.h +++ b/impeller/renderer/testing/mocks.h @@ -17,111 +17,156 @@ namespace testing { class MockDeviceBuffer : public DeviceBuffer { public: MockDeviceBuffer(const DeviceBufferDescriptor& desc) : DeviceBuffer(desc) {} - MOCK_METHOD3(CopyHostBuffer, - bool(const uint8_t* source, Range source_range, size_t offset)); + // MOCK_METHOD(bool, CopyHostBuffer, (const uint8_t* source, Range + // source_range, size_t offset), (override)); - MOCK_METHOD1(SetLabel, bool(const std::string& label)); + MOCK_METHOD(bool, SetLabel, (const std::string& label), (override)); - MOCK_METHOD2(SetLabel, bool(const std::string& label, Range range)); + MOCK_METHOD(bool, + SetLabel, + (const std::string& label, Range range), + (override)); - MOCK_CONST_METHOD0(OnGetContents, uint8_t*()); + MOCK_METHOD(uint8_t*, OnGetContents, (), (const, override)); - MOCK_METHOD3(OnCopyHostBuffer, - bool(const uint8_t* source, Range source_range, size_t offset)); + MOCK_METHOD(bool, + OnCopyHostBuffer, + (const uint8_t* source, Range source_range, size_t offset), + (override)); }; class MockAllocator : public Allocator { public: - MOCK_CONST_METHOD0(GetMaxTextureSizeSupported, ISize()); - MOCK_METHOD1( - OnCreateBuffer, - std::shared_ptr(const DeviceBufferDescriptor& desc)); - MOCK_METHOD1(OnCreateTexture, - std::shared_ptr(const TextureDescriptor& desc)); + MOCK_METHOD(ISize, GetMaxTextureSizeSupported, (), (const, override)); + MOCK_METHOD(std::shared_ptr, + OnCreateBuffer, + (const DeviceBufferDescriptor& desc), + (override)); + MOCK_METHOD(std::shared_ptr, + OnCreateTexture, + (const TextureDescriptor& desc), + (override)); }; class MockBlitPass : public BlitPass { public: - MOCK_CONST_METHOD0(IsValid, bool()); - MOCK_CONST_METHOD1( - EncodeCommands, - bool(const std::shared_ptr& transients_allocator)); - MOCK_METHOD1(OnSetLabel, void(std::string label)); - - MOCK_METHOD5(OnCopyTextureToTextureCommand, - bool(std::shared_ptr source, - std::shared_ptr destination, - IRect source_region, - IPoint destination_origin, - std::string label)); - - MOCK_METHOD5(OnCopyTextureToBufferCommand, - bool(std::shared_ptr source, - std::shared_ptr destination, - IRect source_region, - size_t destination_offset, - std::string label)); - MOCK_METHOD4(OnCopyBufferToTextureCommand, - bool(BufferView source, - std::shared_ptr destination, - IPoint destination_origin, - std::string label)); - MOCK_METHOD2(OnGenerateMipmapCommand, - bool(std::shared_ptr texture, std::string label)); + MOCK_METHOD(bool, IsValid, (), (const, override)); + MOCK_METHOD(bool, + EncodeCommands, + (const std::shared_ptr& transients_allocator), + (const, override)); + MOCK_METHOD(void, OnSetLabel, (std::string label), (override)); + + MOCK_METHOD(bool, + OnCopyTextureToTextureCommand, + (std::shared_ptr source, + std::shared_ptr destination, + IRect source_region, + IPoint destination_origin, + std::string label), + (override)); + + MOCK_METHOD(bool, + OnCopyTextureToBufferCommand, + (std::shared_ptr source, + std::shared_ptr destination, + IRect source_region, + size_t destination_offset, + std::string label), + (override)); + MOCK_METHOD(bool, + OnCopyBufferToTextureCommand, + (BufferView source, + std::shared_ptr destination, + IPoint destination_origin, + std::string label), + (override)); + MOCK_METHOD(bool, + OnGenerateMipmapCommand, + (std::shared_ptr texture, std::string label), + (override)); }; class MockCommandBuffer : public CommandBuffer { public: MockCommandBuffer(std::weak_ptr context) : CommandBuffer(context) {} - MOCK_CONST_METHOD0(IsValid, bool()); - MOCK_CONST_METHOD1(SetLabel, void(const std::string& label)); - MOCK_METHOD0(OnCreateBlitPass, std::shared_ptr()); - MOCK_METHOD1(OnSubmitCommands, bool(CompletionCallback callback)); - MOCK_METHOD0(OnWaitUntilScheduled, void()); - MOCK_METHOD0(OnCreateComputePass, std::shared_ptr()); - MOCK_METHOD1(OnCreateRenderPass, - std::shared_ptr(RenderTarget render_target)); + MOCK_METHOD(bool, IsValid, (), (const, override)); + MOCK_METHOD(void, SetLabel, (const std::string& label), (const, override)); + MOCK_METHOD(std::shared_ptr, OnCreateBlitPass, (), (override)); + MOCK_METHOD(bool, + OnSubmitCommands, + (CompletionCallback callback), + (override)); + MOCK_METHOD(void, OnWaitUntilScheduled, (), (override)); + MOCK_METHOD(std::shared_ptr, + OnCreateComputePass, + (), + (override)); + MOCK_METHOD(std::shared_ptr, + OnCreateRenderPass, + (RenderTarget render_target), + (override)); }; class MockImpellerContext : public Context { public: - MOCK_CONST_METHOD0(GetBackendType, Context::BackendType()); + MOCK_METHOD(Context::BackendType, GetBackendType, (), (const, override)); - MOCK_CONST_METHOD0(DescribeGpuModel, std::string()); + MOCK_METHOD(std::string, DescribeGpuModel, (), (const, override)); - MOCK_CONST_METHOD0(IsValid, bool()); + MOCK_METHOD(bool, IsValid, (), (const, override)); - MOCK_METHOD0(Shutdown, void()); + MOCK_METHOD(void, Shutdown, (), (override)); - MOCK_CONST_METHOD0(GetResourceAllocator, std::shared_ptr()); + MOCK_METHOD(std::shared_ptr, + GetResourceAllocator, + (), + (const, override)); - MOCK_CONST_METHOD0(GetShaderLibrary, std::shared_ptr()); + MOCK_METHOD(std::shared_ptr, + GetShaderLibrary, + (), + (const, override)); - MOCK_CONST_METHOD0(GetSamplerLibrary, std::shared_ptr()); + MOCK_METHOD(std::shared_ptr, + GetSamplerLibrary, + (), + (const, override)); - MOCK_CONST_METHOD0(GetPipelineLibrary, std::shared_ptr()); + MOCK_METHOD(std::shared_ptr, + GetPipelineLibrary, + (), + (const, override)); - MOCK_CONST_METHOD0(CreateCommandBuffer, std::shared_ptr()); + MOCK_METHOD(std::shared_ptr, + CreateCommandBuffer, + (), + (const, override)); - MOCK_CONST_METHOD0(GetCapabilities, - const std::shared_ptr&()); + MOCK_METHOD(const std::shared_ptr&, + GetCapabilities, + (), + (const, override)); }; class MockTexture : public Texture { public: MockTexture(const TextureDescriptor& desc) : Texture(desc) {} - MOCK_METHOD1(SetLabel, void(std::string_view label)); - MOCK_METHOD3(SetContents, - bool(const uint8_t* contents, size_t length, size_t slice)); - MOCK_METHOD2(SetContents, - bool(std::shared_ptr mapping, size_t slice)); - MOCK_CONST_METHOD0(IsValid, bool()); - MOCK_CONST_METHOD0(GetSize, ISize()); - MOCK_METHOD3(OnSetContents, - bool(const uint8_t* contents, size_t length, size_t slice)); - MOCK_METHOD2(OnSetContents, - bool(std::shared_ptr mapping, size_t slice)); + MOCK_METHOD(void, SetLabel, (std::string_view label), (override)); + // MOCK_METHOD(bool, SetContents, (const uint8_t* contents, size_t length, + // size_t slice), (override)); MOCK_METHOD(bool, SetContents, + // (std::shared_ptr mapping, size_t slice), (override)); + MOCK_METHOD(bool, IsValid, (), (const, override)); + MOCK_METHOD(ISize, GetSize, (), (const, override)); + MOCK_METHOD(bool, + OnSetContents, + (const uint8_t* contents, size_t length, size_t slice), + (override)); + MOCK_METHOD(bool, + OnSetContents, + (std::shared_ptr mapping, size_t slice), + (override)); }; } // namespace testing diff --git a/lib/ui/painting/image_encoding_unittests.cc b/lib/ui/painting/image_encoding_unittests.cc index 8a111167fc64d..65fb4df75e410 100644 --- a/lib/ui/painting/image_encoding_unittests.cc +++ b/lib/ui/painting/image_encoding_unittests.cc @@ -31,13 +31,16 @@ fml::AutoResetWaitableEvent message_latch; class MockDlImage : public DlImage { public: - MOCK_CONST_METHOD0(skia_image, sk_sp()); - MOCK_CONST_METHOD0(impeller_texture, std::shared_ptr()); - MOCK_CONST_METHOD0(isOpaque, bool()); - MOCK_CONST_METHOD0(isTextureBacked, bool()); - MOCK_CONST_METHOD0(isUIThreadSafe, bool()); - MOCK_CONST_METHOD0(dimensions, SkISize()); - MOCK_CONST_METHOD0(GetApproximateByteSize, size_t()); + MOCK_METHOD(sk_sp, skia_image, (), (const, override)); + MOCK_METHOD(std::shared_ptr, + impeller_texture, + (), + (const, override)); + MOCK_METHOD(bool, isOpaque, (), (const, override)); + MOCK_METHOD(bool, isTextureBacked, (), (const, override)); + MOCK_METHOD(bool, isUIThreadSafe, (), (const, override)); + MOCK_METHOD(SkISize, dimensions, (), (const, override)); + MOCK_METHOD(size_t, GetApproximateByteSize, (), (const, override)); }; } // namespace @@ -57,8 +60,8 @@ class MockSyncSwitch { std::function false_handler = [] {}; }; - MOCK_CONST_METHOD1(Execute, void(const Handlers& handlers)); - MOCK_METHOD1(SetSwitch, void(bool value)); + MOCK_METHOD(void, Execute, (const Handlers& handlers), (const)); + MOCK_METHOD(void, SetSwitch, (bool value)); }; TEST_F(ShellTest, EncodeImageGivesExternalTypedData) { diff --git a/shell/common/animator_unittests.cc b/shell/common/animator_unittests.cc index e15aa1b1c98c0..459c77b0ec672 100644 --- a/shell/common/animator_unittests.cc +++ b/shell/common/animator_unittests.cc @@ -25,18 +25,24 @@ namespace testing { class FakeAnimatorDelegate : public Animator::Delegate { public: - MOCK_METHOD2(OnAnimatorBeginFrame, - void(fml::TimePoint frame_target_time, uint64_t frame_number)); + MOCK_METHOD(void, + OnAnimatorBeginFrame, + (fml::TimePoint frame_target_time, uint64_t frame_number), + (override)); void OnAnimatorNotifyIdle(fml::TimeDelta deadline) override { notify_idle_called_ = true; } - MOCK_METHOD1(OnAnimatorUpdateLatestFrameTargetTime, - void(fml::TimePoint frame_target_time)); + MOCK_METHOD(void, + OnAnimatorUpdateLatestFrameTargetTime, + (fml::TimePoint frame_target_time), + (override)); - MOCK_METHOD1(OnAnimatorDraw, - void(std::shared_ptr pipeline)); + MOCK_METHOD(void, + OnAnimatorDraw, + (std::shared_ptr pipeline), + (override)); void OnAnimatorDrawLastLayerTree( std::unique_ptr frame_timings_recorder) override {} diff --git a/shell/common/rasterizer_unittests.cc b/shell/common/rasterizer_unittests.cc index 5a527e49a2e4e..887e8be616d40 100644 --- a/shell/common/rasterizer_unittests.cc +++ b/shell/common/rasterizer_unittests.cc @@ -34,56 +34,77 @@ constexpr float kDevicePixelRatio = 2.0f; class MockDelegate : public Rasterizer::Delegate { public: - MOCK_METHOD1(OnFrameRasterized, void(const FrameTiming& frame_timing)); - MOCK_METHOD0(GetFrameBudget, fml::Milliseconds()); - MOCK_CONST_METHOD0(GetLatestFrameTargetTime, fml::TimePoint()); - MOCK_CONST_METHOD0(GetTaskRunners, const TaskRunners&()); - MOCK_CONST_METHOD0(GetParentRasterThreadMerger, - const fml::RefPtr()); - MOCK_CONST_METHOD0(GetIsGpuDisabledSyncSwitch, - std::shared_ptr()); - MOCK_CONST_METHOD0(GetSettings, const Settings&()); - MOCK_METHOD2(ShouldDiscardLayerTree, - bool(int64_t, const flutter::LayerTree&)); + MOCK_METHOD(void, + OnFrameRasterized, + (const FrameTiming& frame_timing), + (override)); + MOCK_METHOD(fml::Milliseconds, GetFrameBudget, (), (override)); + MOCK_METHOD(fml::TimePoint, GetLatestFrameTargetTime, (), (const, override)); + MOCK_METHOD(const TaskRunners&, GetTaskRunners, (), (const, override)); + MOCK_METHOD(const fml::RefPtr, + GetParentRasterThreadMerger, + (), + (const, override)); + MOCK_METHOD(std::shared_ptr, + GetIsGpuDisabledSyncSwitch, + (), + (const, override)); + MOCK_METHOD(const Settings&, GetSettings, (), (const, override)); + MOCK_METHOD(bool, + ShouldDiscardLayerTree, + (int64_t, const flutter::LayerTree&), + (override)); }; class MockSurface : public Surface { public: - MOCK_METHOD0(IsValid, bool()); - MOCK_METHOD1(AcquireFrame, - std::unique_ptr(const SkISize& size)); - MOCK_CONST_METHOD0(GetRootTransformation, SkMatrix()); - MOCK_METHOD0(GetContext, GrDirectContext*()); - MOCK_METHOD0(GetExternalViewEmbedder, ExternalViewEmbedder*()); - MOCK_METHOD0(MakeRenderContextCurrent, std::unique_ptr()); - MOCK_METHOD0(ClearRenderContext, bool()); - MOCK_CONST_METHOD0(AllowsDrawingWhenGpuDisabled, bool()); + MOCK_METHOD(bool, IsValid, (), (override)); + MOCK_METHOD(std::unique_ptr, + AcquireFrame, + (const SkISize& size), + (override)); + MOCK_METHOD(SkMatrix, GetRootTransformation, (), (const, override)); + MOCK_METHOD(GrDirectContext*, GetContext, (), (override)); + MOCK_METHOD(std::unique_ptr, + MakeRenderContextCurrent, + (), + (override)); + MOCK_METHOD(bool, ClearRenderContext, (), (override)); + MOCK_METHOD(bool, AllowsDrawingWhenGpuDisabled, (), (const, override)); }; class MockExternalViewEmbedder : public ExternalViewEmbedder { public: - MOCK_METHOD0(GetRootCanvas, DlCanvas*()); - MOCK_METHOD0(CancelFrame, void()); - MOCK_METHOD4(BeginFrame, - void(SkISize frame_size, - GrDirectContext* context, - double device_pixel_ratio, - fml::RefPtr raster_thread_merger)); - MOCK_METHOD2(PrerollCompositeEmbeddedView, - void(int64_t view_id, - std::unique_ptr params)); - MOCK_METHOD1(PostPrerollAction, - PostPrerollResult( - fml::RefPtr raster_thread_merger)); - MOCK_METHOD1(CompositeEmbeddedView, DlCanvas*(int64_t view_id)); - MOCK_METHOD3(SubmitFrame, - void(GrDirectContext* context, - const std::shared_ptr& aiks_context, - std::unique_ptr frame)); - MOCK_METHOD2(EndFrame, - void(bool should_resubmit_frame, - fml::RefPtr raster_thread_merger)); - MOCK_METHOD0(SupportsDynamicThreadMerging, bool()); + MOCK_METHOD(DlCanvas*, GetRootCanvas, (), (override)); + MOCK_METHOD(void, CancelFrame, (), (override)); + MOCK_METHOD(void, + BeginFrame, + (SkISize frame_size, + GrDirectContext* context, + double device_pixel_ratio, + fml::RefPtr raster_thread_merger), + (override)); + MOCK_METHOD(void, + PrerollCompositeEmbeddedView, + (int64_t view_id, std::unique_ptr params), + (override)); + MOCK_METHOD(PostPrerollResult, + PostPrerollAction, + (fml::RefPtr raster_thread_merger), + (override)); + MOCK_METHOD(DlCanvas*, CompositeEmbeddedView, (int64_t view_id), (override)); + MOCK_METHOD(void, + SubmitFrame, + (GrDirectContext * context, + const std::shared_ptr& aiks_context, + std::unique_ptr frame), + (override)); + MOCK_METHOD(void, + EndFrame, + (bool should_resubmit_frame, + fml::RefPtr raster_thread_merger), + (override)); + MOCK_METHOD(bool, SupportsDynamicThreadMerging, (), (override)); }; } // namespace diff --git a/shell/common/shell_unittests.cc b/shell/common/shell_unittests.cc index 43a14bb13b75f..3669e6b129708 100644 --- a/shell/common/shell_unittests.cc +++ b/shell/common/shell_unittests.cc @@ -67,75 +67,110 @@ using ::testing::Return; namespace { class MockPlatformViewDelegate : public PlatformView::Delegate { - MOCK_METHOD1(OnPlatformViewCreated, void(std::unique_ptr surface)); - - MOCK_METHOD0(OnPlatformViewDestroyed, void()); - - MOCK_METHOD0(OnPlatformViewScheduleFrame, void()); - - MOCK_METHOD1(OnPlatformViewSetNextFrameCallback, - void(const fml::closure& closure)); - - MOCK_METHOD2(OnPlatformViewSetViewportMetrics, - void(int64_t view_id, const ViewportMetrics& metrics)); - - MOCK_METHOD1(OnPlatformViewDispatchPlatformMessage, - void(std::unique_ptr message)); - - MOCK_METHOD1(OnPlatformViewDispatchPointerDataPacket, - void(std::unique_ptr packet)); - - MOCK_METHOD3(OnPlatformViewDispatchSemanticsAction, - void(int32_t id, - SemanticsAction action, - fml::MallocMapping args)); - - MOCK_METHOD1(OnPlatformViewSetSemanticsEnabled, void(bool enabled)); - - MOCK_METHOD1(OnPlatformViewSetAccessibilityFeatures, void(int32_t flags)); - - MOCK_METHOD1(OnPlatformViewRegisterTexture, - void(std::shared_ptr texture)); - - MOCK_METHOD1(OnPlatformViewUnregisterTexture, void(int64_t texture_id)); - - MOCK_METHOD1(OnPlatformViewMarkTextureFrameAvailable, - void(int64_t texture_id)); + MOCK_METHOD(void, + OnPlatformViewCreated, + (std::unique_ptr surface), + (override)); + + MOCK_METHOD(void, OnPlatformViewDestroyed, (), (override)); + + MOCK_METHOD(void, OnPlatformViewScheduleFrame, (), (override)); + + MOCK_METHOD(void, + OnPlatformViewSetNextFrameCallback, + (const fml::closure& closure), + (override)); + + MOCK_METHOD(void, + OnPlatformViewSetViewportMetrics, + (int64_t view_id, const ViewportMetrics& metrics), + (override)); + + MOCK_METHOD(void, + OnPlatformViewDispatchPlatformMessage, + (std::unique_ptr message), + (override)); + + MOCK_METHOD(void, + OnPlatformViewDispatchPointerDataPacket, + (std::unique_ptr packet), + (override)); + + MOCK_METHOD(void, + OnPlatformViewDispatchSemanticsAction, + (int32_t id, SemanticsAction action, fml::MallocMapping args), + (override)); + + MOCK_METHOD(void, + OnPlatformViewSetSemanticsEnabled, + (bool enabled), + (override)); + + MOCK_METHOD(void, + OnPlatformViewSetAccessibilityFeatures, + (int32_t flags), + (override)); + + MOCK_METHOD(void, + OnPlatformViewRegisterTexture, + (std::shared_ptr texture), + (override)); + + MOCK_METHOD(void, + OnPlatformViewUnregisterTexture, + (int64_t texture_id), + (override)); + + MOCK_METHOD(void, + OnPlatformViewMarkTextureFrameAvailable, + (int64_t texture_id), + (override)); MOCK_METHOD(const Settings&, OnPlatformViewGetSettings, (), (const, override)); - MOCK_METHOD3(LoadDartDeferredLibrary, - void(intptr_t loading_unit_id, - std::unique_ptr snapshot_data, - std::unique_ptr snapshot_instructions)); - - MOCK_METHOD3(LoadDartDeferredLibraryError, - void(intptr_t loading_unit_id, - const std::string error_message, - bool transient)); - - MOCK_METHOD2(UpdateAssetResolverByType, - void(std::unique_ptr updated_asset_resolver, - AssetResolver::AssetResolverType type)); + MOCK_METHOD(void, + LoadDartDeferredLibrary, + (intptr_t loading_unit_id, + std::unique_ptr snapshot_data, + std::unique_ptr snapshot_instructions), + (override)); + + MOCK_METHOD(void, + LoadDartDeferredLibraryError, + (intptr_t loading_unit_id, + const std::string error_message, + bool transient), + (override)); + + MOCK_METHOD(void, + UpdateAssetResolverByType, + (std::unique_ptr updated_asset_resolver, + AssetResolver::AssetResolverType type), + (override)); }; class MockSurface : public Surface { public: - MOCK_METHOD0(IsValid, bool()); + MOCK_METHOD(bool, IsValid, (), (override)); - MOCK_METHOD1(AcquireFrame, - std::unique_ptr(const SkISize& size)); + MOCK_METHOD(std::unique_ptr, + AcquireFrame, + (const SkISize& size), + (override)); - MOCK_CONST_METHOD0(GetRootTransformation, SkMatrix()); + MOCK_METHOD(SkMatrix, GetRootTransformation, (), (const, override)); - MOCK_METHOD0(GetContext, GrDirectContext*()); + MOCK_METHOD(GrDirectContext*, GetContext, (), (override)); - MOCK_METHOD0(MakeRenderContextCurrent, std::unique_ptr()); + MOCK_METHOD(std::unique_ptr, + MakeRenderContextCurrent, + (), + (override)); - MOCK_METHOD0(ClearRenderContext, bool()); + MOCK_METHOD(bool, ClearRenderContext, (), (override)); }; class MockPlatformView : public PlatformView { @@ -143,27 +178,38 @@ class MockPlatformView : public PlatformView { MockPlatformView(MockPlatformViewDelegate& delegate, const TaskRunners& task_runners) : PlatformView(delegate, task_runners) {} - MOCK_METHOD0(CreateRenderingSurface, std::unique_ptr()); - MOCK_CONST_METHOD0(GetPlatformMessageHandler, - std::shared_ptr()); + MOCK_METHOD(std::unique_ptr, CreateRenderingSurface, (), (override)); + MOCK_METHOD(std::shared_ptr, + GetPlatformMessageHandler, + (), + (const, override)); }; class TestPlatformView : public PlatformView { public: TestPlatformView(Shell& shell, const TaskRunners& task_runners) : PlatformView(shell, task_runners) {} - MOCK_METHOD0(CreateRenderingSurface, std::unique_ptr()); + MOCK_METHOD(std::unique_ptr, CreateRenderingSurface, (), (override)); }; class MockPlatformMessageHandler : public PlatformMessageHandler { public: - MOCK_METHOD1(HandlePlatformMessage, - void(std::unique_ptr message)); - MOCK_CONST_METHOD0(DoesHandlePlatformMessageOnPlatformThread, bool()); - MOCK_METHOD2(InvokePlatformMessageResponseCallback, - void(int response_id, std::unique_ptr mapping)); - MOCK_METHOD1(InvokePlatformMessageEmptyResponseCallback, - void(int response_id)); + MOCK_METHOD(void, + HandlePlatformMessage, + (std::unique_ptr message), + (override)); + MOCK_METHOD(bool, + DoesHandlePlatformMessageOnPlatformThread, + (), + (const, override)); + MOCK_METHOD(void, + InvokePlatformMessageResponseCallback, + (int response_id, std::unique_ptr mapping), + (override)); + MOCK_METHOD(void, + InvokePlatformMessageEmptyResponseCallback, + (int response_id), + (override)); }; class MockPlatformMessageResponse : public PlatformMessageResponse { @@ -171,8 +217,8 @@ class MockPlatformMessageResponse : public PlatformMessageResponse { static fml::RefPtr Create() { return fml::AdoptRef(new MockPlatformMessageResponse()); } - MOCK_METHOD1(Complete, void(std::unique_ptr data)); - MOCK_METHOD0(CompleteEmpty, void()); + MOCK_METHOD(void, Complete, (std::unique_ptr data), (override)); + MOCK_METHOD(void, CompleteEmpty, (), (override)); }; } // namespace diff --git a/shell/platform/android/android_context_gl_impeller_unittests.cc b/shell/platform/android/android_context_gl_impeller_unittests.cc index a3dace6e68c7d..452c55fc76261 100644 --- a/shell/platform/android/android_context_gl_impeller_unittests.cc +++ b/shell/platform/android/android_context_gl_impeller_unittests.cc @@ -18,8 +18,11 @@ using ::impeller::egl::ConfigDescriptor; namespace { class MockDisplay : public impeller::egl::Display { public: - MOCK_CONST_METHOD0(IsValid, bool()); - MOCK_CONST_METHOD1(ChooseConfig, std::unique_ptr(ConfigDescriptor)); + MOCK_METHOD(bool, IsValid, (), (const, override)); + MOCK_METHOD(std::unique_ptr, + ChooseConfig, + (ConfigDescriptor), + (const, override)); }; } // namespace diff --git a/shell/platform/android/android_shell_holder_unittests.cc b/shell/platform/android/android_shell_holder_unittests.cc index 242b6c6f20774..849af6b77355c 100644 --- a/shell/platform/android/android_shell_holder_unittests.cc +++ b/shell/platform/android/android_shell_holder_unittests.cc @@ -9,59 +9,95 @@ namespace testing { namespace { class MockPlatformViewAndroidJNI : public PlatformViewAndroidJNI { public: - MOCK_METHOD2(FlutterViewHandlePlatformMessage, - void(std::unique_ptr message, - int responseId)); - MOCK_METHOD2(FlutterViewHandlePlatformMessageResponse, - void(int responseId, std::unique_ptr data)); - MOCK_METHOD3(FlutterViewUpdateSemantics, - void(std::vector buffer, - std::vector strings, - std::vector> string_attribute_args)); - MOCK_METHOD2(FlutterViewUpdateCustomAccessibilityActions, - void(std::vector actions_buffer, - std::vector strings)); - MOCK_METHOD0(FlutterViewOnFirstFrame, void()); - MOCK_METHOD0(FlutterViewOnPreEngineRestart, void()); - MOCK_METHOD2(SurfaceTextureAttachToGLContext, - void(JavaLocalRef surface_texture, int textureId)); - MOCK_METHOD1(SurfaceTextureUpdateTexImage, - void(JavaLocalRef surface_texture)); - MOCK_METHOD2(SurfaceTextureGetTransformMatrix, - void(JavaLocalRef surface_texture, SkMatrix& transform)); - MOCK_METHOD1(SurfaceTextureDetachFromGLContext, - void(JavaLocalRef surface_texture)); - MOCK_METHOD1(ImageTextureEntryAcquireLatestImage, - JavaLocalRef(JavaLocalRef image_texture_entry)); - MOCK_METHOD1(ImageGetHardwareBuffer, JavaLocalRef(JavaLocalRef image)); - MOCK_METHOD1(ImageClose, void(JavaLocalRef image)); - MOCK_METHOD1(HardwareBufferClose, void(JavaLocalRef hardware_buffer)); - MOCK_METHOD8(FlutterViewOnDisplayPlatformView, - void(int view_id, - int x, - int y, - int width, - int height, - int viewWidth, - int viewHeight, - MutatorsStack mutators_stack)); - MOCK_METHOD5(FlutterViewDisplayOverlaySurface, - void(int surface_id, int x, int y, int width, int height)); - MOCK_METHOD0(FlutterViewBeginFrame, void()); - MOCK_METHOD0(FlutterViewEndFrame, void()); - MOCK_METHOD0(FlutterViewCreateOverlaySurface, - std::unique_ptr()); - MOCK_METHOD0(FlutterViewDestroyOverlaySurfaces, void()); - MOCK_METHOD1(FlutterViewComputePlatformResolvedLocale, - std::unique_ptr>( - std::vector supported_locales_data)); - MOCK_METHOD0(GetDisplayRefreshRate, double()); - MOCK_METHOD0(GetDisplayWidth, double()); - MOCK_METHOD0(GetDisplayHeight, double()); - MOCK_METHOD0(GetDisplayDensity, double()); - MOCK_METHOD1(RequestDartDeferredLibrary, bool(int loading_unit_id)); - MOCK_CONST_METHOD2(FlutterViewGetScaledFontSize, - double(double font_size, int configuration_id)); + MOCK_METHOD(void, + FlutterViewHandlePlatformMessage, + (std::unique_ptr message, + int responseId), + (override)); + MOCK_METHOD(void, + FlutterViewHandlePlatformMessageResponse, + (int responseId, std::unique_ptr data), + (override)); + MOCK_METHOD(void, + FlutterViewUpdateSemantics, + (std::vector buffer, + std::vector strings, + std::vector> string_attribute_args), + (override)); + MOCK_METHOD(void, + FlutterViewUpdateCustomAccessibilityActions, + (std::vector actions_buffer, + std::vector strings), + (override)); + MOCK_METHOD(void, FlutterViewOnFirstFrame, (), (override)); + MOCK_METHOD(void, FlutterViewOnPreEngineRestart, (), (override)); + MOCK_METHOD(void, + SurfaceTextureAttachToGLContext, + (JavaLocalRef surface_texture, int textureId), + (override)); + MOCK_METHOD(void, + SurfaceTextureUpdateTexImage, + (JavaLocalRef surface_texture), + (override)); + MOCK_METHOD(void, + SurfaceTextureGetTransformMatrix, + (JavaLocalRef surface_texture, SkMatrix& transform), + (override)); + MOCK_METHOD(void, + SurfaceTextureDetachFromGLContext, + (JavaLocalRef surface_texture), + (override)); + MOCK_METHOD(JavaLocalRef, + ImageTextureEntryAcquireLatestImage, + (JavaLocalRef image_texture_entry), + (override)); + MOCK_METHOD(JavaLocalRef, + ImageGetHardwareBuffer, + (JavaLocalRef image), + (override)); + MOCK_METHOD(void, ImageClose, (JavaLocalRef image), (override)); + MOCK_METHOD(void, + HardwareBufferClose, + (JavaLocalRef hardware_buffer), + (override)); + MOCK_METHOD(void, + FlutterViewOnDisplayPlatformView, + (int view_id, + int x, + int y, + int width, + int height, + int viewWidth, + int viewHeight, + MutatorsStack mutators_stack), + (override)); + MOCK_METHOD(void, + FlutterViewDisplayOverlaySurface, + (int surface_id, int x, int y, int width, int height), + (override)); + MOCK_METHOD(void, FlutterViewBeginFrame, (), (override)); + MOCK_METHOD(void, FlutterViewEndFrame, (), (override)); + MOCK_METHOD(std::unique_ptr, + FlutterViewCreateOverlaySurface, + (), + (override)); + MOCK_METHOD(void, FlutterViewDestroyOverlaySurfaces, (), (override)); + MOCK_METHOD(std::unique_ptr>, + FlutterViewComputePlatformResolvedLocale, + (std::vector supported_locales_data), + (override)); + MOCK_METHOD(double, GetDisplayRefreshRate, (), (override)); + MOCK_METHOD(double, GetDisplayWidth, (), (override)); + MOCK_METHOD(double, GetDisplayHeight, (), (override)); + MOCK_METHOD(double, GetDisplayDensity, (), (override)); + MOCK_METHOD(bool, + RequestDartDeferredLibrary, + (int loading_unit_id), + (override)); + MOCK_METHOD(double, + FlutterViewGetScaledFontSize, + (double font_size, int configuration_id), + (const, override)); }; class MockPlatformMessageResponse : public PlatformMessageResponse { @@ -69,8 +105,8 @@ class MockPlatformMessageResponse : public PlatformMessageResponse { static fml::RefPtr Create() { return fml::AdoptRef(new MockPlatformMessageResponse()); } - MOCK_METHOD1(Complete, void(std::unique_ptr data)); - MOCK_METHOD0(CompleteEmpty, void()); + MOCK_METHOD(void, Complete, (std::unique_ptr data), (override)); + MOCK_METHOD(void, CompleteEmpty, (), (override)); }; } // namespace diff --git a/shell/platform/android/apk_asset_provider_unittests.cc b/shell/platform/android/apk_asset_provider_unittests.cc index 888e70b374317..c5f82e65091a7 100644 --- a/shell/platform/android/apk_asset_provider_unittests.cc +++ b/shell/platform/android/apk_asset_provider_unittests.cc @@ -6,9 +6,10 @@ namespace flutter { namespace testing { class MockAPKAssetProviderImpl : public APKAssetProviderInternal { public: - MOCK_CONST_METHOD1( - GetAsMapping, - std::unique_ptr(const std::string& asset_name)); + MOCK_METHOD(std::unique_ptr, + GetAsMapping, + (const std::string& asset_name), + (const, override)); }; TEST(APKAssetProvider, Clone) { diff --git a/shell/platform/common/client_wrapper/standard_message_codec_unittests.cc b/shell/platform/common/client_wrapper/standard_message_codec_unittests.cc index df02aae2e77f9..afe7247025f58 100644 --- a/shell/platform/common/client_wrapper/standard_message_codec_unittests.cc +++ b/shell/platform/common/client_wrapper/standard_message_codec_unittests.cc @@ -17,11 +17,14 @@ namespace { class MockStandardCodecSerializer : public StandardCodecSerializer { public: - MOCK_CONST_METHOD2(WriteValue, - void(const EncodableValue& value, - ByteStreamWriter* stream)); - MOCK_CONST_METHOD2(ReadValueOfType, - EncodableValue(uint8_t type, ByteStreamReader* stream)); + MOCK_METHOD(void, + WriteValue, + (const EncodableValue& value, ByteStreamWriter* stream), + (const, override)); + MOCK_METHOD(EncodableValue, + ReadValueOfType, + (uint8_t type, ByteStreamReader* stream), + (const, override)); }; } // namespace diff --git a/shell/platform/embedder/platform_view_embedder_unittests.cc b/shell/platform/embedder/platform_view_embedder_unittests.cc index d22dc030e7292..d5d2538a1ccdc 100644 --- a/shell/platform/embedder/platform_view_embedder_unittests.cc +++ b/shell/platform/embedder/platform_view_embedder_unittests.cc @@ -16,46 +16,79 @@ namespace flutter { namespace testing { namespace { class MockDelegate : public PlatformView::Delegate { - MOCK_METHOD1(OnPlatformViewCreated, void(std::unique_ptr)); - MOCK_METHOD0(OnPlatformViewDestroyed, void()); - MOCK_METHOD0(OnPlatformViewScheduleFrame, void()); - MOCK_METHOD1(OnPlatformViewSetNextFrameCallback, - void(const fml::closure& closure)); - MOCK_METHOD2(OnPlatformViewSetViewportMetrics, - void(int64_t view_id, const ViewportMetrics& metrics)); - MOCK_METHOD1(OnPlatformViewDispatchPlatformMessage, - void(std::unique_ptr message)); - MOCK_METHOD1(OnPlatformViewDispatchPointerDataPacket, - void(std::unique_ptr packet)); - MOCK_METHOD3(OnPlatformViewDispatchSemanticsAction, - void(int32_t id, - SemanticsAction action, - fml::MallocMapping args)); - MOCK_METHOD1(OnPlatformViewSetSemanticsEnabled, void(bool enabled)); - MOCK_METHOD1(OnPlatformViewSetAccessibilityFeatures, void(int32_t flags)); - MOCK_METHOD1(OnPlatformViewRegisterTexture, - void(std::shared_ptr texture)); - MOCK_METHOD1(OnPlatformViewUnregisterTexture, void(int64_t texture_id)); - MOCK_METHOD1(OnPlatformViewMarkTextureFrameAvailable, - void(int64_t texture_id)); - MOCK_METHOD3(LoadDartDeferredLibrary, - void(intptr_t loading_unit_id, - std::unique_ptr snapshot_data, - std::unique_ptr snapshot_instructions)); - MOCK_METHOD3(LoadDartDeferredLibraryError, - void(intptr_t loading_unit_id, - const std::string error_message, - bool transient)); - MOCK_METHOD2(UpdateAssetResolverByType, - void(std::unique_ptr updated_asset_resolver, - AssetResolver::AssetResolverType type)); - MOCK_CONST_METHOD0(OnPlatformViewGetSettings, const Settings&()); + MOCK_METHOD(void, + OnPlatformViewCreated, + (std::unique_ptr), + (override)); + MOCK_METHOD(void, OnPlatformViewDestroyed, (), (override)); + MOCK_METHOD(void, OnPlatformViewScheduleFrame, (), (override)); + MOCK_METHOD(void, + OnPlatformViewSetNextFrameCallback, + (const fml::closure& closure), + (override)); + MOCK_METHOD(void, + OnPlatformViewSetViewportMetrics, + (int64_t view_id, const ViewportMetrics& metrics), + (override)); + MOCK_METHOD(void, + OnPlatformViewDispatchPlatformMessage, + (std::unique_ptr message), + (override)); + MOCK_METHOD(void, + OnPlatformViewDispatchPointerDataPacket, + (std::unique_ptr packet), + (override)); + MOCK_METHOD(void, + OnPlatformViewDispatchSemanticsAction, + (int32_t id, SemanticsAction action, fml::MallocMapping args), + (override)); + MOCK_METHOD(void, + OnPlatformViewSetSemanticsEnabled, + (bool enabled), + (override)); + MOCK_METHOD(void, + OnPlatformViewSetAccessibilityFeatures, + (int32_t flags), + (override)); + MOCK_METHOD(void, + OnPlatformViewRegisterTexture, + (std::shared_ptr texture), + (override)); + MOCK_METHOD(void, + OnPlatformViewUnregisterTexture, + (int64_t texture_id), + (override)); + MOCK_METHOD(void, + OnPlatformViewMarkTextureFrameAvailable, + (int64_t texture_id), + (override)); + MOCK_METHOD(void, + LoadDartDeferredLibrary, + (intptr_t loading_unit_id, + std::unique_ptr snapshot_data, + std::unique_ptr snapshot_instructions), + (override)); + MOCK_METHOD(void, + LoadDartDeferredLibraryError, + (intptr_t loading_unit_id, + const std::string error_message, + bool transient), + (override)); + MOCK_METHOD(void, + UpdateAssetResolverByType, + (std::unique_ptr updated_asset_resolver, + AssetResolver::AssetResolverType type), + (override)); + MOCK_METHOD(const Settings&, + OnPlatformViewGetSettings, + (), + (const, override)); }; class MockResponse : public PlatformMessageResponse { public: - MOCK_METHOD1(Complete, void(std::unique_ptr data)); - MOCK_METHOD0(CompleteEmpty, void()); + MOCK_METHOD(void, Complete, (std::unique_ptr data), (override)); + MOCK_METHOD(void, CompleteEmpty, (), (override)); }; } // namespace diff --git a/shell/platform/fuchsia/flutter/tests/platform_view_unittest.cc b/shell/platform/fuchsia/flutter/tests/platform_view_unittest.cc index c6b8f7c7b2886..f19c04ba56bc2 100644 --- a/shell/platform/fuchsia/flutter/tests/platform_view_unittest.cc +++ b/shell/platform/fuchsia/flutter/tests/platform_view_unittest.cc @@ -176,8 +176,8 @@ class MockPlatformViewDelegate : public flutter::PlatformView::Delegate { class MockResponse : public flutter::PlatformMessageResponse { public: - MOCK_METHOD1(Complete, void(std::unique_ptr data)); - MOCK_METHOD0(CompleteEmpty, void()); + MOCK_METHOD(void, Complete, (std::unique_ptr data), (override)); + MOCK_METHOD(void, CompleteEmpty, (), (override)); }; class TestPlatformMessageResponse : public flutter::PlatformMessageResponse { diff --git a/shell/platform/linux/testing/mock_binary_messenger.h b/shell/platform/linux/testing/mock_binary_messenger.h index f48a8999a4e4d..e26a3cf1c7463 100644 --- a/shell/platform/linux/testing/mock_binary_messenger.h +++ b/shell/platform/linux/testing/mock_binary_messenger.h @@ -22,41 +22,47 @@ class MockBinaryMessenger { operator FlBinaryMessenger*(); - MOCK_METHOD5(fl_binary_messenger_set_message_handler_on_channel, - void(FlBinaryMessenger* messenger, - const gchar* channel, - FlBinaryMessengerMessageHandler handler, - gpointer user_data, - GDestroyNotify destroy_notify)); - - MOCK_METHOD4(fl_binary_messenger_send_response, - gboolean(FlBinaryMessenger* messenger, - FlBinaryMessengerResponseHandle* response_handle, - GBytes* response, - GError** error)); - - MOCK_METHOD6(fl_binary_messenger_send_on_channel, - void(FlBinaryMessenger* messenger, - const gchar* channel, - GBytes* message, - GCancellable* cancellable, - GAsyncReadyCallback callback, - gpointer user_data)); - - MOCK_METHOD3(fl_binary_messenger_send_on_channel_finish, - GBytes*(FlBinaryMessenger* messenger, - GAsyncResult* result, - GError** error)); - - MOCK_METHOD3(fl_binary_messenger_resize_channel, - void(FlBinaryMessenger* messenger, - const gchar* channel, - int64_t new_size)); - - MOCK_METHOD3(fl_binary_messenger_set_allow_channel_overflow, - void(FlBinaryMessenger* messenger, - const gchar* channel, - bool allowed)); + MOCK_METHOD(void, + fl_binary_messenger_set_message_handler_on_channel, + (FlBinaryMessenger * messenger, + const gchar* channel, + FlBinaryMessengerMessageHandler handler, + gpointer user_data, + GDestroyNotify destroy_notify)); + + MOCK_METHOD(gboolean, + fl_binary_messenger_send_response, + (FlBinaryMessenger * messenger, + FlBinaryMessengerResponseHandle* response_handle, + GBytes* response, + GError** error)); + + MOCK_METHOD(void, + fl_binary_messenger_send_on_channel, + (FlBinaryMessenger * messenger, + const gchar* channel, + GBytes* message, + GCancellable* cancellable, + GAsyncReadyCallback callback, + gpointer user_data)); + + MOCK_METHOD(GBytes*, + fl_binary_messenger_send_on_channel_finish, + (FlBinaryMessenger * messenger, + GAsyncResult* result, + GError** error)); + + MOCK_METHOD(void, + fl_binary_messenger_resize_channel, + (FlBinaryMessenger * messenger, + const gchar* channel, + int64_t new_size)); + + MOCK_METHOD(void, + fl_binary_messenger_set_allow_channel_overflow, + (FlBinaryMessenger * messenger, + const gchar* channel, + bool allowed)); bool HasMessageHandler(const gchar* channel) const; diff --git a/shell/platform/linux/testing/mock_im_context.h b/shell/platform/linux/testing/mock_im_context.h index 40dd0128ad6ef..212631b78d1e2 100644 --- a/shell/platform/linux/testing/mock_im_context.h +++ b/shell/platform/linux/testing/mock_im_context.h @@ -18,31 +18,34 @@ class MockIMContext { operator GtkIMContext*(); - MOCK_METHOD2(gtk_im_context_set_client_window, - void(GtkIMContext* context, GdkWindow* window)); - MOCK_METHOD4(gtk_im_context_get_preedit_string, - void(GtkIMContext* context, - gchar** str, - PangoAttrList** attrs, - gint* cursor_pos)); - MOCK_METHOD2(gtk_im_context_filter_keypress, - gboolean(GtkIMContext* context, GdkEventKey* event)); - MOCK_METHOD1(gtk_im_context_focus_in, gboolean(GtkIMContext* context)); - MOCK_METHOD1(gtk_im_context_focus_out, void(GtkIMContext* context)); - MOCK_METHOD1(gtk_im_context_reset, void(GtkIMContext* context)); - MOCK_METHOD2(gtk_im_context_set_cursor_location, - void(GtkIMContext* context, GdkRectangle* area)); - MOCK_METHOD2(gtk_im_context_set_use_preedit, - void(GtkIMContext* context, gboolean use_preedit)); - MOCK_METHOD4(gtk_im_context_set_surrounding, - void(GtkIMContext* context, - const gchar* text, - gint len, - gint cursor_index)); - MOCK_METHOD3(gtk_im_context_get_surrounding, - gboolean(GtkIMContext* context, - gchar** text, - gint* cursor_index)); + MOCK_METHOD(void, + gtk_im_context_set_client_window, + (GtkIMContext * context, GdkWindow* window)); + MOCK_METHOD(void, + gtk_im_context_get_preedit_string, + (GtkIMContext * context, + gchar** str, + PangoAttrList** attrs, + gint* cursor_pos)); + MOCK_METHOD(gboolean, + gtk_im_context_filter_keypress, + (GtkIMContext * context, GdkEventKey* event)); + MOCK_METHOD(gboolean, gtk_im_context_focus_in, (GtkIMContext * context)); + MOCK_METHOD(void, gtk_im_context_focus_out, (GtkIMContext * context)); + MOCK_METHOD(void, gtk_im_context_reset, (GtkIMContext * context)); + MOCK_METHOD(void, + gtk_im_context_set_cursor_location, + (GtkIMContext * context, GdkRectangle* area)); + MOCK_METHOD(void, + gtk_im_context_set_use_preedit, + (GtkIMContext * context, gboolean use_preedit)); + MOCK_METHOD( + void, + gtk_im_context_set_surrounding, + (GtkIMContext * context, const gchar* text, gint len, gint cursor_index)); + MOCK_METHOD(gboolean, + gtk_im_context_get_surrounding, + (GtkIMContext * context, gchar** text, gint* cursor_index)); private: GtkIMContext* instance_ = nullptr; diff --git a/shell/platform/linux/testing/mock_settings.h b/shell/platform/linux/testing/mock_settings.h index 57636b3ad11ff..51f882b80e511 100644 --- a/shell/platform/linux/testing/mock_settings.h +++ b/shell/platform/linux/testing/mock_settings.h @@ -20,18 +20,21 @@ class MockSettings { operator FlSettings*(); - MOCK_METHOD1(fl_settings_get_clock_format, - FlClockFormat(FlSettings* settings)); + MOCK_METHOD(FlClockFormat, + fl_settings_get_clock_format, + (FlSettings * settings)); - MOCK_METHOD1(fl_settings_get_color_scheme, - FlColorScheme(FlSettings* settings)); + MOCK_METHOD(FlColorScheme, + fl_settings_get_color_scheme, + (FlSettings * settings)); - MOCK_METHOD1(fl_settings_get_enable_animations, bool(FlSettings* settings)); + MOCK_METHOD(bool, fl_settings_get_enable_animations, (FlSettings * settings)); - MOCK_METHOD1(fl_settings_get_high_contrast, bool(FlSettings* settings)); + MOCK_METHOD(bool, fl_settings_get_high_contrast, (FlSettings * settings)); - MOCK_METHOD1(fl_settings_get_text_scaling_factor, - gdouble(FlSettings* settings)); + MOCK_METHOD(gdouble, + fl_settings_get_text_scaling_factor, + (FlSettings * settings)); private: FlSettings* instance_ = nullptr; diff --git a/shell/platform/linux/testing/mock_signal_handler.h b/shell/platform/linux/testing/mock_signal_handler.h index e1e92895da4bd..1eb60175406e9 100644 --- a/shell/platform/linux/testing/mock_signal_handler.h +++ b/shell/platform/linux/testing/mock_signal_handler.h @@ -50,7 +50,7 @@ class MockSignalHandler : public SignalHandler { MockSignalHandler(gpointer instance, const gchar* name) : SignalHandler(instance, name, G_CALLBACK(OnSignal)) {} - MOCK_METHOD0(Handler, void()); + MOCK_METHOD(void, Handler, ()); private: static void OnSignal(MockSignalHandler* mock) { mock->Handler(); } @@ -63,7 +63,7 @@ class MockSignalHandler1 : public SignalHandler { MockSignalHandler1(gpointer instance, const gchar* name) : SignalHandler(instance, name, G_CALLBACK(OnSignal1)) {} - MOCK_METHOD1(Handler1, void(A1 a1)); + MOCK_METHOD(void, Handler1, (A1 a1)); private: static void OnSignal1(MockSignalHandler1* mock, A1 a1) { mock->Handler1(a1); } @@ -76,7 +76,7 @@ class MockSignalHandler2 : public SignalHandler { MockSignalHandler2(gpointer instance, const gchar* name) : SignalHandler(instance, name, G_CALLBACK(OnSignal2)) {} - MOCK_METHOD2(Handler2, void(A1 a1, A2 a2)); + MOCK_METHOD(void, Handler2, (A1 a1, A2 a2)); private: static void OnSignal2(MockSignalHandler2* mock, A1 a1, A2 a2) { diff --git a/shell/platform/linux/testing/mock_text_input_view_delegate.h b/shell/platform/linux/testing/mock_text_input_view_delegate.h index ae43045e15d92..19a32d0f8379a 100644 --- a/shell/platform/linux/testing/mock_text_input_view_delegate.h +++ b/shell/platform/linux/testing/mock_text_input_view_delegate.h @@ -22,12 +22,13 @@ class MockTextInputViewDelegate { operator FlTextInputViewDelegate*(); - MOCK_METHOD5(fl_text_input_view_delegate_translate_coordinates, - void(FlTextInputViewDelegate* delegate, - gint view_x, - gint view_y, - gint* window_x, - gint* window_y)); + MOCK_METHOD(void, + fl_text_input_view_delegate_translate_coordinates, + (FlTextInputViewDelegate * delegate, + gint view_x, + gint view_y, + gint* window_x, + gint* window_y)); private: FlTextInputViewDelegate* instance_ = nullptr; diff --git a/shell/platform/windows/flutter_window_unittests.cc b/shell/platform/windows/flutter_window_unittests.cc index 2c988d26e4763..473cc485ff7f1 100644 --- a/shell/platform/windows/flutter_window_unittests.cc +++ b/shell/platform/windows/flutter_window_unittests.cc @@ -44,29 +44,40 @@ class MockFlutterWindow : public FlutterWindow { return HandleMessage(message, wparam, lparam); } - MOCK_METHOD1(OnDpiScale, void(unsigned int)); - MOCK_METHOD2(OnResize, void(unsigned int, unsigned int)); - MOCK_METHOD4(OnPointerMove, - void(double, double, FlutterPointerDeviceKind, int32_t)); - MOCK_METHOD5(OnPointerDown, - void(double, double, FlutterPointerDeviceKind, int32_t, UINT)); - MOCK_METHOD5(OnPointerUp, - void(double, double, FlutterPointerDeviceKind, int32_t, UINT)); - MOCK_METHOD4(OnPointerLeave, - void(double, double, FlutterPointerDeviceKind, int32_t)); - MOCK_METHOD0(OnSetCursor, void()); - MOCK_METHOD0(GetScrollOffsetMultiplier, float()); - MOCK_METHOD0(GetHighContrastEnabled, bool()); - MOCK_METHOD0(GetDpiScale, float()); - MOCK_METHOD0(IsVisible, bool()); - MOCK_METHOD1(UpdateCursorRect, void(const Rect&)); - MOCK_METHOD0(OnResetImeComposing, void()); - MOCK_METHOD3(Win32DispatchMessage, UINT(UINT, WPARAM, LPARAM)); - MOCK_METHOD4(Win32PeekMessage, BOOL(LPMSG, UINT, UINT, UINT)); - MOCK_METHOD1(Win32MapVkToChar, uint32_t(uint32_t)); - MOCK_METHOD0(GetPlatformWindow, HWND()); - MOCK_METHOD0(GetAxFragmentRootDelegate, ui::AXFragmentRootDelegateWin*()); - MOCK_METHOD1(OnWindowStateEvent, void(WindowStateEvent)); + MOCK_METHOD(void, OnDpiScale, (unsigned int), (override)); + MOCK_METHOD(void, OnResize, (unsigned int, unsigned int), (override)); + MOCK_METHOD(void, + OnPointerMove, + (double, double, FlutterPointerDeviceKind, int32_t), + (override)); + MOCK_METHOD(void, + OnPointerDown, + (double, double, FlutterPointerDeviceKind, int32_t, UINT), + (override)); + MOCK_METHOD(void, + OnPointerUp, + (double, double, FlutterPointerDeviceKind, int32_t, UINT), + (override)); + MOCK_METHOD(void, + OnPointerLeave, + (double, double, FlutterPointerDeviceKind, int32_t), + (override)); + MOCK_METHOD(void, OnSetCursor, (), (override)); + MOCK_METHOD(float, GetScrollOffsetMultiplier, (), (override)); + MOCK_METHOD(bool, GetHighContrastEnabled, (), (override)); + MOCK_METHOD(float, GetDpiScale, (), (override)); + MOCK_METHOD(bool, IsVisible, (), (override)); + MOCK_METHOD(void, UpdateCursorRect, (const Rect&), (override)); + MOCK_METHOD(void, OnResetImeComposing, (), (override)); + MOCK_METHOD(UINT, Win32DispatchMessage, (UINT, WPARAM, LPARAM), (override)); + MOCK_METHOD(BOOL, Win32PeekMessage, (LPMSG, UINT, UINT, UINT), (override)); + MOCK_METHOD(uint32_t, Win32MapVkToChar, (uint32_t), (override)); + MOCK_METHOD(HWND, GetPlatformWindow, (), (override)); + MOCK_METHOD(ui::AXFragmentRootDelegateWin*, + GetAxFragmentRootDelegate, + (), + (override)); + MOCK_METHOD(void, OnWindowStateEvent, (WindowStateEvent), (override)); protected: // |KeyboardManager::WindowDelegate| @@ -88,8 +99,10 @@ class MockFlutterWindowsView : public FlutterWindowsView { : FlutterWindowsView(std::move(window_binding)) {} ~MockFlutterWindowsView() {} - MOCK_METHOD2(NotifyWinEventWrapper, - void(ui::AXPlatformNodeWin*, ax::mojom::Event)); + MOCK_METHOD(void, + NotifyWinEventWrapper, + (ui::AXPlatformNodeWin*, ax::mojom::Event), + (override)); private: FML_DISALLOW_COPY_AND_ASSIGN(MockFlutterWindowsView); diff --git a/shell/platform/windows/flutter_windows_engine_unittests.cc b/shell/platform/windows/flutter_windows_engine_unittests.cc index f812460989789..96e0a010629b7 100644 --- a/shell/platform/windows/flutter_windows_engine_unittests.cc +++ b/shell/platform/windows/flutter_windows_engine_unittests.cc @@ -606,9 +606,11 @@ class MockFlutterWindowsView : public FlutterWindowsView { : FlutterWindowsView(std::move(wbh)) {} ~MockFlutterWindowsView() {} - MOCK_METHOD2(NotifyWinEventWrapper, - void(ui::AXPlatformNodeWin*, ax::mojom::Event)); - MOCK_METHOD0(GetPlatformWindow, HWND()); + MOCK_METHOD(void, + NotifyWinEventWrapper, + (ui::AXPlatformNodeWin*, ax::mojom::Event), + (override)); + MOCK_METHOD(HWND, GetPlatformWindow, (), (override)); private: FML_DISALLOW_COPY_AND_ASSIGN(MockFlutterWindowsView); @@ -662,14 +664,14 @@ class MockWindowsLifecycleManager : public WindowsLifecycleManager { : WindowsLifecycleManager(engine) {} virtual ~MockWindowsLifecycleManager() {} - MOCK_METHOD4(Quit, - void(std::optional, - std::optional, - std::optional, - UINT)); - MOCK_METHOD4(DispatchMessage, void(HWND, UINT, WPARAM, LPARAM)); - MOCK_METHOD0(IsLastWindowOfProcess, bool(void)); - MOCK_METHOD1(SetLifecycleState, void(AppLifecycleState)); + MOCK_METHOD( + void, + Quit, + (std::optional, std::optional, std::optional, UINT), + (override)); + MOCK_METHOD(void, DispatchMessage, (HWND, UINT, WPARAM, LPARAM), (override)); + MOCK_METHOD(bool, IsLastWindowOfProcess, (void), (override)); + MOCK_METHOD(void, SetLifecycleState, (AppLifecycleState), (override)); void BeginProcessingLifecycle() override { WindowsLifecycleManager::BeginProcessingLifecycle(); diff --git a/shell/platform/windows/flutter_windows_view_unittests.cc b/shell/platform/windows/flutter_windows_view_unittests.cc index 850f2708d8dae..ef86fa9a29073 100644 --- a/shell/platform/windows/flutter_windows_view_unittests.cc +++ b/shell/platform/windows/flutter_windows_view_unittests.cc @@ -110,7 +110,7 @@ class MockFlutterWindowsEngine : public FlutterWindowsEngine { public: MockFlutterWindowsEngine() : FlutterWindowsEngine(GetTestProject()) {} - MOCK_METHOD0(Stop, bool()); + MOCK_METHOD(bool, Stop, (), (override)); private: FML_DISALLOW_COPY_AND_ASSIGN(MockFlutterWindowsEngine); @@ -120,11 +120,17 @@ class MockAngleSurfaceManager : public AngleSurfaceManager { public: MockAngleSurfaceManager() : AngleSurfaceManager(false) {} - MOCK_METHOD4(CreateSurface, bool(WindowsRenderTarget*, EGLint, EGLint, bool)); - MOCK_METHOD4(ResizeSurface, void(WindowsRenderTarget*, EGLint, EGLint, bool)); - MOCK_METHOD0(DestroySurface, void()); - - MOCK_METHOD1(SetVSyncEnabled, void(bool)); + MOCK_METHOD(bool, + CreateSurface, + (WindowsRenderTarget*, EGLint, EGLint, bool), + (override)); + MOCK_METHOD(void, + ResizeSurface, + (WindowsRenderTarget*, EGLint, EGLint, bool), + (override)); + MOCK_METHOD(void, DestroySurface, (), (override)); + + MOCK_METHOD(void, SetVSyncEnabled, (bool), (override)); private: FML_DISALLOW_COPY_AND_ASSIGN(MockAngleSurfaceManager); diff --git a/shell/platform/windows/platform_handler_unittests.cc b/shell/platform/windows/platform_handler_unittests.cc index 7de94392b51b7..d900cc48a30fa 100644 --- a/shell/platform/windows/platform_handler_unittests.cc +++ b/shell/platform/windows/platform_handler_unittests.cc @@ -70,23 +70,33 @@ class MockPlatformHandler : public PlatformHandler { virtual ~MockPlatformHandler() = default; - MOCK_METHOD2(GetPlainText, - void(std::unique_ptr>, - std::string_view key)); - MOCK_METHOD1(GetHasStrings, - void(std::unique_ptr>)); - MOCK_METHOD2(SetPlainText, - void(const std::string&, - std::unique_ptr>)); - MOCK_METHOD2(SystemSoundPlay, - void(const std::string&, - std::unique_ptr>)); - - MOCK_METHOD4(QuitApplication, - void(std::optional hwnd, - std::optional wparam, - std::optional lparam, - UINT exit_code)); + MOCK_METHOD(void, + GetPlainText, + (std::unique_ptr>, + std::string_view key), + (override)); + MOCK_METHOD(void, + GetHasStrings, + (std::unique_ptr>), + (override)); + MOCK_METHOD(void, + SetPlainText, + (const std::string&, + std::unique_ptr>), + (override)); + MOCK_METHOD(void, + SystemSoundPlay, + (const std::string&, + std::unique_ptr>), + (override)); + + MOCK_METHOD(void, + QuitApplication, + (std::optional hwnd, + std::optional wparam, + std::optional lparam, + UINT exit_code), + (override)); private: FML_DISALLOW_COPY_AND_ASSIGN(MockPlatformHandler); diff --git a/shell/platform/windows/settings_plugin_unittests.cc b/shell/platform/windows/settings_plugin_unittests.cc index 78060ad29c055..aebe3ff6c256f 100644 --- a/shell/platform/windows/settings_plugin_unittests.cc +++ b/shell/platform/windows/settings_plugin_unittests.cc @@ -26,12 +26,12 @@ class MockSettingsPlugin : public SettingsPlugin { bool is_high_contrast() { return is_high_contrast_; } // |SettingsPlugin| - MOCK_METHOD0(GetAlwaysUse24HourFormat, bool()); - MOCK_METHOD0(GetTextScaleFactor, float()); - MOCK_METHOD0(GetPreferredBrightness, PlatformBrightness()); + MOCK_METHOD(bool, GetAlwaysUse24HourFormat, (), (override)); + MOCK_METHOD(float, GetTextScaleFactor, (), (override)); + MOCK_METHOD(PlatformBrightness, GetPreferredBrightness, (), (override)); - MOCK_METHOD0(WatchPreferredBrightnessChanged, void()); - MOCK_METHOD0(WatchTextScaleFactorChanged, void()); + MOCK_METHOD(void, WatchPreferredBrightnessChanged, (), (override)); + MOCK_METHOD(void, WatchTextScaleFactorChanged, (), (override)); private: FML_DISALLOW_COPY_AND_ASSIGN(MockSettingsPlugin); diff --git a/shell/platform/windows/testing/mock_direct_manipulation.h b/shell/platform/windows/testing/mock_direct_manipulation.h index 6b0faa93480ec..ecf1f7bea9a9a 100644 --- a/shell/platform/windows/testing/mock_direct_manipulation.h +++ b/shell/platform/windows/testing/mock_direct_manipulation.h @@ -19,7 +19,7 @@ class MockDirectManipulationOwner : public DirectManipulationOwner { : DirectManipulationOwner(window){}; virtual ~MockDirectManipulationOwner() = default; - MOCK_METHOD1(SetContact, void(UINT contact_id)); + MOCK_METHOD(void, SetContact, (UINT contact_id), (override)); private: FML_DISALLOW_COPY_AND_ASSIGN(MockDirectManipulationOwner); diff --git a/shell/platform/windows/testing/mock_text_input_manager.h b/shell/platform/windows/testing/mock_text_input_manager.h index a6f0d12bcf488..d71dd504a59d8 100644 --- a/shell/platform/windows/testing/mock_text_input_manager.h +++ b/shell/platform/windows/testing/mock_text_input_manager.h @@ -21,9 +21,15 @@ class MockTextInputManager : public TextInputManager { MockTextInputManager(); virtual ~MockTextInputManager(); - MOCK_CONST_METHOD0(GetComposingString, std::optional()); - MOCK_CONST_METHOD0(GetResultString, std::optional()); - MOCK_CONST_METHOD0(GetComposingCursorPosition, long()); + MOCK_METHOD(std::optional, + GetComposingString, + (), + (const, override)); + MOCK_METHOD(std::optional, + GetResultString, + (), + (const, override)); + MOCK_METHOD(long, GetComposingCursorPosition, (), (const, override)); private: FML_DISALLOW_COPY_AND_ASSIGN(MockTextInputManager); diff --git a/shell/platform/windows/testing/mock_window.h b/shell/platform/windows/testing/mock_window.h index 4294476d91750..b363824a08e4b 100644 --- a/shell/platform/windows/testing/mock_window.h +++ b/shell/platform/windows/testing/mock_window.h @@ -35,38 +35,59 @@ class MockWindow : public Window { void InjectMessageList(int count, const Win32Message* messages); - MOCK_METHOD1(OnDpiScale, void(unsigned int)); - MOCK_METHOD2(OnResize, void(unsigned int, unsigned int)); - MOCK_METHOD0(OnPaint, void()); - MOCK_METHOD5(OnPointerMove, - void(double, double, FlutterPointerDeviceKind, int32_t, int)); - MOCK_METHOD5(OnPointerDown, - void(double, double, FlutterPointerDeviceKind, int32_t, UINT)); - MOCK_METHOD5(OnPointerUp, - void(double, double, FlutterPointerDeviceKind, int32_t, UINT)); - MOCK_METHOD4(OnPointerLeave, - void(double, double, FlutterPointerDeviceKind, int32_t)); - MOCK_METHOD0(OnSetCursor, void()); - MOCK_METHOD1(OnText, void(const std::u16string&)); - MOCK_METHOD7(OnKey, - void(int, int, int, char32_t, bool, bool, KeyEventCallback)); - MOCK_METHOD1(OnUpdateSemanticsEnabled, void(bool)); - MOCK_METHOD0(GetNativeViewAccessible, gfx::NativeViewAccessible()); - MOCK_METHOD4(OnScroll, - void(double, double, FlutterPointerDeviceKind, int32_t)); - MOCK_METHOD0(OnComposeBegin, void()); - MOCK_METHOD0(OnComposeCommit, void()); - MOCK_METHOD0(OnComposeEnd, void()); - MOCK_METHOD2(OnComposeChange, void(const std::u16string&, int)); - MOCK_METHOD3(OnImeComposition, void(UINT const, WPARAM const, LPARAM const)); - - MOCK_METHOD0(OnThemeChange, void()); - - MOCK_METHOD0(GetAxFragmentRootDelegate, ui::AXFragmentRootDelegateWin*()); - - MOCK_METHOD3(OnGetObject, LRESULT(UINT, WPARAM, LPARAM)); - - MOCK_METHOD1(OnWindowStateEvent, void(WindowStateEvent)); + MOCK_METHOD(void, OnDpiScale, (unsigned int), (override)); + MOCK_METHOD(void, OnResize, (unsigned int, unsigned int), (override)); + MOCK_METHOD(void, OnPaint, (), (override)); + MOCK_METHOD(void, + OnPointerMove, + (double, double, FlutterPointerDeviceKind, int32_t, int), + (override)); + MOCK_METHOD(void, + OnPointerDown, + (double, double, FlutterPointerDeviceKind, int32_t, UINT), + (override)); + MOCK_METHOD(void, + OnPointerUp, + (double, double, FlutterPointerDeviceKind, int32_t, UINT), + (override)); + MOCK_METHOD(void, + OnPointerLeave, + (double, double, FlutterPointerDeviceKind, int32_t), + (override)); + MOCK_METHOD(void, OnSetCursor, (), (override)); + MOCK_METHOD(void, OnText, (const std::u16string&), (override)); + MOCK_METHOD(void, + OnKey, + (int, int, int, char32_t, bool, bool, KeyEventCallback), + (override)); + MOCK_METHOD(void, OnUpdateSemanticsEnabled, (bool), (override)); + MOCK_METHOD(gfx::NativeViewAccessible, + GetNativeViewAccessible, + (), + (override)); + MOCK_METHOD(void, + OnScroll, + (double, double, FlutterPointerDeviceKind, int32_t), + (override)); + MOCK_METHOD(void, OnComposeBegin, (), (override)); + MOCK_METHOD(void, OnComposeCommit, (), (override)); + MOCK_METHOD(void, OnComposeEnd, (), (override)); + MOCK_METHOD(void, OnComposeChange, (const std::u16string&, int), (override)); + MOCK_METHOD(void, + OnImeComposition, + (UINT const, WPARAM const, LPARAM const), + (override)); + + MOCK_METHOD(void, OnThemeChange, (), (override)); + + MOCK_METHOD(ui::AXFragmentRootDelegateWin*, + GetAxFragmentRootDelegate, + (), + (override)); + + MOCK_METHOD(LRESULT, OnGetObject, (UINT, WPARAM, LPARAM), (override)); + + MOCK_METHOD(void, OnWindowStateEvent, (WindowStateEvent), (override)); void CallOnImeComposition(UINT const message, WPARAM const wparam, diff --git a/shell/platform/windows/testing/mock_window_binding_handler.h b/shell/platform/windows/testing/mock_window_binding_handler.h index 0f5daadaec670..bcecbd8b4e479 100644 --- a/shell/platform/windows/testing/mock_window_binding_handler.h +++ b/shell/platform/windows/testing/mock_window_binding_handler.h @@ -19,24 +19,29 @@ class MockWindowBindingHandler : public WindowBindingHandler { MockWindowBindingHandler(); virtual ~MockWindowBindingHandler(); - MOCK_METHOD1(SetView, void(WindowBindingHandlerDelegate* view)); - MOCK_METHOD0(GetRenderTarget, WindowsRenderTarget()); - MOCK_METHOD0(GetPlatformWindow, PlatformWindow()); - MOCK_METHOD0(GetDpiScale, float()); - MOCK_METHOD0(IsVisible, bool()); - MOCK_METHOD0(OnWindowResized, void()); - MOCK_METHOD0(GetPhysicalWindowBounds, PhysicalWindowBounds()); - MOCK_METHOD1(UpdateFlutterCursor, void(const std::string& cursor_name)); - MOCK_METHOD1(SetFlutterCursor, void(HCURSOR cursor_name)); - MOCK_METHOD1(OnCursorRectUpdated, void(const Rect& rect)); - MOCK_METHOD0(OnResetImeComposing, void()); - MOCK_METHOD3(OnBitmapSurfaceUpdated, - bool(const void* allocation, size_t row_bytes, size_t height)); - MOCK_METHOD0(GetPrimaryPointerLocation, PointerLocation()); - MOCK_METHOD0(SendInitialAccessibilityFeatures, void()); - MOCK_METHOD0(GetAlertDelegate, AlertPlatformNodeDelegate*()); - MOCK_METHOD0(GetAlert, ui::AXPlatformNodeWin*()); - MOCK_METHOD0(NeedsVSync, bool()); + MOCK_METHOD(void, SetView, (WindowBindingHandlerDelegate * view), (override)); + MOCK_METHOD(WindowsRenderTarget, GetRenderTarget, (), (override)); + MOCK_METHOD(PlatformWindow, GetPlatformWindow, (), (override)); + MOCK_METHOD(float, GetDpiScale, (), (override)); + MOCK_METHOD(bool, IsVisible, (), (override)); + MOCK_METHOD(void, OnWindowResized, (), (override)); + MOCK_METHOD(PhysicalWindowBounds, GetPhysicalWindowBounds, (), (override)); + MOCK_METHOD(void, + UpdateFlutterCursor, + (const std::string& cursor_name), + (override)); + MOCK_METHOD(void, SetFlutterCursor, (HCURSOR cursor_name), (override)); + MOCK_METHOD(void, OnCursorRectUpdated, (const Rect& rect), (override)); + MOCK_METHOD(void, OnResetImeComposing, (), (override)); + MOCK_METHOD(bool, + OnBitmapSurfaceUpdated, + (const void* allocation, size_t row_bytes, size_t height), + (override)); + MOCK_METHOD(PointerLocation, GetPrimaryPointerLocation, (), (override)); + MOCK_METHOD(void, SendInitialAccessibilityFeatures, (), (override)); + MOCK_METHOD(AlertPlatformNodeDelegate*, GetAlertDelegate, (), (override)); + MOCK_METHOD(ui::AXPlatformNodeWin*, GetAlert, (), (override)); + MOCK_METHOD(bool, NeedsVSync, (), (override)); private: FML_DISALLOW_COPY_AND_ASSIGN(MockWindowBindingHandler); diff --git a/shell/platform/windows/testing/mock_window_binding_handler_delegate.h b/shell/platform/windows/testing/mock_window_binding_handler_delegate.h index fb58b354cb72d..4cdecc292cbce 100644 --- a/shell/platform/windows/testing/mock_window_binding_handler_delegate.h +++ b/shell/platform/windows/testing/mock_window_binding_handler_delegate.h @@ -16,52 +16,67 @@ class MockWindowBindingHandlerDelegate : public WindowBindingHandlerDelegate { public: MockWindowBindingHandlerDelegate() {} - MOCK_METHOD2(OnWindowSizeChanged, void(size_t, size_t)); - MOCK_METHOD0(OnWindowRepaint, void()); - MOCK_METHOD5(OnPointerMove, - void(double, double, FlutterPointerDeviceKind, int32_t, int)); - MOCK_METHOD5(OnPointerDown, - void(double, - double, - FlutterPointerDeviceKind, - int32_t, - FlutterPointerMouseButtons)); - MOCK_METHOD5(OnPointerUp, - void(double, - double, - FlutterPointerDeviceKind, - int32_t, - FlutterPointerMouseButtons)); - MOCK_METHOD4(OnPointerLeave, - void(double, double, FlutterPointerDeviceKind, int32_t)); - MOCK_METHOD1(OnPointerPanZoomStart, void(int32_t)); - MOCK_METHOD5(OnPointerPanZoomUpdate, - void(int32_t, double, double, double, double)); - MOCK_METHOD1(OnPointerPanZoomEnd, void(int32_t)); - MOCK_METHOD1(OnText, void(const std::u16string&)); - MOCK_METHOD7(OnKey, - void(int, int, int, char32_t, bool, bool, KeyEventCallback)); - MOCK_METHOD0(OnComposeBegin, void()); - MOCK_METHOD0(OnComposeCommit, void()); - MOCK_METHOD0(OnComposeEnd, void()); - MOCK_METHOD2(OnComposeChange, void(const std::u16string&, int)); - MOCK_METHOD1(OnUpdateSemanticsEnabled, void(bool)); - MOCK_METHOD0(GetNativeViewAccessible, gfx::NativeViewAccessible()); - MOCK_METHOD7(OnScroll, - void(double, - double, - double, - double, - int, - FlutterPointerDeviceKind, - int32_t)); - MOCK_METHOD1(OnScrollInertiaCancel, void(int32_t)); - MOCK_METHOD0(OnPlatformBrightnessChanged, void()); - MOCK_METHOD1(UpdateHighContrastEnabled, void(bool enabled)); + MOCK_METHOD(void, OnWindowSizeChanged, (size_t, size_t), (override)); + MOCK_METHOD(void, OnWindowRepaint, (), (override)); + MOCK_METHOD(void, + OnPointerMove, + (double, double, FlutterPointerDeviceKind, int32_t, int), + (override)); + MOCK_METHOD(void, + OnPointerDown, + (double, + double, + FlutterPointerDeviceKind, + int32_t, + FlutterPointerMouseButtons), + (override)); + MOCK_METHOD(void, + OnPointerUp, + (double, + double, + FlutterPointerDeviceKind, + int32_t, + FlutterPointerMouseButtons), + (override)); + MOCK_METHOD(void, + OnPointerLeave, + (double, double, FlutterPointerDeviceKind, int32_t), + (override)); + MOCK_METHOD(void, OnPointerPanZoomStart, (int32_t), (override)); + MOCK_METHOD(void, + OnPointerPanZoomUpdate, + (int32_t, double, double, double, double), + (override)); + MOCK_METHOD(void, OnPointerPanZoomEnd, (int32_t), (override)); + MOCK_METHOD(void, OnText, (const std::u16string&), (override)); + MOCK_METHOD(void, + OnKey, + (int, int, int, char32_t, bool, bool, KeyEventCallback), + (override)); + MOCK_METHOD(void, OnComposeBegin, (), (override)); + MOCK_METHOD(void, OnComposeCommit, (), (override)); + MOCK_METHOD(void, OnComposeEnd, (), (override)); + MOCK_METHOD(void, OnComposeChange, (const std::u16string&, int), (override)); + MOCK_METHOD(void, OnUpdateSemanticsEnabled, (bool), (override)); + MOCK_METHOD(gfx::NativeViewAccessible, + GetNativeViewAccessible, + (), + (override)); + MOCK_METHOD( + void, + OnScroll, + (double, double, double, double, int, FlutterPointerDeviceKind, int32_t), + (override)); + MOCK_METHOD(void, OnScrollInertiaCancel, (int32_t), (override)); + MOCK_METHOD(void, OnPlatformBrightnessChanged, (), (override)); + MOCK_METHOD(void, UpdateHighContrastEnabled, (bool enabled), (override)); - MOCK_METHOD0(GetAxFragmentRootDelegate, ui::AXFragmentRootDelegateWin*()); + MOCK_METHOD(ui::AXFragmentRootDelegateWin*, + GetAxFragmentRootDelegate, + (), + (override)); - MOCK_METHOD2(OnWindowStateEvent, void(HWND, WindowStateEvent)); + MOCK_METHOD(void, OnWindowStateEvent, (HWND, WindowStateEvent), (override)); private: FML_DISALLOW_COPY_AND_ASSIGN(MockWindowBindingHandlerDelegate); diff --git a/shell/platform/windows/testing/mock_windows_proc_table.h b/shell/platform/windows/testing/mock_windows_proc_table.h index d2bcea86cec8d..ec09a6f7bc498 100644 --- a/shell/platform/windows/testing/mock_windows_proc_table.h +++ b/shell/platform/windows/testing/mock_windows_proc_table.h @@ -18,11 +18,15 @@ class MockWindowsProcTable : public WindowsProcTable { MockWindowsProcTable() = default; virtual ~MockWindowsProcTable() = default; - MOCK_METHOD2(GetPointerType, - BOOL(UINT32 pointer_id, POINTER_INPUT_TYPE* pointer_type)); - - MOCK_CONST_METHOD4(GetThreadPreferredUILanguages, - LRESULT(DWORD, PULONG, PZZWSTR, PULONG)); + MOCK_METHOD(BOOL, + GetPointerType, + (UINT32 pointer_id, POINTER_INPUT_TYPE* pointer_type), + (override)); + + MOCK_METHOD(LRESULT, + GetThreadPreferredUILanguages, + (DWORD, PULONG, PZZWSTR, PULONG), + (const, override)); private: FML_DISALLOW_COPY_AND_ASSIGN(MockWindowsProcTable); diff --git a/shell/platform/windows/text_input_plugin_unittest.cc b/shell/platform/windows/text_input_plugin_unittest.cc index 67f13c9479ce3..7d4705096441d 100644 --- a/shell/platform/windows/text_input_plugin_unittest.cc +++ b/shell/platform/windows/text_input_plugin_unittest.cc @@ -100,8 +100,8 @@ class MockTextInputPluginDelegate : public TextInputPluginDelegate { MockTextInputPluginDelegate() {} virtual ~MockTextInputPluginDelegate() = default; - MOCK_METHOD1(OnCursorRectUpdated, void(const Rect&)); - MOCK_METHOD0(OnResetImeComposing, void()); + MOCK_METHOD(void, OnCursorRectUpdated, (const Rect&), (override)); + MOCK_METHOD(void, OnResetImeComposing, (), (override)); private: FML_DISALLOW_COPY_AND_ASSIGN(MockTextInputPluginDelegate); diff --git a/shell/profiling/sampling_profiler_unittest.cc b/shell/profiling/sampling_profiler_unittest.cc index 784b73206d386..95ed49c38ccfc 100644 --- a/shell/profiling/sampling_profiler_unittest.cc +++ b/shell/profiling/sampling_profiler_unittest.cc @@ -18,13 +18,17 @@ class MockTaskRunner : public fml::TaskRunner { inline static RefPtr Create() { return AdoptRef(new MockTaskRunner()); } - MOCK_METHOD1(PostTask, void(const fml::closure& task)); - MOCK_METHOD2(PostTaskForTime, - void(const fml::closure& task, fml::TimePoint target_time)); - MOCK_METHOD2(PostDelayedTask, - void(const fml::closure& task, fml::TimeDelta delay)); - MOCK_METHOD0(RunsTasksOnCurrentThread, bool()); - MOCK_METHOD0(GetTaskQueueId, TaskQueueId()); + MOCK_METHOD(void, PostTask, (const fml::closure& task), (override)); + MOCK_METHOD(void, + PostTaskForTime, + (const fml::closure& task, fml::TimePoint target_time), + (override)); + MOCK_METHOD(void, + PostDelayedTask, + (const fml::closure& task, fml::TimeDelta delay), + (override)); + MOCK_METHOD(bool, RunsTasksOnCurrentThread, (), (override)); + MOCK_METHOD(TaskQueueId, GetTaskQueueId, (), (override)); private: MockTaskRunner() : TaskRunner(fml::RefPtr()) {} From 1b8f82a5c2ef0bb9f543dbb56dec143c5596e2af Mon Sep 17 00:00:00 2001 From: Tong Mu Date: Thu, 31 Aug 2023 21:14:30 -0700 Subject: [PATCH 4/7] Fix compile --- shell/platform/windows/flutter_window_unittests.cc | 2 +- .../windows/testing/mock_window_binding_handler_delegate.h | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/shell/platform/windows/flutter_window_unittests.cc b/shell/platform/windows/flutter_window_unittests.cc index 473cc485ff7f1..7f8ddccc47b42 100644 --- a/shell/platform/windows/flutter_window_unittests.cc +++ b/shell/platform/windows/flutter_window_unittests.cc @@ -48,7 +48,7 @@ class MockFlutterWindow : public FlutterWindow { MOCK_METHOD(void, OnResize, (unsigned int, unsigned int), (override)); MOCK_METHOD(void, OnPointerMove, - (double, double, FlutterPointerDeviceKind, int32_t), + (double, double, FlutterPointerDeviceKind, int32_t, int), (override)); MOCK_METHOD(void, OnPointerDown, diff --git a/shell/platform/windows/testing/mock_window_binding_handler_delegate.h b/shell/platform/windows/testing/mock_window_binding_handler_delegate.h index 4cdecc292cbce..2e1ed22c2034b 100644 --- a/shell/platform/windows/testing/mock_window_binding_handler_delegate.h +++ b/shell/platform/windows/testing/mock_window_binding_handler_delegate.h @@ -68,7 +68,6 @@ class MockWindowBindingHandlerDelegate : public WindowBindingHandlerDelegate { (double, double, double, double, int, FlutterPointerDeviceKind, int32_t), (override)); MOCK_METHOD(void, OnScrollInertiaCancel, (int32_t), (override)); - MOCK_METHOD(void, OnPlatformBrightnessChanged, (), (override)); MOCK_METHOD(void, UpdateHighContrastEnabled, (bool enabled), (override)); MOCK_METHOD(ui::AXFragmentRootDelegateWin*, From 6c66db6d9884c314318fba3fa872231d8e673b87 Mon Sep 17 00:00:00 2001 From: Tong Mu Date: Thu, 31 Aug 2023 23:43:12 -0700 Subject: [PATCH 5/7] Fix more compile --- shell/platform/windows/flutter_windows_engine_unittests.cc | 4 ++-- shell/platform/windows/flutter_windows_view.h | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/shell/platform/windows/flutter_windows_engine_unittests.cc b/shell/platform/windows/flutter_windows_engine_unittests.cc index 96e0a010629b7..3c9d498a17006 100644 --- a/shell/platform/windows/flutter_windows_engine_unittests.cc +++ b/shell/platform/windows/flutter_windows_engine_unittests.cc @@ -610,7 +610,7 @@ class MockFlutterWindowsView : public FlutterWindowsView { NotifyWinEventWrapper, (ui::AXPlatformNodeWin*, ax::mojom::Event), (override)); - MOCK_METHOD(HWND, GetPlatformWindow, (), (override)); + MOCK_METHOD(PlatformWindow, GetPlatformWindow, (), (override)); private: FML_DISALLOW_COPY_AND_ASSIGN(MockFlutterWindowsView); @@ -670,7 +670,7 @@ class MockWindowsLifecycleManager : public WindowsLifecycleManager { (std::optional, std::optional, std::optional, UINT), (override)); MOCK_METHOD(void, DispatchMessage, (HWND, UINT, WPARAM, LPARAM), (override)); - MOCK_METHOD(bool, IsLastWindowOfProcess, (void), (override)); + MOCK_METHOD(bool, IsLastWindowOfProcess, (), (override)); MOCK_METHOD(void, SetLifecycleState, (AppLifecycleState), (override)); void BeginProcessingLifecycle() override { diff --git a/shell/platform/windows/flutter_windows_view.h b/shell/platform/windows/flutter_windows_view.h index 792db3f5b9f95..4b91e1eecaed5 100644 --- a/shell/platform/windows/flutter_windows_view.h +++ b/shell/platform/windows/flutter_windows_view.h @@ -59,7 +59,7 @@ class FlutterWindowsView : public WindowBindingHandlerDelegate, WindowsRenderTarget* GetRenderTarget() const; // Return the currently configured PlatformWindow. - PlatformWindow GetPlatformWindow() const; + virtual PlatformWindow GetPlatformWindow() const; // Returns the engine backing this view. FlutterWindowsEngine* GetEngine(); From 8929fdb6fa514bb3489ae7d71eb63c113079c2cc Mon Sep 17 00:00:00 2001 From: Tong Mu Date: Thu, 31 Aug 2023 23:47:21 -0700 Subject: [PATCH 6/7] Remove mocks --- impeller/renderer/testing/mocks.h | 5 ----- 1 file changed, 5 deletions(-) diff --git a/impeller/renderer/testing/mocks.h b/impeller/renderer/testing/mocks.h index 7b61402d6405c..8d50ac115c27b 100644 --- a/impeller/renderer/testing/mocks.h +++ b/impeller/renderer/testing/mocks.h @@ -17,8 +17,6 @@ namespace testing { class MockDeviceBuffer : public DeviceBuffer { public: MockDeviceBuffer(const DeviceBufferDescriptor& desc) : DeviceBuffer(desc) {} - // MOCK_METHOD(bool, CopyHostBuffer, (const uint8_t* source, Range - // source_range, size_t offset), (override)); MOCK_METHOD(bool, SetLabel, (const std::string& label), (override)); @@ -154,9 +152,6 @@ class MockTexture : public Texture { public: MockTexture(const TextureDescriptor& desc) : Texture(desc) {} MOCK_METHOD(void, SetLabel, (std::string_view label), (override)); - // MOCK_METHOD(bool, SetContents, (const uint8_t* contents, size_t length, - // size_t slice), (override)); MOCK_METHOD(bool, SetContents, - // (std::shared_ptr mapping, size_t slice), (override)); MOCK_METHOD(bool, IsValid, (), (const, override)); MOCK_METHOD(ISize, GetSize, (), (const, override)); MOCK_METHOD(bool, From 1d338f9234a204a71252946d9da2b64ef6d63669 Mon Sep 17 00:00:00 2001 From: Tong Mu Date: Fri, 1 Sep 2023 17:50:39 -0700 Subject: [PATCH 7/7] Fix error --- shell/platform/windows/flutter_windows_engine_unittests.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/shell/platform/windows/flutter_windows_engine_unittests.cc b/shell/platform/windows/flutter_windows_engine_unittests.cc index 3c9d498a17006..d27c78c70507d 100644 --- a/shell/platform/windows/flutter_windows_engine_unittests.cc +++ b/shell/platform/windows/flutter_windows_engine_unittests.cc @@ -610,7 +610,7 @@ class MockFlutterWindowsView : public FlutterWindowsView { NotifyWinEventWrapper, (ui::AXPlatformNodeWin*, ax::mojom::Event), (override)); - MOCK_METHOD(PlatformWindow, GetPlatformWindow, (), (override)); + MOCK_METHOD(PlatformWindow, GetPlatformWindow, (), (const, override)); private: FML_DISALLOW_COPY_AND_ASSIGN(MockFlutterWindowsView);