Added RTF support to pepper API.

ppapi/tests/test_flash_clipboard.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ppapi/tests/test_flash_clipboard.h"
 
+#include <algorithm>
 #include <vector>
 
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/point.h"
 #include "ppapi/cpp/private/flash_clipboard.h"
+#include "ppapi/cpp/var.h"
+#include "ppapi/cpp/var_array_buffer.h"
 #include "ppapi/tests/testing_instance.h"
 
 REGISTER_TEST_CASE(FlashClipboard);
 
 // WriteData() sends an async request to the browser process. As a result, the
 // string written may not be reflected by IsFormatAvailable() or ReadPlainText()
 // immediately. We need to wait and retry.
 const int kIntervalMs = 250;
 const int kMaxIntervals = kActionTimeoutMs / kIntervalMs;
 
 TestFlashClipboard::TestFlashClipboard(TestingInstance* instance)
     : TestCase(instance) {
 }
 
 void TestFlashClipboard::RunTests(const std::string& filter) {
   RUN_TEST(ReadWritePlainText, filter);
   RUN_TEST(ReadWriteHTML, filter);
+  RUN_TEST(ReadWriteRTF, filter);
   RUN_TEST(ReadWriteMultipleFormats, filter);
   RUN_TEST(Clear, filter);
 }
 
 std::string TestFlashClipboard::ReadStringVar(
     PP_Flash_Clipboard_Format format) {
   pp::Var text;
   bool success = pp::flash::Clipboard::ReadData(
       instance_,
       PP_FLASH_CLIPBOARD_TYPE_STANDARD,
@@ skipping 67 matching lines @@
 }
 
 std::string TestFlashClipboard::TestReadWriteHTML() {
   std::string input = "Hello world html!";
   ASSERT_TRUE(WriteStringVar(PP_FLASH_CLIPBOARD_FORMAT_HTML, input));
   ASSERT_TRUE(IsFormatAvailableMatches(PP_FLASH_CLIPBOARD_FORMAT_HTML, true));
   ASSERT_TRUE(ReadHTMLMatches(input));
 
   PASS();
 }
 

[viettrungluu, 2012/03/29 21:25:10]

While you're at it, could you add tests to verify that the various functions
return appropriate values[*] (e.g., error codes or whatever) when passed invalid
values for the format, etc.?

[*] Such tests also help verify that the browser doesn't blow up, etc.

+std::string TestFlashClipboard::TestReadWriteRTF() {
+  std::string rtf_string =
+        "{\\rtf1\\ansi{\\fonttbl\\f0\\fswiss Helvetica;}\\f0\\pard\n"
+        "This is some {\\b bold} text.\\par\n"
+        "}";
+  pp::VarArrayBuffer array_buffer(rtf_string.size());
+  char *bytes = static_cast<char*>(array_buffer.Map());
+  std::copy(rtf_string.data(), rtf_string.data() + rtf_string.size(), bytes);
+  std::vector<PP_Flash_Clipboard_Format> formats_vector(1,
+      PP_FLASH_CLIPBOARD_FORMAT_RTF);
+  std::vector<pp::Var> data_vector(1, array_buffer);
+  ASSERT_TRUE(pp::flash::Clipboard::WriteData(
+      instance_,
+      PP_FLASH_CLIPBOARD_TYPE_STANDARD,
+      formats_vector,
+      data_vector));
+
+  ASSERT_TRUE(IsFormatAvailableMatches(PP_FLASH_CLIPBOARD_FORMAT_RTF, true));
+
+  pp::Var rtf_result;
+  ASSERT_TRUE(pp::flash::Clipboard::ReadData(
+        instance_,
+        PP_FLASH_CLIPBOARD_TYPE_STANDARD,
+        PP_FLASH_CLIPBOARD_FORMAT_RTF,
+        &rtf_result));
+  ASSERT_TRUE(rtf_result.is_array_buffer());
+  pp::VarArrayBuffer array_buffer_result(rtf_result);
+  ASSERT_TRUE(array_buffer_result.ByteLength() == array_buffer.ByteLength());
+  char *bytes_result = static_cast<char*>(array_buffer_result.Map());
+  ASSERT_TRUE(std::equal(bytes, bytes + array_buffer.ByteLength(),
+      bytes_result));
+
+  PASS();
+}
+
 std::string TestFlashClipboard::TestReadWriteMultipleFormats() {
   std::vector<PP_Flash_Clipboard_Format> formats;
   std::vector<pp::Var> data;
   formats.push_back(PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT);
   data.push_back(pp::Var("plain text"));
   formats.push_back(PP_FLASH_CLIPBOARD_FORMAT_HTML);
   data.push_back(pp::Var("html"));
   bool success = pp::flash::Clipboard::WriteData(
       instance_,
       PP_FLASH_CLIPBOARD_TYPE_STANDARD,
@@ skipping 18 matching lines @@
       instance_,
       PP_FLASH_CLIPBOARD_TYPE_STANDARD,
       std::vector<PP_Flash_Clipboard_Format>(),
       std::vector<pp::Var>());
   ASSERT_TRUE(success);
   ASSERT_TRUE(IsFormatAvailableMatches(PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT,
                                        false));
 
   PASS();
 }