Make Clipboard::FormatType an opaque handle type.

BUG=106523
TEST=ui_unittests --gtest_filter=ClipboardTest.* and manual testing

Review URL: http://codereview.chromium.org/8801038

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@113502 0039d316-1c4b-4281-b951-d872f2087c98

9 files changed, 430 insertions, 218 deletions

diff --git a/ui/base/clipboard/clipboard.cc b/ui/base/clipboard/clipboard.cc
index b98f373..69f54c6 100644
--- a/ui/base/clipboard/clipboard.cc
+++ b/ui/base/clipboard/clipboard.cc
@@ -142,8 +142,11 @@ void Clipboard::DispatchObject(ObjectType type, const ObjectMapParams& params) {
     }
 
     case CBF_DATA:
-      WriteData(&(params[0].front()), params[0].size(),
-                &(params[1].front()), params[1].size());
+      WriteData(
+          FormatType::Deserialize(
+              std::string(&(params[0].front()), params[0].size())),
+          &(params[1].front()),
+          params[1].size());
       break;
 
     default:
diff --git a/ui/base/clipboard/clipboard.h b/ui/base/clipboard/clipboard.h
index 39cb5d4..be8d460 100644
--- a/ui/base/clipboard/clipboard.h
+++ b/ui/base/clipboard/clipboard.h
@@ -16,6 +16,10 @@
 #include "base/string16.h"
 #include "ui/base/ui_export.h"
 
+#if defined(TOOLKIT_USES_GTK)
+#include <gdk/gdk.h>
+#endif
+
 namespace gfx {
 class Size;
 }
@@ -27,11 +31,54 @@ class SkBitmap;
 typedef struct _GtkClipboard GtkClipboard;
 #endif
 
+#ifdef __OBJC__
+@class NSString;
+#else
+class NSString;
+#endif
+
 namespace ui {
 
 class UI_EXPORT Clipboard {
  public:
-  typedef std::string FormatType;
+  // Platform neutral holder for native data representation of a clipboard type.
+  struct UI_EXPORT FormatType {
+    FormatType();
+    ~FormatType();
+
+    std::string Serialize() const;
+    static FormatType Deserialize(const std::string& serialization);
+
+   private:
+    friend class Clipboard;
+
+    bool Equals(const FormatType& other) const;
+
+#if defined(OS_WIN)
+    explicit FormatType(UINT native_format);
+    UINT ToUINT() const { return data_; }
+    UINT data_;
+#elif defined(USE_AURA)
+    explicit FormatType(const std::string& native_format);
+    const std::string& ToString() const { return data_; }
+    std::string data_;
+#elif defined(TOOLKIT_USES_GTK)
+    explicit FormatType(const std::string& native_format);
+    explicit FormatType(const GdkAtom& native_format);
+    const GdkAtom& ToGdkAtom() const { return data_; }
+    GdkAtom data_;
+#elif defined(OS_MACOSX)
+   public:
+    FormatType(const FormatType& other);
+    FormatType& operator=(const FormatType& other);
+   private:
+    explicit FormatType(NSString* native_format);
+    NSString* ToNSString() const { return data_; }
+    NSString* data_;
+#else
+#error No FormatType definition.
+#endif
+  };
 
   // ObjectType designates the type of data to be stored in the clipboard. This
   // designation is shared across all OSes. The system-specific designation
@@ -132,11 +179,6 @@ class UI_EXPORT Clipboard {
   // Tests whether the clipboard contains a certain format
   bool IsFormatAvailable(const FormatType& format, Buffer buffer) const;
 
-  // As above, but instead of interpreting |format| by some platform-specific
-  // definition, interpret it as a literal MIME type.
-  bool IsFormatAvailableByString(const std::string& format,
-                                 Buffer buffer) const;
-
   void ReadAvailableTypes(Buffer buffer, std::vector<string16>* types,
                           bool* contains_filenames) const;
 
@@ -170,23 +212,26 @@ class UI_EXPORT Clipboard {
 
   // Reads raw data from the clipboard with the given format type. Stores result
   // as a byte vector.
-  // TODO(dcheng): Due to platform limitations on Windows, we should make sure
-  // format is never controlled by the user.
-  void ReadData(const std::string& format, std::string* result) const;
-
-  // Get format Identifiers for various types.
-  static FormatType GetUrlFormatType();
-  static FormatType GetUrlWFormatType();
-  static FormatType GetMozUrlFormatType();
-  static FormatType GetPlainTextFormatType();
-  static FormatType GetPlainTextWFormatType();
-  static FormatType GetFilenameFormatType();
-  static FormatType GetFilenameWFormatType();
-  static FormatType GetWebKitSmartPasteFormatType();
+  void ReadData(const FormatType& format, std::string* result) const;
+
+  // Gets the FormatType corresponding to an arbitrary format string,
+  // registering it with the system if needed. Due to Windows/Linux
+  // limitiations, |format_string| must never be controlled by the user.
+  static FormatType GetFormatType(const std::string& format_string);
+
+  // Get format identifiers for various types.
+  static const FormatType& GetUrlFormatType();
+  static const FormatType& GetUrlWFormatType();
+  static const FormatType& GetMozUrlFormatType();
+  static const FormatType& GetPlainTextFormatType();
+  static const FormatType& GetPlainTextWFormatType();
+  static const FormatType& GetFilenameFormatType();
+  static const FormatType& GetFilenameWFormatType();
+  static const FormatType& GetWebKitSmartPasteFormatType();
   // Win: MS HTML Format, Other: Generic HTML format
-  static FormatType GetHtmlFormatType();
-  static FormatType GetBitmapFormatType();
-  static FormatType GetWebCustomDataFormatType();
+  static const FormatType& GetHtmlFormatType();
+  static const FormatType& GetBitmapFormatType();
+  static const FormatType& GetWebCustomDataFormatType();
 
   // Embeds a pointer to a SharedMemory object pointed to by |bitmap_handle|
   // belonging to |process| into a shared bitmap [CBF_SMBITMAP] slot in
@@ -198,10 +243,10 @@ class UI_EXPORT Clipboard {
                                      base::ProcessHandle process);
 #if defined(OS_WIN)
   // Firefox text/html
-  static FormatType GetTextHtmlFormatType();
-  static FormatType GetCFHDropFormatType();
-  static FormatType GetFileDescriptorFormatType();
-  static FormatType GetFileContentFormatZeroType();
+  static const FormatType& GetTextHtmlFormatType();
+  static const FormatType& GetCFHDropFormatType();
+  static const FormatType& GetFileDescriptorFormatType();
+  static const FormatType& GetFileContentFormatZeroType();
 #endif
 
  private:
@@ -226,9 +271,9 @@ class UI_EXPORT Clipboard {
 
   void WriteBitmap(const char* pixel_data, const char* size_data);
 
-  // |format_name| is an ASCII string and should be NULL-terminated.
-  void WriteData(const char* format_name, size_t format_len,
-                 const char* data_data, size_t data_len);
+  void WriteData(const FormatType& format,
+                 const char* data_data,
+                 size_t data_len);
 #if defined(OS_WIN)
   void WriteBitmapFromHandle(HBITMAP source_hbitmap,
                              const gfx::Size& size);
@@ -262,7 +307,7 @@ class UI_EXPORT Clipboard {
   // contents of clipboard_data_.
 
  public:
-  typedef std::map<FormatType, std::pair<char*, size_t> > TargetMap;
+  typedef std::map<std::string, std::pair<char*, size_t> > TargetMap;
 
  private:
   // Write changes to gtk clipboard.
diff --git a/ui/base/clipboard/clipboard_aurax11.cc b/ui/base/clipboard/clipboard_aurax11.cc
index 4e16aef..5782d85 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,30 @@ 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() {
+}
+
+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();
@@ -156,24 +181,19 @@ void Clipboard::WriteObjects(const ObjectMap& objects) {
 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) {
@@ -183,13 +203,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().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;
 }
 
@@ -262,10 +280,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.ToString())
     *result = std::string(data->custom_data_data(), data->custom_data_len());
 }
 
@@ -302,40 +320,51 @@ 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::GetFormatType(
+    const std::string& format_string) {
+  return FormatType::Deserialize(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
diff --git a/ui/base/clipboard/clipboard_gtk.cc b/ui/base/clipboard/clipboard_gtk.cc
index 9b64791..78fd155 100644
--- a/ui/base/clipboard/clipboard_gtk.cc
+++ b/ui/base/clipboard/clipboard_gtk.cc
@@ -12,6 +12,7 @@
 #include <string>
 #include <utility>
 
+#include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
@@ -180,11 +181,37 @@ void GdkPixbufFree(guchar* pixels, gpointer data) {
 
 }  // namespace
 
+Clipboard::FormatType::FormatType() {
+}
+
+Clipboard::FormatType::FormatType(const std::string& format_string)
+    : data_(StringToGdkAtom(format_string)) {
+}
+
+Clipboard::FormatType::FormatType(const GdkAtom& native_format)
+    : data_(native_format) {
+}
+
+Clipboard::FormatType::~FormatType() {
+}
+
+std::string Clipboard::FormatType::Serialize() const {
+  return GdkAtomToString(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() : clipboard_data_(NULL) {
-#if !defined(USE_AURA)
   clipboard_ = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
   primary_selection_ = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
-#endif
 }
 
 Clipboard::~Clipboard() {
@@ -302,16 +329,17 @@ void Clipboard::WriteBookmark(const char* title_data, size_t title_len,
   InsertMapping(kMimeTypeMozillaURL, data, data_len);
 }
 
-void Clipboard::WriteData(const char* format_name, size_t format_len,
-                          const char* data_data, size_t data_len) {
-  std::string format(format_name, format_len);
+void Clipboard::WriteData(const FormatType& format,
+                          const char* data_data,
+                          size_t data_len) {
   // We assume that certain mapping types are only written by trusted code.
   // Therefore we must upkeep their integrity.
-  if (format == kMimeTypeBitmap)
+  if (format.Equals(GetBitmapFormatType()))
     return;
   char* data = new char[data_len];
   memcpy(data, data_data, data_len);
-  InsertMapping(format.c_str(), data, data_len);
+  // TODO(dcheng): Maybe this map should use GdkAtoms...
+  InsertMapping(GdkAtomToString(format.ToGdkAtom()).c_str(), data, data_len);
 }
 
 // We do not use gtk_clipboard_wait_is_target_available because of
@@ -323,7 +351,7 @@ bool Clipboard::IsFormatAvailable(const Clipboard::FormatType& format,
   if (clipboard == NULL)
     return false;
 
-  bool format_is_plain_text = GetPlainTextFormatType() == format;
+  bool format_is_plain_text = GetPlainTextFormatType().Equals(format);
   if (format_is_plain_text) {
     // This tries a number of common text targets.
     if (gtk_clipboard_wait_is_text_available(clipboard))
@@ -357,10 +385,8 @@ bool Clipboard::IsFormatAvailable(const Clipboard::FormatType& format,
     }
   }
 
-  GdkAtom format_atom = StringToGdkAtom(format);
-
   for (int i = 0; i < num; i++) {
-    if (targets[i] == format_atom) {
+    if (targets[i] == format.ToGdkAtom()) {
       retval = true;
       break;
     }
@@ -372,11 +398,6 @@ bool Clipboard::IsFormatAvailable(const Clipboard::FormatType& format,
   return retval;
 }
 
-bool Clipboard::IsFormatAvailableByString(const std::string& format,
-                                          Clipboard::Buffer buffer) const {
-  return IsFormatAvailable(format, buffer);
-}
-
 void Clipboard::ReadAvailableTypes(Clipboard::Buffer buffer,
                                    std::vector<string16>* types,
                                    bool* contains_filenames) const {
@@ -399,7 +420,7 @@ void Clipboard::ReadAvailableTypes(Clipboard::Buffer buffer,
     return;
 
   GtkSelectionData* data = gtk_clipboard_wait_for_contents(
-      clipboard, StringToGdkAtom(GetWebCustomDataFormatType()));
+      clipboard, GetWebCustomDataFormatType().ToGdkAtom());
   if (!data)
     return;
   ReadCustomDataTypes(data->data, data->length, types);
@@ -458,7 +479,7 @@ void Clipboard::ReadHTML(Clipboard::Buffer buffer, string16* markup,
   if (clipboard == NULL)
     return;
   GtkSelectionData* data = gtk_clipboard_wait_for_contents(clipboard,
-      StringToGdkAtom(GetHtmlFormatType()));
+      GetHtmlFormatType().ToGdkAtom());
 
   if (!data)
     return;
@@ -510,7 +531,7 @@ void Clipboard::ReadCustomData(Buffer buffer,
     return;
 
   GtkSelectionData* data = gtk_clipboard_wait_for_contents(
-      clipboard, StringToGdkAtom(GetWebCustomDataFormatType()));
+      clipboard, GetWebCustomDataFormatType().ToGdkAtom());
   if (!data)
     return;
   ReadCustomDataForType(data->data, data->length, type, result);
@@ -522,9 +543,9 @@ void Clipboard::ReadBookmark(string16* title, std::string* url) const {
   NOTIMPLEMENTED();
 }
 
-void Clipboard::ReadData(const std::string& format, std::string* result) const {
+void Clipboard::ReadData(const FormatType& format, std::string* result) const {
   GtkSelectionData* data =
-      gtk_clipboard_wait_for_contents(clipboard_, StringToGdkAtom(format));
+      gtk_clipboard_wait_for_contents(clipboard_, format.ToGdkAtom());
   if (!data)
     return;
   result->assign(reinterpret_cast<char*>(data->data), data->length);
@@ -538,34 +559,46 @@ uint64 Clipboard::GetSequenceNumber(Buffer buffer) {
     return SelectionChangeObserver::GetInstance()->primary_sequence_number();
 }
 
+//static
+Clipboard::FormatType Clipboard::GetFormatType(
+    const std::string& format_string) {
+  return FormatType::Deserialize(format_string);
+}
+
 // static
-Clipboard::FormatType Clipboard::GetPlainTextFormatType() {
-  return GdkAtomToString(GDK_TARGET_STRING);
+const Clipboard::FormatType& Clipboard::GetPlainTextFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType, type, (GDK_TARGET_STRING));
+  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;
 }
 
 void Clipboard::InsertMapping(const char* key,
diff --git a/ui/base/clipboard/clipboard_mac.mm b/ui/base/clipboard/clipboard_mac.mm
index 153f5e9..c700139 100644
--- a/ui/base/clipboard/clipboard_mac.mm
+++ b/ui/base/clipboard/clipboard_mac.mm
@@ -6,11 +6,13 @@
 
 #import <Cocoa/Cocoa.h>
 
+#include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/memory/scoped_nsobject.h"
+#include "base/stl_util.h"
 #include "base/sys_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #import "third_party/mozilla/NSPasteboard+Utils.h"
@@ -45,6 +47,40 @@ NSPasteboard* GetPasteboard() {
 
 }  // namespace
 
+Clipboard::FormatType::FormatType() : data_(nil) {
+}
+
+Clipboard::FormatType::FormatType(NSString* native_format)
+    : data_([native_format retain]) {
+}
+
+Clipboard::FormatType::FormatType(const FormatType& other)
+    : data_([other.data_ retain]) {
+}
+
+Clipboard::FormatType& Clipboard::FormatType::operator=(
+    const FormatType& other) {
+  if (this != &other) {
+    [data_ release];
+    data_ = [other.data_ retain];
+  }
+  return *this;
+}
+
+Clipboard::FormatType::~FormatType() {
+  [data_ release];
+}
+
+std::string Clipboard::FormatType::Serialize() const {
+  return base::SysNSStringToUTF8(data_);
+}
+
+// static
+Clipboard::FormatType Clipboard::FormatType::Deserialize(
+    const std::string& serialization) {
+  return FormatType(base::SysUTF8ToNSString(serialization));
+}
+
 Clipboard::Clipboard() {
 }
 
@@ -157,23 +193,20 @@ void Clipboard::WriteBitmap(const char* pixel_data, const char* size_data) {
   }
 }
 
-void Clipboard::WriteData(const char* format_name, size_t format_len,
-                          const char* data_data, size_t data_len) {
+void Clipboard::WriteData(const FormatType& format,
+                          const char* data_data,
+                          size_t data_len) {
   NSPasteboard* pb = GetPasteboard();
-  scoped_nsobject<NSString> format(
-      [[NSString alloc] initWithBytes:format_name
-                               length:format_len
-                             encoding:NSUTF8StringEncoding]);
-  [pb addTypes:[NSArray arrayWithObject:format] owner:nil];
+  [pb addTypes:[NSArray arrayWithObject:format.ToNSString()] owner:nil];
   [pb setData:[NSData dataWithBytes:data_data length:data_len]
-      forType:format];
+      forType:format.ToNSString()];
 }
 
 // Write an extra flavor that signifies WebKit was the last to modify the
 // pasteboard. This flavor has no data.
 void Clipboard::WriteWebSmartPaste() {
   NSPasteboard* pb = GetPasteboard();
-  NSString* format = base::SysUTF8ToNSString(GetWebKitSmartPasteFormatType());
+  NSString* format = GetWebKitSmartPasteFormatType().ToNSString();
   [pb addTypes:[NSArray arrayWithObject:format] owner:nil];
   [pb setData:nil forType:format];
 }
@@ -185,42 +218,25 @@ uint64 Clipboard::GetSequenceNumber(Buffer buffer) {
   return [pb changeCount];
 }
 
-bool Clipboard::IsFormatAvailable(const Clipboard::FormatType& format,
+bool Clipboard::IsFormatAvailable(const FormatType& format,
                                   Buffer buffer) const {
   DCHECK_EQ(buffer, BUFFER_STANDARD);
-  NSString* format_ns = base::SysUTF8ToNSString(format);
 
   NSPasteboard* pb = GetPasteboard();
   NSArray* types = [pb types];
 
   // Safari only places RTF on the pasteboard, never HTML. We can convert RTF
   // to HTML, so the presence of either indicates success when looking for HTML.
-  if ([format_ns isEqualToString:NSHTMLPboardType]) {
+  if ([format.ToNSString() isEqualToString:NSHTMLPboardType]) {
     return [types containsObject:NSHTMLPboardType] ||
            [types containsObject:NSRTFPboardType];
   }
-  return [types containsObject:format_ns];
-}
-
-bool Clipboard::IsFormatAvailableByString(const std::string& format,
-                                          Buffer buffer) const {
-  DCHECK_EQ(buffer, BUFFER_STANDARD);
-  NSString* format_ns = base::SysUTF8ToNSString(format);
-
-  NSPasteboard* pb = GetPasteboard();
-  NSArray* types = [pb types];
-
-  return [types containsObject:format_ns];
+  return [types containsObject:format.ToNSString()];
 }
 
 void Clipboard::ReadAvailableTypes(Clipboard::Buffer buffer,
                                    std::vector<string16>* types,
                                    bool* contains_filenames) const {
-  if (!types || !contains_filenames) {
-    NOTREACHED();
-    return;
-  }
-
   types->clear();
   if (IsFormatAvailable(Clipboard::GetPlainTextFormatType(), buffer))
     types->push_back(UTF8ToUTF16(kMimeTypeText));
@@ -382,61 +398,74 @@ void Clipboard::ReadFiles(std::vector<FilePath>* files) const {
   }
 }
 
-void Clipboard::ReadData(const std::string& format, std::string* result) const {
+void Clipboard::ReadData(const FormatType& format, std::string* result) const {
   NSPasteboard* pb = GetPasteboard();
-  NSData* data = [pb dataForType:base::SysUTF8ToNSString(format)];
+  NSData* data = [pb dataForType:format.ToNSString()];
   if ([data length])
     result->assign(static_cast<const char*>([data bytes]), [data length]);
 }
 
 // static
-Clipboard::FormatType Clipboard::GetUrlFormatType() {
-  return base::SysNSStringToUTF8(NSURLPboardType);
+Clipboard::FormatType Clipboard::GetFormatType(
+    const std::string& format_string) {
+  return FormatType::Deserialize(format_string);
+}
+
+// static
+const Clipboard::FormatType& Clipboard::GetUrlFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (NSURLPboardType));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetUrlWFormatType() {
-  return base::SysNSStringToUTF8(NSURLPboardType);
+const Clipboard::FormatType& Clipboard::GetUrlWFormatType() {
+  return GetUrlFormatType();
 }
 
 // static
-Clipboard::FormatType Clipboard::GetPlainTextFormatType() {
-  return base::SysNSStringToUTF8(NSStringPboardType);
+const Clipboard::FormatType& Clipboard::GetPlainTextFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (NSStringPboardType));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetPlainTextWFormatType() {
-  return base::SysNSStringToUTF8(NSStringPboardType);
+const Clipboard::FormatType& Clipboard::GetPlainTextWFormatType() {
+  return GetPlainTextFormatType();
 }
 
 // static
-Clipboard::FormatType Clipboard::GetFilenameFormatType() {
-  return base::SysNSStringToUTF8(NSFilenamesPboardType);
+const Clipboard::FormatType& Clipboard::GetFilenameFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (NSFilenamesPboardType));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetFilenameWFormatType() {
-  return base::SysNSStringToUTF8(NSFilenamesPboardType);
+const Clipboard::FormatType& Clipboard::GetFilenameWFormatType() {
+  return GetFilenameFormatType();
 }
 
 // static
-Clipboard::FormatType Clipboard::GetHtmlFormatType() {
-  return base::SysNSStringToUTF8(NSHTMLPboardType);
+const Clipboard::FormatType& Clipboard::GetHtmlFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (NSHTMLPboardType));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetBitmapFormatType() {
-  return base::SysNSStringToUTF8(NSTIFFPboardType);
+const Clipboard::FormatType& Clipboard::GetBitmapFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (NSTIFFPboardType));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetWebKitSmartPasteFormatType() {
-  return base::SysNSStringToUTF8(kWebSmartPastePboardType);
+const Clipboard::FormatType& Clipboard::GetWebKitSmartPasteFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (kWebSmartPastePboardType));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetWebCustomDataFormatType() {
-  return base::SysNSStringToUTF8(kWebCustomDataType);
+const Clipboard::FormatType& Clipboard::GetWebCustomDataFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (kWebCustomDataType));
+  return type;
 }
 
 }  // namespace ui
diff --git a/ui/base/clipboard/clipboard_unittest.cc b/ui/base/clipboard/clipboard_unittest.cc
index ecf63f9..90c43c4 100644
--- a/ui/base/clipboard/clipboard_unittest.cc
+++ b/ui/base/clipboard/clipboard_unittest.cc
@@ -379,7 +379,8 @@ TEST_F(ClipboardTest, MultipleBitmapReadWriteTest) {
 
 TEST_F(ClipboardTest, DataTest) {
   Clipboard clipboard;
-  const char* kFormat = "chromium/x-test-format";
+  const ui::Clipboard::FormatType kFormat =
+      ui::Clipboard::GetFormatType("chromium/x-test-format");
   std::string payload("test string");
   Pickle write_pickle;
   write_pickle.WriteString(payload);
@@ -389,7 +390,7 @@ TEST_F(ClipboardTest, DataTest) {
     clipboard_writer.WritePickledData(write_pickle, kFormat);
   }
 
-  ASSERT_TRUE(clipboard.IsFormatAvailableByString(
+  ASSERT_TRUE(clipboard.IsFormatAvailable(
       kFormat, Clipboard::BUFFER_STANDARD));
   std::string output;
   clipboard.ReadData(kFormat, &output);
@@ -404,12 +405,14 @@ TEST_F(ClipboardTest, DataTest) {
 
 TEST_F(ClipboardTest, MultipleDataTest) {
   Clipboard clipboard;
-  const char* kFormat1 = "chromium/x-test-format1";
+  const ui::Clipboard::FormatType kFormat1 =
+      ui::Clipboard::GetFormatType("chromium/x-test-format1");
   std::string payload1("test string1");
   Pickle write_pickle1;
   write_pickle1.WriteString(payload1);
 
-  const char* kFormat2 = "chromium/x-test-format2";
+  const ui::Clipboard::FormatType kFormat2 =
+      ui::Clipboard::GetFormatType("chromium/x-test-format2");
   std::string payload2("test string2");
   Pickle write_pickle2;
   write_pickle2.WriteString(payload2);
@@ -421,7 +424,7 @@ TEST_F(ClipboardTest, MultipleDataTest) {
     clipboard_writer.WritePickledData(write_pickle2, kFormat2);
   }
 
-  ASSERT_TRUE(clipboard.IsFormatAvailableByString(
+  ASSERT_TRUE(clipboard.IsFormatAvailable(
       kFormat2, Clipboard::BUFFER_STANDARD));
 
   // Check string 2.
@@ -442,7 +445,7 @@ TEST_F(ClipboardTest, MultipleDataTest) {
     clipboard_writer.WritePickledData(write_pickle1, kFormat1);
   }
 
-  ASSERT_TRUE(clipboard.IsFormatAvailableByString(
+  ASSERT_TRUE(clipboard.IsFormatAvailable(
       kFormat1, Clipboard::BUFFER_STANDARD));
 
   // Check string 1.
diff --git a/ui/base/clipboard/clipboard_win.cc b/ui/base/clipboard/clipboard_win.cc
index 776ff4d..79a0faa 100644
--- a/ui/base/clipboard/clipboard_win.cc
+++ b/ui/base/clipboard/clipboard_win.cc
@@ -10,13 +10,14 @@
 #include <shlobj.h>
 #include <shellapi.h>
 
+#include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/shared_memory.h"
 #include "base/stl_util.h"
-#include "base/string_util.h"
 #include "base/string_number_conversions.h"
+#include "base/string_util.h"
 #include "base/utf_offset_string_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/scoped_gdi_object.h"
@@ -159,6 +160,30 @@ void MakeBitmapOpaque(const SkBitmap& bitmap) {
 
 }  // namespace
 
+Clipboard::FormatType::FormatType() {
+}
+
+Clipboard::FormatType::FormatType(UINT native_format) : data_(native_format) {
+}
+
+Clipboard::FormatType::~FormatType() {
+}
+
+std::string Clipboard::FormatType::Serialize() const {
+  return base::IntToString(data_);
+}
+
+// static
+Clipboard::FormatType Clipboard::FormatType::Deserialize(
+    const std::string& serialization) {
+  int clipboard_format = -1;
+  if (!base::StringToInt(serialization, &clipboard_format)) {
+    NOTREACHED();
+    return FormatType();
+  }
+  return FormatType(clipboard_format);
+}
+
 Clipboard::Clipboard() : create_window_(false) {
   if (MessageLoop::current()->type() == MessageLoop::TYPE_UI) {
     // Make a dummy HWND to be the clipboard's owner.
@@ -314,12 +339,9 @@ void Clipboard::WriteBitmapFromHandle(HBITMAP source_hbitmap,
   WriteToClipboard(CF_BITMAP, hbitmap);
 }
 
-void Clipboard::WriteData(const char* format_name, size_t format_len,
-                          const char* data_data, size_t data_len) {
-  std::string format(format_name, format_len);
-  CLIPFORMAT clip_format =
-      ::RegisterClipboardFormat(ASCIIToWide(format).c_str());
-
+void Clipboard::WriteData(const FormatType& format,
+                          const char* data_data,
+                          size_t data_len) {
   HGLOBAL hdata = ::GlobalAlloc(GMEM_MOVEABLE, data_len);
   if (!hdata)
     return;
@@ -327,7 +349,7 @@ void Clipboard::WriteData(const char* format_name, size_t format_len,
   char* data = static_cast<char*>(::GlobalLock(hdata));
   memcpy(data, data_data, data_len);
   ::GlobalUnlock(data);
-  WriteToClipboard(clip_format, hdata);
+  WriteToClipboard(format.ToUINT(), hdata);
 }
 
 void Clipboard::WriteToClipboard(unsigned int format, HANDLE handle) {
@@ -346,18 +368,7 @@ uint64 Clipboard::GetSequenceNumber(Buffer buffer) {
 bool Clipboard::IsFormatAvailable(const Clipboard::FormatType& format,
                                   Clipboard::Buffer buffer) const {
   DCHECK_EQ(buffer, BUFFER_STANDARD);
-  int f;
-  if (!base::StringToInt(format, &f))
-    return false;
-  return ::IsClipboardFormatAvailable(f) != FALSE;
-}
-
-bool Clipboard::IsFormatAvailableByString(
-    const std::string& ascii_format, Clipboard::Buffer buffer) const {
-  DCHECK_EQ(buffer, BUFFER_STANDARD);
-  std::wstring wide_format = ASCIIToWide(ascii_format);
-  CLIPFORMAT format = ::RegisterClipboardFormat(wide_format.c_str());
-  return ::IsClipboardFormatAvailable(format) != FALSE;
+  return ::IsClipboardFormatAvailable(format.ToUINT()) != FALSE;
 }
 
 void Clipboard::ReadAvailableTypes(Clipboard::Buffer buffer,
@@ -646,20 +657,17 @@ void Clipboard::ReadFiles(std::vector<FilePath>* files) const {
   }
 }
 
-void Clipboard::ReadData(const std::string& format, std::string* result) const {
+void Clipboard::ReadData(const FormatType& format, std::string* result) const {
   if (!result) {
     NOTREACHED();
     return;
   }
 
-  CLIPFORMAT clip_format =
-      ::RegisterClipboardFormat(ASCIIToWide(format).c_str());
-
   ScopedClipboard clipboard;
   if (!clipboard.Acquire(GetClipboardWindow()))
     return;
 
-  HANDLE data = ::GetClipboardData(clip_format);
+  HANDLE data = ::GetClipboardData(format.ToUINT());
   if (!data)
     return;
 
@@ -686,86 +694,145 @@ void Clipboard::ParseBookmarkClipboardFormat(const string16& bookmark,
 }
 
 // static
-Clipboard::FormatType Clipboard::GetUrlFormatType() {
-  return base::IntToString(ClipboardUtil::GetUrlFormat()->cfFormat);
+Clipboard::FormatType Clipboard::GetFormatType(
+    const std::string& format_string) {
+  return FormatType(
+      ::RegisterClipboardFormat(ASCIIToWide(format_string).c_str()));
+}
+
+// static
+// TODO(dcheng): Just substitue the appropriate constants here.
+const Clipboard::FormatType& Clipboard::GetUrlFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetUrlFormat()->cfFormat));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetUrlWFormatType() {
-  return base::IntToString(ClipboardUtil::GetUrlWFormat()->cfFormat);
+const Clipboard::FormatType& Clipboard::GetUrlWFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetUrlWFormat()->cfFormat));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetMozUrlFormatType() {
-  return base::IntToString(ClipboardUtil::GetMozUrlFormat()->cfFormat);
+const Clipboard::FormatType& Clipboard::GetMozUrlFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetMozUrlFormat()->cfFormat));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetPlainTextFormatType() {
-  return base::IntToString(ClipboardUtil::GetPlainTextFormat()->cfFormat);
+const Clipboard::FormatType& Clipboard::GetPlainTextFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetPlainTextFormat()->cfFormat));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetPlainTextWFormatType() {
-  return base::IntToString(ClipboardUtil::GetPlainTextWFormat()->cfFormat);
+const Clipboard::FormatType& Clipboard::GetPlainTextWFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetPlainTextWFormat()->cfFormat));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetFilenameFormatType() {
-  return base::IntToString(ClipboardUtil::GetFilenameFormat()->cfFormat);
+const Clipboard::FormatType& Clipboard::GetFilenameFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetFilenameFormat()->cfFormat));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetFilenameWFormatType() {
-  return base::IntToString(ClipboardUtil::GetFilenameWFormat()->cfFormat);
+const Clipboard::FormatType& Clipboard::GetFilenameWFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetFilenameWFormat()->cfFormat));
+  return type;
 }
 
 // MS HTML Format
 // static
-Clipboard::FormatType Clipboard::GetHtmlFormatType() {
-  return base::IntToString(ClipboardUtil::GetHtmlFormat()->cfFormat);
+const Clipboard::FormatType& Clipboard::GetHtmlFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetHtmlFormat()->cfFormat));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetBitmapFormatType() {
-  return base::IntToString(CF_BITMAP);
+const Clipboard::FormatType& Clipboard::GetBitmapFormatType() {
+  CR_DEFINE_STATIC_LOCAL(FormatType, type, (CF_BITMAP));
+  return type;
 }
 
 // Firefox text/html
 // static
-Clipboard::FormatType Clipboard::GetTextHtmlFormatType() {
-  return base::IntToString(ClipboardUtil::GetTextHtmlFormat()->cfFormat);
+const Clipboard::FormatType& Clipboard::GetTextHtmlFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetTextHtmlFormat()->cfFormat));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetCFHDropFormatType() {
-  return base::IntToString(ClipboardUtil::GetCFHDropFormat()->cfFormat);
+const Clipboard::FormatType& Clipboard::GetCFHDropFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetCFHDropFormat()->cfFormat));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetFileDescriptorFormatType() {
-  return base::IntToString(ClipboardUtil::GetFileDescriptorFormat()->cfFormat);
+const Clipboard::FormatType& Clipboard::GetFileDescriptorFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetFileDescriptorFormat()->cfFormat));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetFileContentFormatZeroType() {
-  return base::IntToString(ClipboardUtil::GetFileContentFormatZero()->cfFormat);
+const Clipboard::FormatType& Clipboard::GetFileContentFormatZeroType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetFileContentFormatZero()->cfFormat));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetWebKitSmartPasteFormatType() {
-  return base::IntToString(
-      ClipboardUtil::GetWebKitSmartPasteFormat()->cfFormat);
+const Clipboard::FormatType& Clipboard::GetWebKitSmartPasteFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetWebKitSmartPasteFormat()->cfFormat));
+  return type;
 }
 
 // static
-Clipboard::FormatType Clipboard::GetWebCustomDataFormatType() {
-  // TODO(dcheng): Clean up the duplicated constant.
-  // Clipboard::WritePickledData() takes a FormatType, but all the callers
-  // assume that it's a raw string. As a result, we return the format name here
-  // rather than returning a string-ified version of the registered clipboard
-  // format ID.
-  return "Chromium Web Custom MIME Data Format";
+const Clipboard::FormatType& Clipboard::GetWebCustomDataFormatType() {
+  CR_DEFINE_STATIC_LOCAL(
+      FormatType,
+      type,
+      (ClipboardUtil::GetWebCustomDataFormat()->cfFormat));
+  return type;
 }
 
 // static
diff --git a/ui/base/clipboard/scoped_clipboard_writer.cc b/ui/base/clipboard/scoped_clipboard_writer.cc
index 9014f3a..48565ab 100644
--- a/ui/base/clipboard/scoped_clipboard_writer.cc
+++ b/ui/base/clipboard/scoped_clipboard_writer.cc
@@ -104,9 +104,11 @@ void ScopedClipboardWriter::WriteBitmapFromPixels(const void* pixels,
   objects_[Clipboard::CBF_BITMAP] = parameters;
 }
 
-void ScopedClipboardWriter::WritePickledData(const Pickle& pickle,
-                                             Clipboard::FormatType format) {
-  Clipboard::ObjectMapParam format_parameter(format.begin(), format.end());
+void ScopedClipboardWriter::WritePickledData(
+    const Pickle& pickle, const Clipboard::FormatType& format) {
+  std::string format_string = format.Serialize();
+  Clipboard::ObjectMapParam format_parameter(format_string.begin(),
+                                             format_string.end());
   Clipboard::ObjectMapParam data_parameter;
 
   data_parameter.resize(pickle.size());
diff --git a/ui/base/clipboard/scoped_clipboard_writer.h b/ui/base/clipboard/scoped_clipboard_writer.h
index 3e224a2..08aaa3a 100644
--- a/ui/base/clipboard/scoped_clipboard_writer.h
+++ b/ui/base/clipboard/scoped_clipboard_writer.h
@@ -60,7 +60,8 @@ class UI_EXPORT ScopedClipboardWriter {
   void WriteBitmapFromPixels(const void* pixels, const gfx::Size& size);
 
   // Adds arbitrary data to clipboard.
-  void WritePickledData(const Pickle& pickle, Clipboard::FormatType format);
+  void WritePickledData(const Pickle& pickle,
+                        const Clipboard::FormatType& format);
 
  protected:
   // Converts |text| to UTF-8 and adds it to the clipboard.  If it's a URL, we