Make Clipboard::FormatType an opaque handle type.

ui/base/clipboard/clipboard.h

 // 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.
 
 #ifndef UI_BASE_CLIPBOARD_CLIPBOARD_H_
 #define UI_BASE_CLIPBOARD_CLIPBOARD_H_
 #pragma once
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/process.h"
 #include "base/shared_memory.h"
 #include "base/string16.h"
 #include "ui/base/ui_export.h"
 
+#if defined(TOOLKIT_USES_GTK)
+#include <gdk/gdk.h>
+#endif
+
 namespace gfx {
 class Size;
 }
 
 class FilePath;
 class SkBitmap;
 
 #if defined(TOOLKIT_USES_GTK)
 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 {
+    // This only exists for the sake of IPC::Message serialization and
+    // deserialization.
+    FormatType();
+    ~FormatType();
+
+   private:
+    friend class Clipboard;
+
+#if defined(OS_WIN)
+    explicit FormatType(UINT native_format);
+    UINT data() const { return data_; }
+    UINT data_;
+#elif defined(USE_AURA)
+    explicit FormatType(const std::string& native_format);
+    const std::string& data() 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& data() const { return data_; }
+    GdkAtom data_;
+#elif defined(OS_MACOSX)
+    explicit FormatType(NSString* native_format);
+    NSString* data() const { return data_; }
+    // We don't use scoped_nsobject because this header gets included in a lot
+    // of places.
+    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
   // is defined by FormatType. A single ObjectType might be represented by
   // several system-specific FormatTypes. For example, on Linux the CBF_TEXT
   // ObjectType maps to "text/plain", "STRING", and several other formats. On
   // windows it maps to CF_UNICODETEXT.
   enum ObjectType {
     CBF_TEXT,
     CBF_HTML,
@@ skipping 80 matching lines @@
 #endif
 
   // Returns a sequence number which uniquely identifies clipboard state.
   // This can be used to version the data on the clipboard and determine
   // whether it has changed.
   uint64 GetSequenceNumber(Buffer buffer);
 
   // 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;
 
   // Reads UNICODE text from the clipboard, if available.
   void ReadText(Buffer buffer, string16* result) const;
 
   // Reads ASCII text from the clipboard, if available.
   void ReadAsciiText(Buffer buffer, std::string* result) const;
 
   // Reads HTML from the clipboard, if available. If the HTML fragment requires
@@ skipping 13 matching lines @@
   // Reads a bookmark from the clipboard, if available.
   void ReadBookmark(string16* title, std::string* url) const;
 
   // Reads a file or group of files from the clipboard, if available, into the
   // out parameter.
   void ReadFile(FilePath* file) const;
   void ReadFiles(std::vector<FilePath>* files) const;
 
   // 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;
+  void ReadData(const FormatType& 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();
+  // Converts a format name into a FormatType, registering it with the system as
+  // needed. Due to Windows/Linux limitiations, |format_string| must never be
+  // controlled by the user.
+  static FormatType RegisterFormatType(const std::string& format_string);

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

Nit: I would perhaps name this GetFormatType since it feels like registration is
a side effect of getting the format type rather than getting the format type a
side effect of registering.

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

Done.

+
+  // Helpers to serialize/deserialize FormatType to strings. These probably do
+  // NOT do what you want. They are intended to help serialize FormatTypes for
+  // IPC messages.
+  static std::string FormatTypeToString(const FormatType& type);
+  static FormatType StringToFormatType(const std::string& format_string);

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

Why not just call these methods SerializeFormatType and DeserializeFormatType. 
You could even put these methods on FormatType.

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

Done.

+
+  // 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
   // |objects|.  The pointer is deleted by DispatchObjects().
   //
   // On non-Windows platforms, |process| is ignored.
   static void ReplaceSharedMemHandle(ObjectMap* objects,
                                      base::SharedMemoryHandle bitmap_handle,
                                      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:
   FRIEND_TEST_ALL_PREFIXES(ClipboardTest, SharedBitmapTest);
   FRIEND_TEST_ALL_PREFIXES(ClipboardTest, EmptyHTMLTest);
 
   void DispatchObject(ObjectType type, const ObjectMapParams& params);
 
   void WriteText(const char* text_data, size_t text_len);
 
   void WriteHTML(const char* markup_data,
                  size_t markup_len,
                  const char* url_data,
                  size_t url_len);
 
   void WriteBookmark(const char* title_data,
                      size_t title_len,
                      const char* url_data,
                      size_t url_len);
 
   void WriteWebSmartPaste();
 
   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);
 
   // Safely write to system clipboard. Free |handle| on failure.
   void WriteToClipboard(unsigned int format, HANDLE handle);
 
   static void ParseBookmarkClipboardFormat(const string16& bookmark,
                                            string16* title,
                                            std::string* url);
@@ skipping 13 matching lines @@
 #elif defined(TOOLKIT_USES_GTK)
   // The public API is via WriteObjects() which dispatches to multiple
   // Write*() calls, but on GTK we must write all the clipboard types
   // in a single GTK call.  To support this we store the current set
   // of data we intend to put on the clipboard on clipboard_data_ as
   // WriteObjects is running, and then at the end call SetGtkClipboard
   // which replaces whatever is on the system clipboard with the
   // 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.
   void SetGtkClipboard();
   // Insert a mapping into clipboard_data_.
   void InsertMapping(const char* key, char* data, size_t data_len);
 
   // Find the gtk clipboard for the passed buffer enum.
   GtkClipboard* LookupBackingClipboard(Buffer clipboard) const;
 
   TargetMap* clipboard_data_;
   GtkClipboard* clipboard_;
   GtkClipboard* primary_selection_;
 #endif
 
   // MIME type constants.
   static const char kMimeTypeText[];
   static const char kMimeTypeHTML[];
   static const char kMimeTypePNG[];
 
   DISALLOW_COPY_AND_ASSIGN(Clipboard);
 };
 
 }  // namespace ui
 
 #endif  // UI_BASE_CLIPBOARD_CLIPBOARD_H_