clipboard_aura_unittest.cc 4.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135
  1. // Copyright 2014 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "remoting/host/chromeos/clipboard_aura.h"
  5. #include <memory>
  6. #include "base/bind.h"
  7. #include "base/callback_helpers.h"
  8. #include "base/memory/ptr_util.h"
  9. #include "base/run_loop.h"
  10. #include "base/strings/utf_string_conversions.h"
  11. #include "base/task/single_thread_task_runner.h"
  12. #include "base/test/task_environment.h"
  13. #include "base/test/test_timeouts.h"
  14. #include "remoting/base/constants.h"
  15. #include "remoting/proto/event.pb.h"
  16. #include "remoting/protocol/clipboard_stub.h"
  17. #include "testing/gmock/include/gmock/gmock.h"
  18. #include "testing/gtest/include/gtest/gtest.h"
  19. #include "ui/base/clipboard/clipboard.h"
  20. #include "ui/base/clipboard/scoped_clipboard_writer.h"
  21. using testing::_;
  22. using testing::Eq;
  23. using testing::InvokeWithoutArgs;
  24. using testing::Property;
  25. namespace remoting {
  26. namespace {
  27. const base::TimeDelta kTestOverridePollingInterval = base::Milliseconds(1);
  28. class ClientClipboard : public protocol::ClipboardStub {
  29. public:
  30. ClientClipboard();
  31. ClientClipboard(const ClientClipboard&) = delete;
  32. ClientClipboard& operator=(const ClientClipboard&) = delete;
  33. MOCK_METHOD1(InjectClipboardEvent,
  34. void(const protocol::ClipboardEvent& event));
  35. };
  36. ClientClipboard::ClientClipboard() = default;
  37. } // namespace
  38. class ClipboardAuraTest : public testing::Test {
  39. public:
  40. ClipboardAuraTest() = default;
  41. void SetUp() override;
  42. void TearDown() override;
  43. protected:
  44. void StopAndResetClipboard();
  45. base::test::TaskEnvironment task_environment_{
  46. base::test::TaskEnvironment::MainThreadType::UI};
  47. ClientClipboard* client_clipboard_;
  48. std::unique_ptr<ClipboardAura> clipboard_;
  49. };
  50. void ClipboardAuraTest::SetUp() {
  51. // Alert the clipboard class to which threads are allowed to access the
  52. // clipboard.
  53. std::vector<base::PlatformThreadId> allowed_clipboard_threads;
  54. allowed_clipboard_threads.push_back(base::PlatformThread::CurrentId());
  55. ui::Clipboard::SetAllowedThreads(allowed_clipboard_threads);
  56. // Setup the clipboard.
  57. client_clipboard_ = new ClientClipboard();
  58. clipboard_ = std::make_unique<ClipboardAura>();
  59. EXPECT_GT(TestTimeouts::tiny_timeout(), kTestOverridePollingInterval * 10)
  60. << "The test timeout should be greater than the polling interval";
  61. clipboard_->SetPollingIntervalForTesting(kTestOverridePollingInterval);
  62. clipboard_->Start(base::WrapUnique(client_clipboard_));
  63. }
  64. void ClipboardAuraTest::TearDown() {
  65. ui::Clipboard::DestroyClipboardForCurrentThread();
  66. }
  67. void ClipboardAuraTest::StopAndResetClipboard() {
  68. clipboard_.reset();
  69. }
  70. TEST_F(ClipboardAuraTest, WriteToClipboard) {
  71. protocol::ClipboardEvent event;
  72. event.set_mime_type(kMimeTypeTextUtf8);
  73. event.set_data("Test data.");
  74. clipboard_->InjectClipboardEvent(event);
  75. StopAndResetClipboard();
  76. base::RunLoop().RunUntilIdle();
  77. std::string clipboard_data;
  78. ui::Clipboard* aura_clipboard = ui::Clipboard::GetForCurrentThread();
  79. aura_clipboard->ReadAsciiText(ui::ClipboardBuffer::kCopyPaste,
  80. /* data_dst = */ nullptr, &clipboard_data);
  81. EXPECT_EQ(clipboard_data, "Test data.")
  82. << "InjectClipboardEvent should write to aura clipboard";
  83. }
  84. TEST_F(ClipboardAuraTest, MonitorClipboardChanges) {
  85. base::RunLoop().RunUntilIdle();
  86. {
  87. // |clipboard_writer| will write to the clipboard when it goes out of scope.
  88. ui::ScopedClipboardWriter clipboard_writer(ui::ClipboardBuffer::kCopyPaste);
  89. clipboard_writer.WriteText(u"Test data.");
  90. }
  91. EXPECT_CALL(*client_clipboard_,
  92. InjectClipboardEvent(Property(&protocol::ClipboardEvent::data,
  93. Eq("Test data.")))).Times(1);
  94. base::RunLoop run_loop;
  95. task_environment_.GetMainThreadTaskRunner()->PostDelayedTask(
  96. FROM_HERE,
  97. base::BindOnce(&ClipboardAuraTest_MonitorClipboardChanges_Test::
  98. StopAndResetClipboard,
  99. base::Unretained(this)),
  100. TestTimeouts::tiny_timeout());
  101. task_environment_.GetMainThreadTaskRunner()->PostDelayedTask(
  102. FROM_HERE, run_loop.QuitClosure(), TestTimeouts::tiny_timeout());
  103. run_loop.Run();
  104. }
  105. } // namespace remoting