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() {
+}
+
+std::string Clipboard::FormatType::Serialize() const {
+  return data_;
+}
+
+// static
+Clipboard::FormatType Clipboard::FormatType::Deserialize(
+    const std::string& serialization) {
+  return FormatType(serialization);
+}
+
+bool Clipboard::FormatType::Equals(const FormatType& other) const {
+  return data_ == other.data_;
+}
+
 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().Equals(format))
     return !data->text().empty();
-  else if (GetHtmlFormatType() == format)
+  else if (GetHtmlFormatType().Equals(format))
     return !data->markup_data().empty() || !data->url().empty();
-  else if (GetBitmapFormatType() == format)
+  else if (GetBitmapFormatType().Equals(format))
     return !!data->bitmap_data();
-  else if (GetWebKitSmartPasteFormatType() == format)
+  else if (GetWebKitSmartPasteFormatType().Equals(format))
     return data->web_smart_paste();
-  else if (data->custom_data_format() == format)
+  else if (data->custom_data_format() == format.ToString())
     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().ToString()));
   if (IsFormatAvailable(GetHtmlFormatType(), buffer))
-    types->push_back(UTF8ToUTF16(GetHtmlFormatType()));
+    types->push_back(UTF8ToUTF16(GetHtmlFormatType().ToString()));
   if (IsFormatAvailable(GetBitmapFormatType(), buffer))
-    types->push_back(UTF8ToUTF16(GetBitmapFormatType()));
-  if (IsFormatAvailable(GetWebKitSmartPasteFormatType(), buffer))
-    types->push_back(UTF8ToUTF16(GetWebKitSmartPasteFormatType()));
+    types->push_back(UTF8ToUTF16(GetBitmapFormatType().ToString()));
   *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.ToString())
     *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.ToString(), data_data, data_len);
 }
 
 // static
-Clipboard::FormatType Clipboard::GetPlainTextFormatType() {
-  return std::string(kMimeTypeText);
+Clipboard::FormatType Clipboard::GetFormatType(
+    const std::string& format_string) {
+  return FormatType::Deserialize(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