This changes the base clipboard class.

base/clipboard_linux.cc

 // Copyright (c) 2006-2008 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 "base/clipboard.h"
 #include "base/string_util.h"
 
 #include <gtk/gtk.h>
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 
 namespace {
 
 static const char* kMimeHtml = "text/html";
 static const char* kMimeText = "text/plain";
 static const char* kMimeWebkitSmartPaste = "chrome-internal/webkit-paste";
 
+std::string GdkAtomToString(const GdkAtom& atom) {
+  gchar* name = gdk_atom_name(atom);
+  std::string rv(name);
+  g_free(name);
+  return rv;
+}
+
+GdkAtom StringToGdkAtom(const std::string& str) {
+  return gdk_atom_intern(str.c_str(), false);
+}
+
 // GtkClipboardGetFunc callback.
 // GTK will call this when an application wants data we copied to the clipboard.
 void GetData(GtkClipboard* clipboard,
              GtkSelectionData* selection_data,
              guint info,
              gpointer user_data) {
   Clipboard::TargetMap* data_map =
       reinterpret_cast<Clipboard::TargetMap*>(user_data);
 
   Clipboard::TargetMap::iterator iter =
-      data_map->find(std::string(gdk_atom_name(selection_data->target)));
+      data_map->find(GdkAtomToString(selection_data->target));
 
   if (iter == data_map->end())
     return;
 
   gtk_selection_data_set(selection_data, selection_data->target, 8,
                          reinterpret_cast<guchar*>(iter->second.first),
                          iter->second.second);
 }
 
 // GtkClipboardClearFunc callback.
@@ skipping 126 matching lines @@
   NOTIMPLEMENTED();
 }
 
 // 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.
 // TODO(estade): When gnome bug 557315 is resolved, change this function
 // to use gtk_clipboard_wait_is_target_available. Also, catch requests
 // for plain text and change them to gtk_clipboard_wait_is_text_available
 // (which checks for several standard text targets).
-bool Clipboard::IsFormatAvailable(Clipboard::FormatType format) const {
+bool Clipboard::IsFormatAvailable(const Clipboard::FormatType& format) const {
   bool retval = false;
   GdkAtom* targets = NULL;
   GtkSelectionData* data =
       gtk_clipboard_wait_for_contents(clipboard_,
                                       gdk_atom_intern("TARGETS", false));
 
   if (!data)
     return false;
 
   int num = 0;
   gtk_selection_data_get_targets(data, &targets, &num);
 
+  GdkAtom format_atom = StringToGdkAtom(format);
+
   for (int i = 0; i < num; i++) {
-    if (targets[i] == format) {
+    if (targets[i] == format_atom) {
       retval = true;
       break;
     }
   }
 
   gtk_selection_data_free(data);
   g_free(targets);
 
   return retval;
 }
@@ skipping 23 matching lines @@
 
 void Clipboard::ReadFile(FilePath* file) const {
   *file = FilePath();
 }
 
 // TODO(estade): handle different charsets.
 void Clipboard::ReadHTML(string16* markup, std::string* src_url) const {
   markup->clear();
 
   GtkSelectionData* data = gtk_clipboard_wait_for_contents(clipboard_,
-                                                           GetHtmlFormatType());
+      StringToGdkAtom(GetHtmlFormatType()));
 
   if (!data)
     return;
 
   UTF8ToUTF16(reinterpret_cast<char*>(data->data),
               strlen(reinterpret_cast<char*>(data->data)),
               markup);
   gtk_selection_data_free(data);
 }
 
 // static
 Clipboard::FormatType Clipboard::GetPlainTextFormatType() {
-  return GDK_TARGET_STRING;
+  return GdkAtomToString(GDK_TARGET_STRING);
 }
 
 // static
 Clipboard::FormatType Clipboard::GetPlainTextWFormatType() {
   return GetPlainTextFormatType();
 }
 
 // static
 Clipboard::FormatType Clipboard::GetHtmlFormatType() {
-  return gdk_atom_intern(kMimeHtml, false);
+  return std::string(kMimeHtml);
 }
 
 // static
 Clipboard::FormatType Clipboard::GetWebKitSmartPasteFormatType() {
-  return gdk_atom_intern(kMimeWebkitSmartPaste, false);
+  return std::string(kMimeWebkitSmartPaste);
 }
 
 // Insert the key/value pair in the clipboard_data structure. If
 // the mapping already exists, it frees the associated data. Don't worry
 // about double freeing because if the same key is inserted into the
 // map twice, it must have come from different Write* functions and the
 // data pointer cannot be the same.
 void Clipboard::InsertMapping(const char* key,
                               char* data,
                               size_t data_len) {
   TargetMap::iterator iter = clipboard_data_->find(key);
 
   if (iter != clipboard_data_->end())
     delete[] iter->second.first;
 
   (*clipboard_data_)[key] = std::make_pair(data, data_len);
 }