Make Clipboard::FormatType an opaque handle type.

ui/base/clipboard/clipboard_gtk.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 <gtk/gtk.h>
 #include <X11/extensions/Xfixes.h>
 #include <X11/Xatom.h>
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 
+#include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/utf_string_conversions.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/clipboard/custom_data_helper.h"
 #include "ui/base/gtk/gtk_signal.h"
 #include "ui/base/x/x11_util.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/gtk_util.h"
@@ skipping 148 matching lines @@
   delete map;
 }
 
 // Called on GdkPixbuf destruction; see WriteBitmap().
 void GdkPixbufFree(guchar* pixels, gpointer data) {
   free(pixels);
 }
 
 }  // 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() {
   gtk_clipboard_store(clipboard_);
 }
 
 void Clipboard::WriteObjects(const ObjectMap& objects) {
   clipboard_data_ = new TargetMap();
 
   for (ObjectMap::const_iterator iter = objects.begin();
@@ skipping 97 matching lines @@
   string16 url = UTF8ToUTF16(std::string(url_data, url_len) + "\n");
   string16 title = UTF8ToUTF16(std::string(title_data, title_len));
   int data_len = 2 * (title.length() + url.length());
 
   char* data = new char[data_len];
   memcpy(data, url.data(), 2 * url.length());
   memcpy(data + 2 * url.length(), title.data(), 2 * title.length());
   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
 // a bug with the gtk clipboard. It caches the available targets
 // and does not always refresh the cache when it is appropriate.
 bool Clipboard::IsFormatAvailable(const Clipboard::FormatType& format,
                                   Clipboard::Buffer buffer) const {
   GtkClipboard* clipboard = LookupBackingClipboard(buffer);
   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))
       return true;
   }
 
   bool retval = false;
   GdkAtom* targets = NULL;
   GtkSelectionData* data =
       gtk_clipboard_wait_for_contents(clipboard,
@@ skipping 13 matching lines @@
   if (num <= 0) {
     if (format_is_plain_text) {
       gchar* text = gtk_clipboard_wait_for_text(clipboard);
       if (text) {
         g_free(text);
         retval = true;
       }
     }
   }
 
-  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;
     }
   }
 
   g_free(targets);
   gtk_selection_data_free(data);
 
   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 {
   if (!types || !contains_filenames) {
     NOTREACHED();
     return;
   }
 
   types->clear();
   if (IsFormatAvailable(GetPlainTextFormatType(), buffer))
     types->push_back(UTF8ToUTF16(kMimeTypeText));
   if (IsFormatAvailable(GetHtmlFormatType(), buffer))
     types->push_back(UTF8ToUTF16(kMimeTypeHTML));
   if (IsFormatAvailable(GetBitmapFormatType(), buffer))
     types->push_back(UTF8ToUTF16(kMimeTypePNG));
   *contains_filenames = false;
 
   GtkClipboard* clipboard = LookupBackingClipboard(buffer);
   if (!clipboard)
     return;
 
   GtkSelectionData* data = gtk_clipboard_wait_for_contents(
-      clipboard, StringToGdkAtom(GetWebCustomDataFormatType()));
+      clipboard, GetWebCustomDataFormatType().ToGdkAtom());
   if (!data)
     return;
   ReadCustomDataTypes(data->data, data->length, types);
   gtk_selection_data_free(data);
 }
 
 
 void Clipboard::ReadText(Clipboard::Buffer buffer, string16* result) const {
   GtkClipboard* clipboard = LookupBackingClipboard(buffer);
   if (clipboard == NULL)
@@ skipping 38 matching lines @@
   markup->clear();
   if (src_url)
     src_url->clear();
   *fragment_start = 0;
   *fragment_end = 0;
 
   GtkClipboard* clipboard = LookupBackingClipboard(buffer);
   if (clipboard == NULL)
     return;
   GtkSelectionData* data = gtk_clipboard_wait_for_contents(clipboard,
-      StringToGdkAtom(GetHtmlFormatType()));
+      GetHtmlFormatType().ToGdkAtom());
 
   if (!data)
     return;
 
   // If the data starts with 0xFEFF, i.e., Byte Order Mark, assume it is
   // UTF-16, otherwise assume UTF-8.
   if (data->length >= 2 &&
       reinterpret_cast<uint16_t*>(data->data)[0] == 0xFEFF) {
     markup->assign(reinterpret_cast<uint16_t*>(data->data) + 1,
                    (data->length / 2) - 1);
@@ skipping 31 matching lines @@
 }
 
 void Clipboard::ReadCustomData(Buffer buffer,
                                const string16& type,
                                string16* result) const {
   GtkClipboard* clipboard = LookupBackingClipboard(buffer);
   if (!clipboard)
     return;
 
   GtkSelectionData* data = gtk_clipboard_wait_for_contents(
-      clipboard, StringToGdkAtom(GetWebCustomDataFormatType()));
+      clipboard, GetWebCustomDataFormatType().ToGdkAtom());
   if (!data)
     return;
   ReadCustomDataForType(data->data, data->length, type, result);
   gtk_selection_data_free(data);
 }
 
 void Clipboard::ReadBookmark(string16* title, std::string* url) const {
   // TODO(estade): implement this.
   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);
   gtk_selection_data_free(data);
 }
 
 uint64 Clipboard::GetSequenceNumber(Buffer buffer) {
   if (buffer == BUFFER_STANDARD)
     return SelectionChangeObserver::GetInstance()->clipboard_sequence_number();
   else
     return SelectionChangeObserver::GetInstance()->primary_sequence_number();
 }
 
-// static
-Clipboard::FormatType Clipboard::GetPlainTextFormatType() {
-  return GdkAtomToString(GDK_TARGET_STRING);
+//static
+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, (GDK_TARGET_STRING));
+  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;
 }
 
 void Clipboard::InsertMapping(const char* key,
                               char* data,
                               size_t data_len) {
   DCHECK(clipboard_data_->find(key) == clipboard_data_->end());
   (*clipboard_data_)[key] = std::make_pair(data, data_len);
 }
 
 GtkClipboard* Clipboard::LookupBackingClipboard(Buffer clipboard) const {
   switch (clipboard) {
     case BUFFER_STANDARD:
       return clipboard_;
     case BUFFER_SELECTION:
       return primary_selection_;
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 }  // namespace ui