Make Clipboard::FormatType an opaque handle type.

ui/base/clipboard/clipboard_aurax11.cc

 // Copyright (c) 2011 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 "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"
 #include "ui/gfx/linux_util.h"
 #include "ui/gfx/size.h"
 
 namespace ui {
 
 namespace {
 const char kMimeTypeBitmap[] = "image/bmp";
@@ skipping 111 matching lines @@
 
 }  // namespace
 
 // TODO(varunjain): Complete implementation:
 // 1. Handle different types of BUFFERs.
 // 2. Do we need to care about concurrency here? Can there be multiple instances
 //    of ui::Clipboard? Ask oshima.
 // 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();
 }
 
 Clipboard::~Clipboard() {
 }
 
 void Clipboard::WriteObjects(const ObjectMap& objects) {
   // We need to overwrite previous data. Probably best to just delete
   // everything and start fresh.
   DeleteClipboardData();
   for (ObjectMap::const_iterator iter = objects.begin();
        iter != objects.end(); ++iter) {
     DispatchObject(static_cast<ObjectType>(iter->first), iter->second);
   }
 }
 
 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) {
     NOTREACHED();
     return;
   }
 
   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;
 }
 
 void Clipboard::ReadText(Buffer buffer, string16* result) const {
   *result = UTF8ToUTF16(GetClipboardData()->text());
 }
 
 void Clipboard::ReadAsciiText(Buffer buffer, std::string* result) const {
   *result = GetClipboardData()->text();
 }
@@ skipping 52 matching lines @@
 }
 
 void Clipboard::ReadFile(FilePath* file) const {
   NOTIMPLEMENTED();
 }
 
 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());
 }
 
 uint64 Clipboard::GetSequenceNumber(Buffer buffer) {
   NOTIMPLEMENTED();
   return 0;
 }
 
 void Clipboard::WriteText(const char* text_data, size_t text_len) {
   GetClipboardData()->set_text(std::string(text_data, text_len));
@@ skipping 16 matching lines @@
 }
 
 void Clipboard::WriteWebSmartPaste() {
   GetClipboardData()->set_web_smart_paste(true);
 }
 
 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::GetPlainTextFormatType() {
-  return std::string(kMimeTypeText);
+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::GetPlainTextWFormatType() {
+const Clipboard::FormatType& Clipboard::GetPlainTextFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeText));
+  return type;
+}
+
+// static
+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