Modified the flash cipboard interface to add html clipboard support.

ppapi/cpp/private/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/cpp/private/flash_clipboard.h"
 
+#include <vector>
+
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/cpp/instance.h"
+#include "ppapi/cpp/logging.h"
 #include "ppapi/cpp/module_impl.h"
 #include "ppapi/cpp/var.h"
 
 namespace pp {
 
 namespace {
 
 template <> const char* interface_name<PPB_Flash_Clipboard>() {
   return PPB_FLASH_CLIPBOARD_INTERFACE;
 }
 
+template <> const char* interface_name<PPB_Flash_Clipboard_3_0>() {
+  return PPB_FLASH_CLIPBOARD_INTERFACE_3_0;
+}
+
 }  // namespace
 
 namespace flash {
 
 // static
 bool Clipboard::IsAvailable() {
   return has_interface<PPB_Flash_Clipboard>();
 }
 
 // static
 bool Clipboard::IsFormatAvailable(Instance* instance,
                                   PP_Flash_Clipboard_Type clipboard_type,
                                   PP_Flash_Clipboard_Format format) {
   bool rv = false;
   if (has_interface<PPB_Flash_Clipboard>()) {
     rv = PP_ToBool(get_interface<PPB_Flash_Clipboard>()->IsFormatAvailable(
         instance->pp_instance(), clipboard_type, format));
   }
   return rv;
 }
 
 // static
-bool Clipboard::ReadPlainText(Instance* instance,
-                              PP_Flash_Clipboard_Type clipboard_type,
-                              std::string* text_out) {
-  bool rv = false;
-  if (has_interface<PPB_Flash_Clipboard>()) {
-    Var v(Var::PassRef(),
-          get_interface<PPB_Flash_Clipboard>()->ReadPlainText(
-              instance->pp_instance(),
-              clipboard_type));
-    if (v.is_string()) {
-      rv = true;
-      *text_out = v.AsString();
+bool Clipboard::ReadData(Instance* instance,
+    PP_Flash_Clipboard_Type clipboard_type,
+    PP_Flash_Clipboard_Format clipboard_format,
+    PP_Var* out) {
+  if (has_interface<PPB_Flash_Clipboard>() ||
+      (has_interface<PPB_Flash_Clipboard_3_0>() &&
+       clipboard_format == PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT)) {
+    bool rv = false;
+    if (has_interface<PPB_Flash_Clipboard>()) {
+      *out = get_interface<PPB_Flash_Clipboard>()->ReadData(
+          instance->pp_instance(),
+          clipboard_type,
+          clipboard_format);
     }
+    return rv;
   }
-  return rv;
+  else {
+    return false;
+  }
 }
 
 // static
-bool Clipboard::WritePlainText(Instance* instance,
-                               PP_Flash_Clipboard_Type clipboard_type,
-                               const std::string& text) {
-  bool rv = false;
-  if (has_interface<PPB_Flash_Clipboard>()) {
-    rv = (get_interface<PPB_Flash_Clipboard>()->WritePlainText(
+bool Clipboard::WriteData(Instance* instance,
+    PP_Flash_Clipboard_Type clipboard_type,
+    const std::vector<PP_Flash_Clipboard_Data_Item>& data_items) {
+  if (has_interface<PPB_Flash_Clipboard>() ||
+      has_interface<PPB_Flash_Clipboard_3_0>()) {
+    bool rv = false;
+    PP_Flash_Clipboard_Data_Item* data_items_array =
+        new PP_Flash_Clipboard_Data_Item[data_items.size()];
+
+    uint32_t data_items_array_size = 0;
+    for (std::vector<PP_Flash_Clipboard_Data_Item>::const_iterator
+        i = data_items.begin(); i != data_items.end(); ++i) {
+      if (has_interface<PPB_Flash_Clipboard_3_0>() &&
+          i->format != PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT) {
+          continue;
+      }
+
+      data_items_array[data_items_array_size] = *i;
+      ++data_items_array_size;
+    }
+
+    rv = (get_interface<PPB_Flash_Clipboard>()->WriteData(
               instance->pp_instance(),
               clipboard_type,
-              Var(text).pp_var()) == PP_OK);
+              data_items_array_size,
+              data_items_array) == PP_OK);
+    delete[] data_items_array;
+    return rv;
   }
-  return rv;
+  else {
+    return false;
+  }
 }
 
 }  // namespace flash
 }  // namespace pp