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 }
  43
  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
  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
  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
  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
  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
 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
 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
 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
 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(static_cast<uint32_t>(PP_FLASH_CLIPBOARD_FORMAT_INVALID),
 177             format_id);
 178
 179   std::vector<uint32_t> formats_vector(1, format_id);
 180   std::vector<pp::Var> data_vector(1, array_buffer);
 181   ASSERT_TRUE(pp::flash::Clipboard::WriteData(
 182       instance_,
 183       PP_FLASH_CLIPBOARD_TYPE_STANDARD,
 184       formats_vector,
 185       data_vector));
 186
 187   ASSERT_TRUE(IsFormatAvailableMatches(format_id, true));
 188
 189   pp::Var custom_data_result;
 190   ASSERT_TRUE(pp::flash::Clipboard::ReadData(
 191       instance_,
 192       PP_FLASH_CLIPBOARD_TYPE_STANDARD,
 193       format_id,
 194       &custom_data_result));
 195   ASSERT_TRUE(custom_data_result.is_array_buffer());
 196   pp::VarArrayBuffer array_buffer_result(custom_data_result);
 197   ASSERT_EQ(array_buffer_result.ByteLength(), array_buffer.ByteLength());
 198   char* bytes_result = static_cast<char*>(array_buffer_result.Map());
 199   ASSERT_TRUE(std::equal(bytes, bytes + array_buffer.ByteLength(),
 200       bytes_result));
 201
 202   PASS();
 203 }
 204
 205 std::string TestFlashClipboard::TestReadWriteMultipleFormats() {
 206   std::vector<uint32_t> formats;
 207   std::vector<pp::Var> data;
 208   formats.push_back(PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT);
 209   data.push_back(pp::Var("plain text"));
 210   formats.push_back(PP_FLASH_CLIPBOARD_FORMAT_HTML);
 211   data.push_back(pp::Var("html"));
 212   bool success = pp::flash::Clipboard::WriteData(
 213       instance_,
 214       PP_FLASH_CLIPBOARD_TYPE_STANDARD,
 215       formats,
 216       data);
 217   ASSERT_TRUE(success);
 218   ASSERT_TRUE(IsFormatAvailableMatches(PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT,
 219                                        true));
 220   ASSERT_TRUE(IsFormatAvailableMatches(PP_FLASH_CLIPBOARD_FORMAT_HTML, true));
 221   ASSERT_TRUE(ReadPlainTextMatches(data[0].AsString()));
 222   ASSERT_TRUE(ReadHTMLMatches(data[1].AsString()));
 223
 224   PASS();
 225 }
 226
 227 std::string TestFlashClipboard::TestClear() {
 228   std::string input = "Hello world plain text!";
 229   ASSERT_TRUE(WriteStringVar(PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT, input));
 230   ASSERT_TRUE(IsFormatAvailableMatches(PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT,
 231                                        true));
 232   bool success = pp::flash::Clipboard::WriteData(
 233       instance_,
 234       PP_FLASH_CLIPBOARD_TYPE_STANDARD,
 235       std::vector<uint32_t>(),
 236       std::vector<pp::Var>());
 237   ASSERT_TRUE(success);
 238   ASSERT_TRUE(IsFormatAvailableMatches(PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT,
 239                                        false));
 240
 241   PASS();
 242 }
 243
 244 std::string TestFlashClipboard::TestInvalidFormat() {
 245   uint32_t invalid_format = 999;
 246   ASSERT_FALSE(WriteStringVar(invalid_format, "text"));
 247   ASSERT_TRUE(IsFormatAvailableMatches(invalid_format, false));
 248   std::string unused;
 249   ASSERT_FALSE(ReadStringVar(invalid_format, &unused));
 250
 251   PASS();
 252 }
 253
 254 std::string TestFlashClipboard::TestRegisterCustomFormat() {
 255   // Test an empty name is rejected.
 256   uint32_t format_id =
 257       pp::flash::Clipboard::RegisterCustomFormat(instance_, std::string());
 258   ASSERT_EQ(static_cast<uint32_t>(PP_FLASH_CLIPBOARD_FORMAT_INVALID),
 259             format_id);
 260
 261   // Test a valid format name.
 262   format_id = pp::flash::Clipboard::RegisterCustomFormat(instance_, "a-b");
 263   ASSERT_NE(static_cast<uint32_t>(PP_FLASH_CLIPBOARD_FORMAT_INVALID),
 264             format_id);
 265   // Make sure the format doesn't collide with predefined formats.
 266   ASSERT_NE(static_cast<uint32_t>(PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT),
 267             format_id);
 268   ASSERT_NE(static_cast<uint32_t>(PP_FLASH_CLIPBOARD_FORMAT_HTML),
 269             format_id);
 270   ASSERT_NE(static_cast<uint32_t>(PP_FLASH_CLIPBOARD_FORMAT_RTF),
 271             format_id);
 272
 273   // Check that if the same name is registered, the same id comes out.
 274   uint32_t format_id2 =
 275       pp::flash::Clipboard::RegisterCustomFormat(instance_, "a-b");
 276   ASSERT_EQ(format_id, format_id2);
 277
 278   // Check that the second format registered has a different id.
 279   uint32_t format_id3 =
 280       pp::flash::Clipboard::RegisterCustomFormat(instance_, "a-b-c");
 281   ASSERT_NE(format_id, format_id3);
 282
 283   PASS();
 284 }