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(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
 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
 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
 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
 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 }