Make Clipboard::FormatType an opaque handle type.

ui/base/clipboard/clipboard_aurax11.cc

Index: ui/base/clipboard/clipboard_aurax11.cc
diff --git a/ui/base/clipboard/clipboard_aurax11.cc b/ui/base/clipboard/clipboard_aurax11.cc
index 4e16aefe855ddf4a0ae51a7f0e9e6754bdfb1230..8f8ce0ccb58bee76945995c2806184713d86fba0 100644
--- a/ui/base/clipboard/clipboard_aurax11.cc
+++ b/ui/base/clipboard/clipboard_aurax11.cc
@@ -4,6 +4,7 @@
 
 #include "ui/base/clipboard/clipboard.h"
 
+#include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
 #include "third_party/skia/include/core/SkBitmap.h"
@@ -135,6 +136,16 @@ void DeleteClipboardData() {
 // 3. Implement File types.
 // 4. Handle conversion between types.
 
+Clipboard::FormatType::FormatType() {
+}
+
+Clipboard::FormatType::FormatType(const std::string& native_format)
+    : data_(native_format) {
+}
+
+Clipboard::FormatType::~FormatType() {
+}
+
 Clipboard::Clipboard() {
   // Make sure clipboard is created.
   GetClipboardData();
@@ -156,24 +167,19 @@ void Clipboard::WriteObjects(const ObjectMap& objects) {
 bool Clipboard::IsFormatAvailable(const FormatType& format,
                                   Buffer buffer) const {
   ClipboardData* data = GetClipboardData();
-  if (GetPlainTextFormatType() == format)
+  if (GetPlainTextFormatType().data() == format.data())

[tony, 2011/12/06 18:58:29]

Would it be worth adding an Equals method to FormatType?

Also, it looks like we just use .data() in the platform specific files.  It
might be clearer to just make methods for each OS (ToString, ToGtkAtom,
ToNSString, etc). This is like what we do in ui/gfx/rect.h.

[dcheng, 2011/12/06 22:57:02]

Done (for both).

     return !data->text().empty();
-  else if (GetHtmlFormatType() == format)
+  else if (GetHtmlFormatType().data() == format.data())
     return !data->markup_data().empty() || !data->url().empty();
-  else if (GetBitmapFormatType() == format)
+  else if (GetBitmapFormatType().data() == format.data())
     return !!data->bitmap_data();
-  else if (GetWebKitSmartPasteFormatType() == format)
+  else if (GetWebKitSmartPasteFormatType().data() == format.data())
     return data->web_smart_paste();
-  else if (data->custom_data_format() == format)
+  else if (data->custom_data_format() == format.data())
     return true;
   return false;
 }
 
-bool Clipboard::IsFormatAvailableByString(const std::string& format,
-                                          Buffer buffer) const {
-  return IsFormatAvailable(format, buffer);
-}
-
 void Clipboard::ReadAvailableTypes(Buffer buffer, std::vector<string16>* types,
     bool* contains_filenames) const {
   if (!types || !contains_filenames) {
@@ -183,13 +189,11 @@ void Clipboard::ReadAvailableTypes(Buffer buffer, std::vector<string16>* types,
 
   types->clear();
   if (IsFormatAvailable(GetPlainTextFormatType(), buffer))
-    types->push_back(UTF8ToUTF16(GetPlainTextFormatType()));
+    types->push_back(UTF8ToUTF16(GetPlainTextFormatType().data()));
   if (IsFormatAvailable(GetHtmlFormatType(), buffer))
-    types->push_back(UTF8ToUTF16(GetHtmlFormatType()));
+    types->push_back(UTF8ToUTF16(GetHtmlFormatType().data()));
   if (IsFormatAvailable(GetBitmapFormatType(), buffer))
-    types->push_back(UTF8ToUTF16(GetBitmapFormatType()));
-  if (IsFormatAvailable(GetWebKitSmartPasteFormatType(), buffer))
-    types->push_back(UTF8ToUTF16(GetWebKitSmartPasteFormatType()));
+    types->push_back(UTF8ToUTF16(GetBitmapFormatType().data()));
   *contains_filenames = false;
 }
 
@@ -262,10 +266,10 @@ void Clipboard::ReadFiles(std::vector<FilePath>* files) const {
   NOTIMPLEMENTED();
 }
 
-void Clipboard::ReadData(const std::string& format, std::string* result) const {
+void Clipboard::ReadData(const FormatType& format, std::string* result) const {
   result->clear();
   ClipboardData* data = GetClipboardData();
-  if (data->custom_data_format() == format)
+  if (data->custom_data_format() == format.data())
     *result = std::string(data->custom_data_data(), data->custom_data_len());
 }
 
@@ -302,40 +306,60 @@ void Clipboard::WriteBitmap(const char* pixel_data, const char* size_data) {
   GetClipboardData()->SetBitmapData(pixel_data, size_data);
 }
 
-void Clipboard::WriteData(const char* format_name, size_t format_len,
-                          const char* data_data, size_t data_len) {
-  GetClipboardData()->SetCustomData(std::string(format_name, format_len),
-      data_data, data_len);
+void Clipboard::WriteData(const FormatType& format,
+                          const char* data_data,
+                          size_t data_len) {
+  GetClipboardData()->SetCustomData(format.data(), data_data, data_len);
+}
+
+// static
+Clipboard::FormatType Clipboard::RegisterFormatType(
+    const std::string& format_string) {
+  return StringToFormatType(format_string);
+}
+
+std::string Clipboard::FormatTypeToString(const FormatType& type) {
+  return type.data();
+}
+
+Clipboard::FormatType Clipboard::StringToFormatType(
+    const std::string& format_string) {
+  return FormatType(format_string);
 }
 
 // static
-Clipboard::FormatType Clipboard::GetPlainTextFormatType() {
-  return std::string(kMimeTypeText);
+const Clipboard::FormatType& Clipboard::GetPlainTextFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeText));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetPlainTextWFormatType() {
+const Clipboard::FormatType& Clipboard::GetPlainTextWFormatType() {
   return GetPlainTextFormatType();
 }
 
 // static
-Clipboard::FormatType Clipboard::GetHtmlFormatType() {
-  return std::string(kMimeTypeHTML);
+const Clipboard::FormatType& Clipboard::GetHtmlFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeHTML));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetBitmapFormatType() {
-  return std::string(kMimeTypeBitmap);
+const Clipboard::FormatType& Clipboard::GetBitmapFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeBitmap));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetWebKitSmartPasteFormatType() {
-  return std::string(kMimeTypeWebkitSmartPaste);
+const Clipboard::FormatType& Clipboard::GetWebKitSmartPasteFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeWebkitSmartPaste));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetWebCustomDataFormatType() {
-  return std::string(kMimeTypeWebCustomData);
+const Clipboard::FormatType& Clipboard::GetWebCustomDataFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeWebCustomData));
+  return type;
 }
 
 }  // namespace ui