ppapi/tests/test_flash_clipboard.cc

   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
  29 TestFlashClipboard::TestFlashClipboard(TestingInstance* instance)
  30     : TestCase(instance) {
  31 }
  32
  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   RUN_TEST(GetSequenceNumber, filter);
  43 }
  44
  45 bool TestFlashClipboard::ReadStringVar(uint32_t format, std::string* result) {
  46   pp::Var text;
  47   bool success = pp::flash::Clipboard::ReadData(
  48       instance_,
  49       PP_FLASH_CLIPBOARD_TYPE_STANDARD,
  50       format,
  51       &text);
  52   if (success && text.is_string()) {
  53     *result = text.AsString();
  54     return true;
  55   }
  56   return false;
  57 }
  58
  59 bool TestFlashClipboard::WriteStringVar(uint32_t format,
  60                                         const std::string& text) {
  61   std::vector<uint32_t> formats_vector(1, format);
  62   std::vector<pp::Var> data_vector(1, pp::Var(text));
  63   bool success = pp::flash::Clipboard::WriteData(
  64       instance_,
  65       PP_FLASH_CLIPBOARD_TYPE_STANDARD,
  66       formats_vector,
  67       data_vector);
  68   return success;
  69 }
  70
  71 bool TestFlashClipboard::IsFormatAvailableMatches(uint32_t format,
  72                                                   bool expected) {
  73   for (int i = 0; i < kMaxIntervals; ++i) {
  74     bool is_available = pp::flash::Clipboard::IsFormatAvailable(
  75         instance_,
  76         PP_FLASH_CLIPBOARD_TYPE_STANDARD,
  77         format);
  78     if (is_available == expected)
  79       return true;
  80
  81     PlatformSleep(kIntervalMs);
  82   }
  83   return false;
  84 }
  85
  86 bool TestFlashClipboard::ReadPlainTextMatches(const std::string& expected) {
  87   for (int i = 0; i < kMaxIntervals; ++i) {
  88     std::string result;
  89     bool success = ReadStringVar(PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT, &result);
  90     if (success && result == expected)
  91       return true;
  92
  93     PlatformSleep(kIntervalMs);
  94   }
  95   return false;
  96 }
  97
  98 bool TestFlashClipboard::ReadHTMLMatches(const std::string& expected) {
  99   for (int i = 0; i < kMaxIntervals; ++i) {
 100     std::string result;
 101     bool success = ReadStringVar(PP_FLASH_CLIPBOARD_FORMAT_HTML, &result);
 102     // Harmless markup may be inserted around the copied html on some
 103     // platforms, so just check that the pasted string contains the
 104     // copied string. Also check that we only paste the copied fragment, see
 105     // http://code.google.com/p/chromium/issues/detail?id=130827.
 106     if (success && result.find(expected) != std::string::npos &&
 107         result.find("<!--StartFragment-->") == std::string::npos &&
 108         result.find("<!--EndFragment-->") == std::string::npos) {
 109       return true;
 110     }
 111
 112     PlatformSleep(kIntervalMs);
 113   }
 114   return false;
 115 }
 116
 117 uint64_t TestFlashClipboard::GetSequenceNumber(uint64_t last_sequence_number) {
 118   uint64_t next_sequence_number = last_sequence_number;
 119   for (int i = 0; i < kMaxIntervals; ++i) {
 120     pp::flash::Clipboard::GetSequenceNumber(
 121         instance_, PP_FLASH_CLIPBOARD_TYPE_STANDARD, &next_sequence_number);
 122     if (next_sequence_number != last_sequence_number)
 123       return next_sequence_number;
 124
 125     PlatformSleep(kIntervalMs);
 126   }
 127   return next_sequence_number;
 128 }
 129
 130 std::string TestFlashClipboard::TestReadWritePlainText() {
 131   std::string input = "Hello world plain text!";
 132   ASSERT_TRUE(WriteStringVar(PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT, input));
 133   ASSERT_TRUE(IsFormatAvailableMatches(PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT,
 134                                        true));
 135   ASSERT_TRUE(ReadPlainTextMatches(input));
 136
 137   PASS();
 138 }
 139
 140 std::string TestFlashClipboard::TestReadWriteHTML() {
 141   std::string input = "Hello world html!";
 142   ASSERT_TRUE(WriteStringVar(PP_FLASH_CLIPBOARD_FORMAT_HTML, input));
 143   ASSERT_TRUE(IsFormatAvailableMatches(PP_FLASH_CLIPBOARD_FORMAT_HTML, true));
 144   ASSERT_TRUE(ReadHTMLMatches(input));
 145
 146   PASS();
 147 }
 148
 149 std::string TestFlashClipboard::TestReadWriteRTF() {
 150   std::string rtf_string =
 151         "{\\rtf1\\ansi{\\fonttbl\\f0\\fswiss Helvetica;}\\f0\\pard\n"
 152         "This is some {\\b bold} text.\\par\n"
 153         "}";
 154   pp::VarArrayBuffer array_buffer(static_cast<uint32_t>(rtf_string.size()));
 155   char* bytes = static_cast<char*>(array_buffer.Map());
 156   std::copy(rtf_string.data(), rtf_string.data() + rtf_string.size(), bytes);
 157   std::vector<uint32_t> formats_vector(1, PP_FLASH_CLIPBOARD_FORMAT_RTF);
 158   std::vector<pp::Var> data_vector(1, array_buffer);
 159   ASSERT_TRUE(pp::flash::Clipboard::WriteData(
 160       instance_,
 161       PP_FLASH_CLIPBOARD_TYPE_STANDARD,
 162       formats_vector,
 163       data_vector));
 164
 165   ASSERT_TRUE(IsFormatAvailableMatches(PP_FLASH_CLIPBOARD_FORMAT_RTF, true));
 166
 167   pp::Var rtf_result;
 168   ASSERT_TRUE(pp::flash::Clipboard::ReadData(
 169         instance_,
 170         PP_FLASH_CLIPBOARD_TYPE_STANDARD,
 171         PP_FLASH_CLIPBOARD_FORMAT_RTF,
 172         &rtf_result));
 173   ASSERT_TRUE(rtf_result.is_array_buffer());
 174   pp::VarArrayBuffer array_buffer_result(rtf_result);
 175   ASSERT_TRUE(array_buffer_result.ByteLength() == array_buffer.ByteLength());
 176   char* bytes_result = static_cast<char*>(array_buffer_result.Map());
 177   ASSERT_TRUE(std::equal(bytes, bytes + array_buffer.ByteLength(),
 178       bytes_result));
 179
 180   PASS();
 181 }
 182
 183 std::string TestFlashClipboard::TestReadWriteCustomData() {
 184   std::string custom_data = "custom_data";
 185   pp::VarArrayBuffer array_buffer(static_cast<uint32_t>(custom_data.size()));
 186   char* bytes = static_cast<char*>(array_buffer.Map());
 187   std::copy(custom_data.begin(), custom_data.end(), bytes);
 188   uint32_t format_id =
 189       pp::flash::Clipboard::RegisterCustomFormat(instance_, "my-format");
 190   ASSERT_NE(static_cast<uint32_t>(PP_FLASH_CLIPBOARD_FORMAT_INVALID),
 191             format_id);
 192
 193   std::vector<uint32_t> formats_vector(1, format_id);
 194   std::vector<pp::Var> data_vector(1, array_buffer);
 195   ASSERT_TRUE(pp::flash::Clipboard::WriteData(
 196       instance_,
 197       PP_FLASH_CLIPBOARD_TYPE_STANDARD,
 198       formats_vector,
 199       data_vector));
 200
 201   ASSERT_TRUE(IsFormatAvailableMatches(format_id, true));
 202
 203   pp::Var custom_data_result;
 204   ASSERT_TRUE(pp::flash::Clipboard::ReadData(
 205       instance_,
 206       PP_FLASH_CLIPBOARD_TYPE_STANDARD,
 207       format_id,
 208       &custom_data_result));
 209   ASSERT_TRUE(custom_data_result.is_array_buffer());
 210   pp::VarArrayBuffer array_buffer_result(custom_data_result);
 211   ASSERT_EQ(array_buffer_result.ByteLength(), array_buffer.ByteLength());
 212   char* bytes_result = static_cast<char*>(array_buffer_result.Map());
 213   ASSERT_TRUE(std::equal(bytes, bytes + array_buffer.ByteLength(),
 214       bytes_result));
 215
 216   PASS();
 217 }
 218
 219 std::string TestFlashClipboard::TestReadWriteMultipleFormats() {
 220   std::vector<uint32_t> formats;
 221   std::vector<pp::Var> data;
 222   formats.push_back(PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT);
 223   data.push_back(pp::Var("plain text"));
 224   formats.push_back(PP_FLASH_CLIPBOARD_FORMAT_HTML);
 225   data.push_back(pp::Var("html"));
 226   bool success = pp::flash::Clipboard::WriteData(
 227       instance_,
 228       PP_FLASH_CLIPBOARD_TYPE_STANDARD,
 229       formats,
 230       data);
 231   ASSERT_TRUE(success);
 232   ASSERT_TRUE(IsFormatAvailableMatches(PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT,
 233                                        true));
 234   ASSERT_TRUE(IsFormatAvailableMatches(PP_FLASH_CLIPBOARD_FORMAT_HTML, true));
 235   ASSERT_TRUE(ReadPlainTextMatches(data[0].AsString()));
 236   ASSERT_TRUE(ReadHTMLMatches(data[1].AsString()));
 237
 238   PASS();
 239 }
 240
 241 std::string TestFlashClipboard::TestClear() {
 242   std::string input = "Hello world plain text!";
 243   ASSERT_TRUE(WriteStringVar(PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT, input));
 244   ASSERT_TRUE(IsFormatAvailableMatches(PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT,
 245                                        true));
 246   bool success = pp::flash::Clipboard::WriteData(
 247       instance_,
 248       PP_FLASH_CLIPBOARD_TYPE_STANDARD,
 249       std::vector<uint32_t>(),
 250       std::vector<pp::Var>());
 251   ASSERT_TRUE(success);
 252   ASSERT_TRUE(IsFormatAvailableMatches(PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT,
 253                                        false));
 254
 255   PASS();
 256 }
 257
 258 std::string TestFlashClipboard::TestInvalidFormat() {
 259   uint32_t invalid_format = 999;
 260   ASSERT_FALSE(WriteStringVar(invalid_format, "text"));
 261   ASSERT_TRUE(IsFormatAvailableMatches(invalid_format, false));
 262   std::string unused;
 263   ASSERT_FALSE(ReadStringVar(invalid_format, &unused));
 264
 265   PASS();
 266 }
 267
 268 std::string TestFlashClipboard::TestRegisterCustomFormat() {
 269   // Test an empty name is rejected.
 270   uint32_t format_id =
 271       pp::flash::Clipboard::RegisterCustomFormat(instance_, std::string());
 272   ASSERT_EQ(static_cast<uint32_t>(PP_FLASH_CLIPBOARD_FORMAT_INVALID),
 273             format_id);
 274
 275   // Test a valid format name.
 276   format_id = pp::flash::Clipboard::RegisterCustomFormat(instance_, "a-b");
 277   ASSERT_NE(static_cast<uint32_t>(PP_FLASH_CLIPBOARD_FORMAT_INVALID),
 278             format_id);
 279   // Make sure the format doesn't collide with predefined formats.
 280   ASSERT_NE(static_cast<uint32_t>(PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT),
 281             format_id);
 282   ASSERT_NE(static_cast<uint32_t>(PP_FLASH_CLIPBOARD_FORMAT_HTML),
 283             format_id);
 284   ASSERT_NE(static_cast<uint32_t>(PP_FLASH_CLIPBOARD_FORMAT_RTF),
 285             format_id);
 286
 287   // Check that if the same name is registered, the same id comes out.
 288   uint32_t format_id2 =
 289       pp::flash::Clipboard::RegisterCustomFormat(instance_, "a-b");
 290   ASSERT_EQ(format_id, format_id2);
 291
 292   // Check that the second format registered has a different id.
 293   uint32_t format_id3 =
 294       pp::flash::Clipboard::RegisterCustomFormat(instance_, "a-b-c");
 295   ASSERT_NE(format_id, format_id3);
 296
 297   PASS();
 298 }
 299
 300 std::string TestFlashClipboard::TestGetSequenceNumber() {
 301   uint64_t sequence_number_before = 0;
 302   uint64_t sequence_number_after = 0;
 303   ASSERT_TRUE(pp::flash::Clipboard::GetSequenceNumber(
 304       instance_, PP_FLASH_CLIPBOARD_TYPE_STANDARD, &sequence_number_before));
 305
 306   // Test the sequence number changes after writing html.
 307   ASSERT_TRUE(WriteStringVar(PP_FLASH_CLIPBOARD_FORMAT_HTML, "<html>"));
 308   sequence_number_after = GetSequenceNumber(sequence_number_before);
 309   ASSERT_NE(sequence_number_before, sequence_number_after);
 310   sequence_number_before = sequence_number_after;
 311
 312   // Test the sequence number changes after writing some custom data.
 313   std::string custom_data = "custom_data";
 314   pp::VarArrayBuffer array_buffer(static_cast<uint32_t>(custom_data.size()));
 315   char* bytes = static_cast<char*>(array_buffer.Map());
 316   std::copy(custom_data.begin(), custom_data.end(), bytes);
 317   uint32_t format_id =
 318       pp::flash::Clipboard::RegisterCustomFormat(instance_, "my-format");
 319   std::vector<uint32_t> formats_vector(1, format_id);
 320   std::vector<pp::Var> data_vector(1, array_buffer);
 321   ASSERT_TRUE(pp::flash::Clipboard::WriteData(instance_,
 322                                               PP_FLASH_CLIPBOARD_TYPE_STANDARD,
 323                                               formats_vector,
 324                                               data_vector));
 325   sequence_number_after = GetSequenceNumber(sequence_number_before);
 326   ASSERT_NE(sequence_number_before, sequence_number_after);
 327   sequence_number_before = sequence_number_after;
 328
 329   // Read the data and make sure the sequence number doesn't change.
 330   pp::Var custom_data_result;
 331   ASSERT_TRUE(pp::flash::Clipboard::ReadData(
 332       instance_,
 333       PP_FLASH_CLIPBOARD_TYPE_STANDARD,
 334       format_id,
 335       &custom_data_result));
 336   ASSERT_TRUE(pp::flash::Clipboard::GetSequenceNumber(
 337       instance_, PP_FLASH_CLIPBOARD_TYPE_STANDARD, &sequence_number_after));
 338   ASSERT_EQ(sequence_number_before, sequence_number_after);
 339   sequence_number_before = sequence_number_after;
 340
 341   // Clear the clipboard and check the sequence number changes.
 342   pp::flash::Clipboard::WriteData(instance_,
 343                                   PP_FLASH_CLIPBOARD_TYPE_STANDARD,
 344                                   std::vector<uint32_t>(),
 345                                   std::vector<pp::Var>());
 346   sequence_number_after = GetSequenceNumber(sequence_number_before);
 347   ASSERT_NE(sequence_number_before, sequence_number_after);
 348
 349   PASS();
 350 }