1 // Copyright (c) 2012 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
5 #include "ppapi/tests/test_flash_clipboard.h"
6
7 #include <algorithm>
8 #include <vector>
9
10 #include "ppapi/cpp/instance.h"
11 #include "ppapi/cpp/module.h"
12 #include "ppapi/cpp/point.h"
13 #include "ppapi/cpp/private/flash_clipboard.h"
14 #include "ppapi/cpp/var.h"
15 #include "ppapi/cpp/var_array_buffer.h"
16 #include "ppapi/tests/testing_instance.h"
17
18 // http://crbug.com/176822
19 #if !defined(OS_WIN)
20 REGISTER_TEST_CASE(FlashClipboard);
21 #endif
22
23 // WriteData() sends an async request to the browser process. As a result, the
24 // string written may not be reflected by IsFormatAvailable() or ReadPlainText()
25 // immediately. We need to wait and retry.
26 const int kIntervalMs = 250;
27 const int kMaxIntervals = kActionTimeoutMs / kIntervalMs;
28
TestFlashClipboard(TestingInstance * instance)29 TestFlashClipboard::TestFlashClipboard(TestingInstance* instance)
30 : TestCase(instance) {
31 }
32
RunTests(const std::string & filter)33 void TestFlashClipboard::RunTests(const std::string& filter) {
34 RUN_TEST(ReadWritePlainText, filter);
35 RUN_TEST(ReadWriteHTML, filter);
36 RUN_TEST(ReadWriteRTF, filter);
37 RUN_TEST(ReadWriteCustomData, filter);
38 RUN_TEST(ReadWriteMultipleFormats, filter);
39 RUN_TEST(Clear, filter);
40 RUN_TEST(InvalidFormat, filter);
41 RUN_TEST(RegisterCustomFormat, filter);
42 }
43
ReadStringVar(uint32_t format,std::string * result)44 bool TestFlashClipboard::ReadStringVar(uint32_t format, std::string* result) {
45 pp::Var text;
46 bool success = pp::flash::Clipboard::ReadData(
47 instance_,
48 PP_FLASH_CLIPBOARD_TYPE_STANDARD,
49 format,
50 &text);
51 if (success && text.is_string()) {
52 *result = text.AsString();
53 return true;
54 }
55 return false;
56 }
57
WriteStringVar(uint32_t format,const std::string & text)58 bool TestFlashClipboard::WriteStringVar(uint32_t format,
59 const std::string& text) {
60 std::vector<uint32_t> formats_vector(1, format);
61 std::vector<pp::Var> data_vector(1, pp::Var(text));
62 bool success = pp::flash::Clipboard::WriteData(
63 instance_,
64 PP_FLASH_CLIPBOARD_TYPE_STANDARD,
65 formats_vector,
66 data_vector);
67 return success;
68 }
69
IsFormatAvailableMatches(uint32_t format,bool expected)70 bool TestFlashClipboard::IsFormatAvailableMatches(uint32_t format,
71 bool expected) {
72 for (int i = 0; i < kMaxIntervals; ++i) {
73 bool is_available = pp::flash::Clipboard::IsFormatAvailable(
74 instance_,
75 PP_FLASH_CLIPBOARD_TYPE_STANDARD,
76 format);
77 if (is_available == expected)
78 return true;
79
80 PlatformSleep(kIntervalMs);
81 }
82 return false;
83 }
84
ReadPlainTextMatches(const std::string & expected)85 bool TestFlashClipboard::ReadPlainTextMatches(const std::string& expected) {
86 for (int i = 0; i < kMaxIntervals; ++i) {
87 std::string result;
88 bool success = ReadStringVar(PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT, &result);
89 if (success && result == expected)
90 return true;
91
92 PlatformSleep(kIntervalMs);
93 }
94 return false;
95 }
96
ReadHTMLMatches(const std::string & expected)97 bool TestFlashClipboard::ReadHTMLMatches(const std::string& expected) {
98 for (int i = 0; i < kMaxIntervals; ++i) {
99 std::string result;
100 bool success = ReadStringVar(PP_FLASH_CLIPBOARD_FORMAT_HTML, &result);
101 // Harmless markup may be inserted around the copied html on some
102 // platforms, so just check that the pasted string contains the
103 // copied string. Also check that we only paste the copied fragment, see
104 // http://code.google.com/p/chromium/issues/detail?id=130827.
105 if (success && result.find(expected) != std::string::npos &&
106 result.find("<!--StartFragment-->") == std::string::npos &&
107 result.find("<!--EndFragment-->") == std::string::npos) {
108 return true;
109 }
110
111 PlatformSleep(kIntervalMs);
112 }
113 return false;
114 }
115
TestReadWritePlainText()116 std::string TestFlashClipboard::TestReadWritePlainText() {
117 std::string input = "Hello world plain text!";
118 ASSERT_TRUE(WriteStringVar(PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT, input));
119 ASSERT_TRUE(IsFormatAvailableMatches(PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT,
120 true));
121 ASSERT_TRUE(ReadPlainTextMatches(input));
122
123 PASS();
124 }
125
TestReadWriteHTML()126 std::string TestFlashClipboard::TestReadWriteHTML() {
127 std::string input = "Hello world html!";
128 ASSERT_TRUE(WriteStringVar(PP_FLASH_CLIPBOARD_FORMAT_HTML, input));
129 ASSERT_TRUE(IsFormatAvailableMatches(PP_FLASH_CLIPBOARD_FORMAT_HTML, true));
130 ASSERT_TRUE(ReadHTMLMatches(input));
131
132 PASS();
133 }
134
TestReadWriteRTF()135 std::string TestFlashClipboard::TestReadWriteRTF() {
136 std::string rtf_string =
137 "{\\rtf1\\ansi{\\fonttbl\\f0\\fswiss Helvetica;}\\f0\\pard\n"
138 "This is some {\\b bold} text.\\par\n"
139 "}";
140 pp::VarArrayBuffer array_buffer(rtf_string.size());
141 char* bytes = static_cast<char*>(array_buffer.Map());
142 std::copy(rtf_string.data(), rtf_string.data() + rtf_string.size(), bytes);
143 std::vector<uint32_t> formats_vector(1, PP_FLASH_CLIPBOARD_FORMAT_RTF);
144 std::vector<pp::Var> data_vector(1, array_buffer);
145 ASSERT_TRUE(pp::flash::Clipboard::WriteData(
146 instance_,
147 PP_FLASH_CLIPBOARD_TYPE_STANDARD,
148 formats_vector,
149 data_vector));
150
151 ASSERT_TRUE(IsFormatAvailableMatches(PP_FLASH_CLIPBOARD_FORMAT_RTF, true));
152
153 pp::Var rtf_result;
154 ASSERT_TRUE(pp::flash::Clipboard::ReadData(
155 instance_,
156 PP_FLASH_CLIPBOARD_TYPE_STANDARD,
157 PP_FLASH_CLIPBOARD_FORMAT_RTF,
158 &rtf_result));
159 ASSERT_TRUE(rtf_result.is_array_buffer());
160 pp::VarArrayBuffer array_buffer_result(rtf_result);
161 ASSERT_TRUE(array_buffer_result.ByteLength() == array_buffer.ByteLength());
162 char* bytes_result = static_cast<char*>(array_buffer_result.Map());
163 ASSERT_TRUE(std::equal(bytes, bytes + array_buffer.ByteLength(),
164 bytes_result));
165
166 PASS();
167 }
168
TestReadWriteCustomData()169 std::string TestFlashClipboard::TestReadWriteCustomData() {
170 std::string custom_data = "custom_data";
171 pp::VarArrayBuffer array_buffer(custom_data.size());
172 char* bytes = static_cast<char*>(array_buffer.Map());
173 std::copy(custom_data.begin(), custom_data.end(), bytes);
174 uint32_t format_id =
175 pp::flash::Clipboard::RegisterCustomFormat(instance_, "my-format");
176 ASSERT_NE(format_id, PP_FLASH_CLIPBOARD_FORMAT_INVALID);
177
178 std::vector<uint32_t> formats_vector(1, format_id);
179 std::vector<pp::Var> data_vector(1, array_buffer);
180 ASSERT_TRUE(pp::flash::Clipboard::WriteData(
181 instance_,
182 PP_FLASH_CLIPBOARD_TYPE_STANDARD,
183 formats_vector,
184 data_vector));
185
186 ASSERT_TRUE(IsFormatAvailableMatches(format_id, true));
187
188 pp::Var custom_data_result;
189 ASSERT_TRUE(pp::flash::Clipboard::ReadData(
190 instance_,
191 PP_FLASH_CLIPBOARD_TYPE_STANDARD,
192 format_id,
193 &custom_data_result));
194 ASSERT_TRUE(custom_data_result.is_array_buffer());
195 pp::VarArrayBuffer array_buffer_result(custom_data_result);
196 ASSERT_EQ(array_buffer_result.ByteLength(), array_buffer.ByteLength());
197 char* bytes_result = static_cast<char*>(array_buffer_result.Map());
198 ASSERT_TRUE(std::equal(bytes, bytes + array_buffer.ByteLength(),
199 bytes_result));
200
201 PASS();
202 }
203
TestReadWriteMultipleFormats()204 std::string TestFlashClipboard::TestReadWriteMultipleFormats() {
205 std::vector<uint32_t> formats;
206 std::vector<pp::Var> data;
207 formats.push_back(PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT);
208 data.push_back(pp::Var("plain text"));
209 formats.push_back(PP_FLASH_CLIPBOARD_FORMAT_HTML);
210 data.push_back(pp::Var("html"));
211 bool success = pp::flash::Clipboard::WriteData(
212 instance_,
213 PP_FLASH_CLIPBOARD_TYPE_STANDARD,
214 formats,
215 data);
216 ASSERT_TRUE(success);
217 ASSERT_TRUE(IsFormatAvailableMatches(PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT,
218 true));
219 ASSERT_TRUE(IsFormatAvailableMatches(PP_FLASH_CLIPBOARD_FORMAT_HTML, true));
220 ASSERT_TRUE(ReadPlainTextMatches(data[0].AsString()));
221 ASSERT_TRUE(ReadHTMLMatches(data[1].AsString()));
222
223 PASS();
224 }
225
TestClear()226 std::string TestFlashClipboard::TestClear() {
227 std::string input = "Hello world plain text!";
228 ASSERT_TRUE(WriteStringVar(PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT, input));
229 ASSERT_TRUE(IsFormatAvailableMatches(PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT,
230 true));
231 bool success = pp::flash::Clipboard::WriteData(
232 instance_,
233 PP_FLASH_CLIPBOARD_TYPE_STANDARD,
234 std::vector<uint32_t>(),
235 std::vector<pp::Var>());
236 ASSERT_TRUE(success);
237 ASSERT_TRUE(IsFormatAvailableMatches(PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT,
238 false));
239
240 PASS();
241 }
242
TestInvalidFormat()243 std::string TestFlashClipboard::TestInvalidFormat() {
244 uint32_t invalid_format = 999;
245 ASSERT_FALSE(WriteStringVar(invalid_format, "text"));
246 ASSERT_TRUE(IsFormatAvailableMatches(invalid_format, false));
247 std::string unused;
248 ASSERT_FALSE(ReadStringVar(invalid_format, &unused));
249
250 PASS();
251 }
252
TestRegisterCustomFormat()253 std::string TestFlashClipboard::TestRegisterCustomFormat() {
254 // Test an empty name is rejected.
255 uint32_t format_id =
256 pp::flash::Clipboard::RegisterCustomFormat(instance_, std::string());
257 ASSERT_EQ(format_id, PP_FLASH_CLIPBOARD_FORMAT_INVALID);
258
259 // Test a valid format name.
260 format_id = pp::flash::Clipboard::RegisterCustomFormat(instance_, "a-b");
261 ASSERT_NE(format_id, PP_FLASH_CLIPBOARD_FORMAT_INVALID);
262 // Make sure the format doesn't collide with predefined formats.
263 ASSERT_NE(format_id, PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT);
264 ASSERT_NE(format_id, PP_FLASH_CLIPBOARD_FORMAT_HTML);
265 ASSERT_NE(format_id, PP_FLASH_CLIPBOARD_FORMAT_RTF);
266
267 // Check that if the same name is registered, the same id comes out.
268 uint32_t format_id2 =
269 pp::flash::Clipboard::RegisterCustomFormat(instance_, "a-b");
270 ASSERT_EQ(format_id, format_id2);
271
272 // Check that the second format registered has a different id.
273 uint32_t format_id3 =
274 pp::flash::Clipboard::RegisterCustomFormat(instance_, "a-b-c");
275 ASSERT_NE(format_id, format_id3);
276
277 PASS();
278 }
279