| // Copyright 2013 The Flutter Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #include "flutter/shell/platform/windows/platform_handler.h" | |
| #include <memory> | |
| #include "flutter/shell/platform/common/json_method_codec.h" | |
| #include "flutter/shell/platform/windows/flutter_windows_view.h" | |
| #include "flutter/shell/platform/windows/testing/mock_window_binding_handler.h" | |
| #include "flutter/shell/platform/windows/testing/test_binary_messenger.h" | |
| #include "gmock/gmock.h" | |
| #include "gtest/gtest.h" | |
| #include "rapidjson/document.h" | |
| namespace flutter { | |
| namespace testing { | |
| namespace { | |
| using ::testing::_; | |
| static constexpr char kChannelName[] = "flutter/platform"; | |
| static constexpr char kGetClipboardDataMethod[] = "Clipboard.getData"; | |
| static constexpr char kHasStringsClipboardMethod[] = "Clipboard.hasStrings"; | |
| static constexpr char kSetClipboardDataMethod[] = "Clipboard.setData"; | |
| static constexpr char kPlaySoundMethod[] = "SystemSound.play"; | |
| static constexpr char kTextPlainFormat[] = "text/plain"; | |
| static constexpr char kFakeContentType[] = "text/madeupcontenttype"; | |
| static constexpr char kSoundTypeAlert[] = "SystemSoundType.alert"; | |
| static constexpr char kValueKey[] = "value"; | |
| static constexpr int kAccessDeniedErrorCode = 5; | |
| static constexpr int kErrorSuccess = 0; | |
| static constexpr int kArbitraryErrorCode = 1; | |
| // Test implementation of PlatformHandler to allow testing the PlatformHandler | |
| // logic. | |
| class TestPlatformHandler : public PlatformHandler { | |
| public: | |
| explicit TestPlatformHandler( | |
| BinaryMessenger* messenger, | |
| FlutterWindowsView* view, | |
| std::optional<std::function<std::unique_ptr<ScopedClipboardInterface>()>> | |
| scoped_clipboard_provider = std::nullopt) | |
| : PlatformHandler(messenger, view, scoped_clipboard_provider) {} | |
| virtual ~TestPlatformHandler() = default; | |
| MOCK_METHOD2(GetPlainText, | |
| void(std::unique_ptr<MethodResult<rapidjson::Document>>, | |
| std::string_view key)); | |
| MOCK_METHOD1(GetHasStrings, | |
| void(std::unique_ptr<MethodResult<rapidjson::Document>>)); | |
| MOCK_METHOD2(SetPlainText, | |
| void(const std::string&, | |
| std::unique_ptr<MethodResult<rapidjson::Document>>)); | |
| MOCK_METHOD2(SystemSoundPlay, | |
| void(const std::string&, | |
| std::unique_ptr<MethodResult<rapidjson::Document>>)); | |
| }; | |
| // Mock result to inspect results of PlatformHandler calls. | |
| class MockMethodResult : public MethodResult<rapidjson::Document> { | |
| public: | |
| MOCK_METHOD1(SuccessInternal, void(const rapidjson::Document*)); | |
| MOCK_METHOD3(ErrorInternal, | |
| void(const std::string&, | |
| const std::string&, | |
| const rapidjson::Document*)); | |
| MOCK_METHOD0(NotImplementedInternal, void()); | |
| }; | |
| // A test version of system clipboard. | |
| class MockSystemClipboard { | |
| public: | |
| void OpenClipboard() { opened = true; } | |
| void CloseClipboard() { opened = false; } | |
| bool opened = false; | |
| }; | |
| // A test version of the private ScopedClipboard. | |
| class TestScopedClipboard : public ScopedClipboardInterface { | |
| public: | |
| TestScopedClipboard(int open_error, | |
| bool has_strings, | |
| std::shared_ptr<MockSystemClipboard> clipboard); | |
| ~TestScopedClipboard(); | |
| // Prevent copying. | |
| TestScopedClipboard(TestScopedClipboard const&) = delete; | |
| TestScopedClipboard& operator=(TestScopedClipboard const&) = delete; | |
| int Open(HWND window) override; | |
| bool HasString() override; | |
| std::variant<std::wstring, int> GetString() override; | |
| int SetString(const std::wstring string) override; | |
| private: | |
| bool opened_ = false; | |
| bool has_strings_; | |
| int open_error_; | |
| std::shared_ptr<MockSystemClipboard> clipboard_; | |
| }; | |
| TestScopedClipboard::TestScopedClipboard( | |
| int open_error, | |
| bool has_strings, | |
| std::shared_ptr<MockSystemClipboard> clipboard = nullptr) { | |
| open_error_ = open_error; | |
| has_strings_ = has_strings; | |
| clipboard_ = clipboard; | |
| } | |
| TestScopedClipboard::~TestScopedClipboard() { | |
| if ((!open_error_) && clipboard_ != nullptr) { | |
| clipboard_->CloseClipboard(); | |
| } | |
| } | |
| int TestScopedClipboard::Open(HWND window) { | |
| if ((!open_error_) && clipboard_ != nullptr) { | |
| clipboard_->OpenClipboard(); | |
| } | |
| return open_error_; | |
| } | |
| bool TestScopedClipboard::HasString() { | |
| return has_strings_; | |
| } | |
| std::variant<std::wstring, int> TestScopedClipboard::GetString() { | |
| return -1; | |
| } | |
| int TestScopedClipboard::SetString(const std::wstring string) { | |
| return -1; | |
| } | |
| } // namespace | |
| TEST(PlatformHandler, GettingTextCallsThrough) { | |
| TestBinaryMessenger messenger; | |
| FlutterWindowsView view( | |
| std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>()); | |
| auto system_clipboard = std::make_shared<MockSystemClipboard>(); | |
| TestPlatformHandler platform_handler(&messenger, &view, [system_clipboard]() { | |
| return std::make_unique<TestScopedClipboard>(kErrorSuccess, false, | |
| system_clipboard); | |
| }); | |
| auto args = std::make_unique<rapidjson::Document>(rapidjson::kStringType); | |
| auto& allocator = args->GetAllocator(); | |
| args->SetString(kTextPlainFormat); | |
| auto encoded = JsonMethodCodec::GetInstance().EncodeMethodCall( | |
| MethodCall<rapidjson::Document>(kGetClipboardDataMethod, | |
| std::move(args))); | |
| // Set up a handler to call a response on |result| so that it doesn't log | |
| // on destruction about leaking. | |
| ON_CALL(platform_handler, GetPlainText) | |
| .WillByDefault( | |
| [](std::unique_ptr<MethodResult<rapidjson::Document>> result, | |
| auto key) { result->NotImplemented(); }); | |
| EXPECT_CALL(platform_handler, GetPlainText(_, ::testing::StrEq("text"))); | |
| EXPECT_TRUE(messenger.SimulateEngineMessage( | |
| kChannelName, encoded->data(), encoded->size(), | |
| [](const uint8_t* reply, size_t reply_size) {})); | |
| } | |
| TEST(PlatformHandler, RejectsGettingUnknownTypes) { | |
| TestBinaryMessenger messenger; | |
| FlutterWindowsView view( | |
| std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>()); | |
| auto system_clipboard = std::make_shared<MockSystemClipboard>(); | |
| TestPlatformHandler platform_handler(&messenger, &view, [system_clipboard]() { | |
| return std::make_unique<TestScopedClipboard>(kErrorSuccess, false, | |
| system_clipboard); | |
| }); | |
| auto args = std::make_unique<rapidjson::Document>(rapidjson::kStringType); | |
| auto& allocator = args->GetAllocator(); | |
| args->SetString(kFakeContentType); | |
| auto encoded = JsonMethodCodec::GetInstance().EncodeMethodCall( | |
| MethodCall<rapidjson::Document>(kGetClipboardDataMethod, | |
| std::move(args))); | |
| MockMethodResult result; | |
| // Requsting an unknow content type is an error. | |
| EXPECT_CALL(result, ErrorInternal(_, _, _)); | |
| EXPECT_TRUE(messenger.SimulateEngineMessage( | |
| kChannelName, encoded->data(), encoded->size(), | |
| [&](const uint8_t* reply, size_t reply_size) { | |
| JsonMethodCodec::GetInstance().DecodeAndProcessResponseEnvelope( | |
| reply, reply_size, &result); | |
| })); | |
| } | |
| TEST(PlatformHandler, GetHasStringsCallsThrough) { | |
| TestBinaryMessenger messenger; | |
| FlutterWindowsView view( | |
| std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>()); | |
| auto system_clipboard = std::make_shared<MockSystemClipboard>(); | |
| TestPlatformHandler platform_handler(&messenger, &view, [system_clipboard]() { | |
| return std::make_unique<TestScopedClipboard>(kErrorSuccess, false, | |
| system_clipboard); | |
| }); | |
| auto args = std::make_unique<rapidjson::Document>(rapidjson::kStringType); | |
| auto& allocator = args->GetAllocator(); | |
| args->SetString(kTextPlainFormat); | |
| auto encoded = JsonMethodCodec::GetInstance().EncodeMethodCall( | |
| MethodCall<rapidjson::Document>(kHasStringsClipboardMethod, | |
| std::move(args))); | |
| // Set up a handler to call a response on |result| so that it doesn't log | |
| // on destruction about leaking. | |
| ON_CALL(platform_handler, GetHasStrings) | |
| .WillByDefault( | |
| [](std::unique_ptr<MethodResult<rapidjson::Document>> result) { | |
| result->NotImplemented(); | |
| }); | |
| EXPECT_CALL(platform_handler, GetHasStrings(_)); | |
| EXPECT_TRUE(messenger.SimulateEngineMessage( | |
| kChannelName, encoded->data(), encoded->size(), | |
| [](const uint8_t* reply, size_t reply_size) {})); | |
| } | |
| TEST(PlatformHandler, RejectsGetHasStringsOnUnknownTypes) { | |
| TestBinaryMessenger messenger; | |
| FlutterWindowsView view( | |
| std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>()); | |
| auto system_clipboard = std::make_shared<MockSystemClipboard>(); | |
| TestPlatformHandler platform_handler(&messenger, &view, [system_clipboard]() { | |
| return std::make_unique<TestScopedClipboard>(kErrorSuccess, false, | |
| system_clipboard); | |
| }); | |
| auto args = std::make_unique<rapidjson::Document>(rapidjson::kStringType); | |
| auto& allocator = args->GetAllocator(); | |
| args->SetString(kFakeContentType); | |
| auto encoded = JsonMethodCodec::GetInstance().EncodeMethodCall( | |
| MethodCall<rapidjson::Document>(kHasStringsClipboardMethod, | |
| std::move(args))); | |
| MockMethodResult result; | |
| // Requsting an unknow content type is an error. | |
| EXPECT_CALL(result, ErrorInternal(_, _, _)); | |
| EXPECT_TRUE(messenger.SimulateEngineMessage( | |
| kChannelName, encoded->data(), encoded->size(), | |
| [&](const uint8_t* reply, size_t reply_size) { | |
| JsonMethodCodec::GetInstance().DecodeAndProcessResponseEnvelope( | |
| reply, reply_size, &result); | |
| })); | |
| } | |
| TEST(PlatformHandler, SettingTextCallsThrough) { | |
| TestBinaryMessenger messenger; | |
| FlutterWindowsView view( | |
| std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>()); | |
| auto system_clipboard = std::make_shared<MockSystemClipboard>(); | |
| TestPlatformHandler platform_handler(&messenger, &view, [system_clipboard]() { | |
| return std::make_unique<TestScopedClipboard>(kErrorSuccess, false, | |
| system_clipboard); | |
| }); | |
| auto args = std::make_unique<rapidjson::Document>(rapidjson::kObjectType); | |
| auto& allocator = args->GetAllocator(); | |
| args->AddMember("text", "hello", allocator); | |
| auto encoded = JsonMethodCodec::GetInstance().EncodeMethodCall( | |
| MethodCall<rapidjson::Document>(kSetClipboardDataMethod, | |
| std::move(args))); | |
| // Set up a handler to call a response on |result| so that it doesn't log | |
| // on destruction about leaking. | |
| ON_CALL(platform_handler, SetPlainText) | |
| .WillByDefault( | |
| [](auto value, | |
| std::unique_ptr<MethodResult<rapidjson::Document>> result) { | |
| result->NotImplemented(); | |
| }); | |
| EXPECT_CALL(platform_handler, SetPlainText(::testing::StrEq("hello"), _)); | |
| EXPECT_TRUE(messenger.SimulateEngineMessage( | |
| kChannelName, encoded->data(), encoded->size(), | |
| [](const uint8_t* reply, size_t reply_size) {})); | |
| } | |
| TEST(PlatformHandler, RejectsSettingUnknownTypes) { | |
| TestBinaryMessenger messenger; | |
| FlutterWindowsView view( | |
| std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>()); | |
| auto system_clipboard = std::make_shared<MockSystemClipboard>(); | |
| TestPlatformHandler platform_handler(&messenger, &view, [system_clipboard]() { | |
| return std::make_unique<TestScopedClipboard>(kErrorSuccess, false, | |
| system_clipboard); | |
| }); | |
| auto args = std::make_unique<rapidjson::Document>(rapidjson::kObjectType); | |
| auto& allocator = args->GetAllocator(); | |
| args->AddMember("madeuptype", "hello", allocator); | |
| auto encoded = JsonMethodCodec::GetInstance().EncodeMethodCall( | |
| MethodCall<rapidjson::Document>(kSetClipboardDataMethod, | |
| std::move(args))); | |
| MockMethodResult result; | |
| // Requsting an unknow content type is an error. | |
| EXPECT_CALL(result, ErrorInternal(_, _, _)); | |
| EXPECT_TRUE(messenger.SimulateEngineMessage( | |
| kChannelName, encoded->data(), encoded->size(), | |
| [&](const uint8_t* reply, size_t reply_size) { | |
| JsonMethodCodec::GetInstance().DecodeAndProcessResponseEnvelope( | |
| reply, reply_size, &result); | |
| })); | |
| } | |
| TEST(PlatformHandler, PlayingSystemSoundCallsThrough) { | |
| TestBinaryMessenger messenger; | |
| FlutterWindowsView view( | |
| std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>()); | |
| auto system_clipboard = std::make_shared<MockSystemClipboard>(); | |
| TestPlatformHandler platform_handler(&messenger, &view, [system_clipboard]() { | |
| return std::make_unique<TestScopedClipboard>(kErrorSuccess, false, | |
| system_clipboard); | |
| }); | |
| auto args = std::make_unique<rapidjson::Document>(rapidjson::kStringType); | |
| auto& allocator = args->GetAllocator(); | |
| args->SetString(kSoundTypeAlert); | |
| auto encoded = JsonMethodCodec::GetInstance().EncodeMethodCall( | |
| MethodCall<rapidjson::Document>(kPlaySoundMethod, std::move(args))); | |
| // Set up a handler to call a response on |result| so that it doesn't log | |
| // on destruction about leaking. | |
| ON_CALL(platform_handler, SystemSoundPlay) | |
| .WillByDefault( | |
| [](auto sound_type, | |
| std::unique_ptr<MethodResult<rapidjson::Document>> result) { | |
| result->NotImplemented(); | |
| }); | |
| EXPECT_CALL(platform_handler, | |
| SystemSoundPlay(::testing::StrEq(kSoundTypeAlert), _)); | |
| EXPECT_TRUE(messenger.SimulateEngineMessage( | |
| kChannelName, encoded->data(), encoded->size(), | |
| [](const uint8_t* reply, size_t reply_size) {})); | |
| } | |
| // Regression test for https://github.com/flutter/flutter/issues/95817. | |
| TEST(PlatformHandler, HasStringsAccessDeniedReturnsFalseWithoutError) { | |
| TestBinaryMessenger messenger; | |
| FlutterWindowsView view( | |
| std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>()); | |
| // HasStrings will receive access denied on the clipboard, but will return | |
| // false without error. | |
| PlatformHandler platform_handler(&messenger, &view, []() { | |
| return std::make_unique<TestScopedClipboard>(kAccessDeniedErrorCode, true); | |
| }); | |
| auto args = std::make_unique<rapidjson::Document>(rapidjson::kStringType); | |
| auto& allocator = args->GetAllocator(); | |
| args->SetString(kTextPlainFormat); | |
| auto encoded = JsonMethodCodec::GetInstance().EncodeMethodCall( | |
| MethodCall<rapidjson::Document>(kHasStringsClipboardMethod, | |
| std::move(args))); | |
| MockMethodResult result; | |
| rapidjson::Document document; | |
| document.SetObject(); | |
| rapidjson::Document::AllocatorType& document_allocator = | |
| document.GetAllocator(); | |
| document.AddMember(rapidjson::Value(kValueKey, document_allocator), | |
| rapidjson::Value(false), document_allocator); | |
| EXPECT_CALL(result, SuccessInternal(_)) | |
| .WillOnce([](const rapidjson::Document* document) { | |
| ASSERT_FALSE((*document)[kValueKey].GetBool()); | |
| }); | |
| EXPECT_TRUE(messenger.SimulateEngineMessage( | |
| kChannelName, encoded->data(), encoded->size(), | |
| [&](const uint8_t* reply, size_t reply_size) { | |
| JsonMethodCodec::GetInstance().DecodeAndProcessResponseEnvelope( | |
| reply, reply_size, &result); | |
| })); | |
| } | |
| TEST(PlatformHandler, HasStringsSuccessWithStrings) { | |
| TestBinaryMessenger messenger; | |
| FlutterWindowsView view( | |
| std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>()); | |
| // HasStrings will succeed and return true. | |
| PlatformHandler platform_handler(&messenger, &view, []() { | |
| return std::make_unique<TestScopedClipboard>(kErrorSuccess, true); | |
| }); | |
| auto args = std::make_unique<rapidjson::Document>(rapidjson::kStringType); | |
| auto& allocator = args->GetAllocator(); | |
| args->SetString(kTextPlainFormat); | |
| auto encoded = JsonMethodCodec::GetInstance().EncodeMethodCall( | |
| MethodCall<rapidjson::Document>(kHasStringsClipboardMethod, | |
| std::move(args))); | |
| MockMethodResult result; | |
| rapidjson::Document document; | |
| document.SetObject(); | |
| rapidjson::Document::AllocatorType& document_allocator = | |
| document.GetAllocator(); | |
| document.AddMember(rapidjson::Value(kValueKey, document_allocator), | |
| rapidjson::Value(false), document_allocator); | |
| EXPECT_CALL(result, SuccessInternal(_)) | |
| .WillOnce([](const rapidjson::Document* document) { | |
| ASSERT_TRUE((*document)[kValueKey].GetBool()); | |
| }); | |
| EXPECT_TRUE(messenger.SimulateEngineMessage( | |
| kChannelName, encoded->data(), encoded->size(), | |
| [&](const uint8_t* reply, size_t reply_size) { | |
| JsonMethodCodec::GetInstance().DecodeAndProcessResponseEnvelope( | |
| reply, reply_size, &result); | |
| })); | |
| } | |
| TEST(PlatformHandler, HasStringsSuccessWithoutStrings) { | |
| TestBinaryMessenger messenger; | |
| FlutterWindowsView view( | |
| std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>()); | |
| // HasStrings will succeed and return false. | |
| PlatformHandler platform_handler(&messenger, &view, []() { | |
| return std::make_unique<TestScopedClipboard>(kErrorSuccess, false); | |
| }); | |
| auto args = std::make_unique<rapidjson::Document>(rapidjson::kStringType); | |
| auto& allocator = args->GetAllocator(); | |
| args->SetString(kTextPlainFormat); | |
| auto encoded = JsonMethodCodec::GetInstance().EncodeMethodCall( | |
| MethodCall<rapidjson::Document>(kHasStringsClipboardMethod, | |
| std::move(args))); | |
| MockMethodResult result; | |
| rapidjson::Document document; | |
| document.SetObject(); | |
| rapidjson::Document::AllocatorType& document_allocator = | |
| document.GetAllocator(); | |
| document.AddMember(rapidjson::Value(kValueKey, document_allocator), | |
| rapidjson::Value(false), document_allocator); | |
| EXPECT_CALL(result, SuccessInternal(_)) | |
| .WillOnce([](const rapidjson::Document* document) { | |
| ASSERT_FALSE((*document)[kValueKey].GetBool()); | |
| }); | |
| EXPECT_TRUE(messenger.SimulateEngineMessage( | |
| kChannelName, encoded->data(), encoded->size(), | |
| [&](const uint8_t* reply, size_t reply_size) { | |
| JsonMethodCodec::GetInstance().DecodeAndProcessResponseEnvelope( | |
| reply, reply_size, &result); | |
| })); | |
| } | |
| TEST(PlatformHandler, HasStringsError) { | |
| TestBinaryMessenger messenger; | |
| FlutterWindowsView view( | |
| std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>()); | |
| // HasStrings will fail. | |
| PlatformHandler platform_handler(&messenger, &view, []() { | |
| return std::make_unique<TestScopedClipboard>(kArbitraryErrorCode, true); | |
| }); | |
| auto args = std::make_unique<rapidjson::Document>(rapidjson::kStringType); | |
| auto& allocator = args->GetAllocator(); | |
| args->SetString(kTextPlainFormat); | |
| auto encoded = JsonMethodCodec::GetInstance().EncodeMethodCall( | |
| MethodCall<rapidjson::Document>(kHasStringsClipboardMethod, | |
| std::move(args))); | |
| MockMethodResult result; | |
| rapidjson::Document document; | |
| document.SetObject(); | |
| rapidjson::Document::AllocatorType& document_allocator = | |
| document.GetAllocator(); | |
| document.AddMember(rapidjson::Value(kValueKey, document_allocator), | |
| rapidjson::Value(false), document_allocator); | |
| EXPECT_CALL(result, SuccessInternal(_)).Times(0); | |
| EXPECT_CALL(result, ErrorInternal(_, _, _)).Times(1); | |
| EXPECT_TRUE(messenger.SimulateEngineMessage( | |
| kChannelName, encoded->data(), encoded->size(), | |
| [&](const uint8_t* reply, size_t reply_size) { | |
| JsonMethodCodec::GetInstance().DecodeAndProcessResponseEnvelope( | |
| reply, reply_size, &result); | |
| })); | |
| } | |
| // Regression test for https://github.com/flutter/flutter/issues/103205. | |
| TEST(PlatformHandler, ReleaseClipboard) { | |
| auto system_clipboard = std::make_shared<MockSystemClipboard>(); | |
| TestBinaryMessenger messenger; | |
| FlutterWindowsView view( | |
| std::make_unique<::testing::NiceMock<MockWindowBindingHandler>>()); | |
| TestPlatformHandler platform_handler(&messenger, &view, [system_clipboard]() { | |
| return std::make_unique<TestScopedClipboard>(kErrorSuccess, false, | |
| system_clipboard); | |
| }); | |
| platform_handler.GetPlainText(std::make_unique<MockMethodResult>(), "text"); | |
| ASSERT_FALSE(system_clipboard->opened); | |
| platform_handler.GetHasStrings(std::make_unique<MockMethodResult>()); | |
| ASSERT_FALSE(system_clipboard->opened); | |
| platform_handler.SetPlainText("", std::make_unique<MockMethodResult>()); | |
| ASSERT_FALSE(system_clipboard->opened); | |
| } | |
| } // namespace testing | |
| } // namespace flutter |