Move flash clipboard to the new proxy and add custom format support

ppapi/proxy/flash_clipboard_format_registry.cc

Index: ppapi/proxy/flash_clipboard_format_registry.cc
diff --git a/ppapi/proxy/flash_clipboard_format_registry.cc b/ppapi/proxy/flash_clipboard_format_registry.cc
new file mode 100644
index 0000000000000000000000000000000000000000..d7dc4f0253e8eb9117ed83730c1c5d3608146c5b
--- /dev/null
+++ b/ppapi/proxy/flash_clipboard_format_registry.cc
@@ -0,0 +1,95 @@
+#include "ppapi/proxy/flash_clipboard_format_registry.h"
+
+#include <cctype>
+
+namespace ppapi {
+namespace proxy {
+
+namespace {
+// These values are chosen arbitrarily. Flash will never exceed these but if
+// the interface becomes public, we can reconsider these.
+const size_t kMaxNumFormats = 10;
+const size_t kMaxFormatNameLength = 50;
+
+// All formats in PP_Flash_Clipboard_Format should be added here.
+const PP_Flash_Clipboard_Format kPredefinedFormats[] = {

[yzshen1, 2012/10/29 16:55:46]

Is it better to define something like PP_FLASH_CLIPBOARD_FORMAT_COUNT in
PP_Flash_Clipboard_Format enum?

[raymes, 2012/10/29 18:44:58]

As discussed, this could have problems if more values were added to the enum.
Tests should catch the case when this list does not match the enum.

+  PP_FLASH_CLIPBOARD_FORMAT_INVALID,
+  PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT,
+  PP_FLASH_CLIPBOARD_FORMAT_HTML,
+  PP_FLASH_CLIPBOARD_FORMAT_RTF
+};
+
+// The first custom format ID will be the ID after that max value in
+// PP_Flash_Clipboard_Format.
+const size_t kFirstCustomFormat =
+    sizeof(kPredefinedFormats) / sizeof(kPredefinedFormats[0]);
+
+// Checks the validity of the given format name.
+bool IsValidFormatName(const std::string& format_name) {
+  if (format_name.length() == 0 || format_name.length() > kMaxFormatNameLength)
+    return false;
+  return true;
+}
+
+}  // namespace
+
+FlashClipboardFormatRegistry::FlashClipboardFormatRegistry() {
+  custom_formats_.resize(kFirstCustomFormat);
+}
+
+FlashClipboardFormatRegistry::~FlashClipboardFormatRegistry() {
+}
+
+uint32_t FlashClipboardFormatRegistry::RegisterFormat(
+    const std::string& format_name) {
+  if (!IsValidFormatName(format_name) ||
+      custom_formats_.size() > kMaxNumFormats) {
+    return PP_FLASH_CLIPBOARD_FORMAT_INVALID;
+  }
+  custom_formats_.push_back(format_name);
+  return custom_formats_.size() - 1;
+}
+
+void FlashClipboardFormatRegistry::SetRegisteredFormat(
+    const std::string& format_name,
+    uint32_t format) {
+  if (format >= custom_formats_.size())
+    custom_formats_.resize(format + 1);
+  custom_formats_[format] = format_name;
+}
+
+bool FlashClipboardFormatRegistry::IsFormatRegistered(uint32_t format) {
+  return format >= kFirstCustomFormat && format < custom_formats_.size();
+}
+
+std::string FlashClipboardFormatRegistry::GetFormatName(uint32_t format) {
+  if (format >= kFirstCustomFormat && format < custom_formats_.size())
+    return custom_formats_[format];
+  return std::string();
+}
+
+uint32_t FlashClipboardFormatRegistry::GetFormatID(
+    const std::string& format_name) {
+ for (size_t i = kFirstCustomFormat; i < custom_formats_.size(); ++i) {
+   if (custom_formats_[i] == format_name)
+     return i;
+ }
+ return PP_FLASH_CLIPBOARD_FORMAT_INVALID;
+}
+
+// static
+bool FlashClipboardFormatRegistry::IsValidClipboardType(
+    PP_Flash_Clipboard_Type type) {
+  return type == PP_FLASH_CLIPBOARD_TYPE_STANDARD ||
+         type == PP_FLASH_CLIPBOARD_TYPE_SELECTION;
+}
+
+// static
+bool FlashClipboardFormatRegistry::IsValidPredefinedFormat(uint32_t format) {
+  if (format == PP_FLASH_CLIPBOARD_FORMAT_INVALID)
+    return false;
+  return format < kFirstCustomFormat;
+}
+
+}  // proxy
+}  // ppapi