Refactor bookmark clipboard code to be cross platform.

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 <gtk/gtk.h>
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 
 #include "base/file_path.h"
 #include "base/gfx/size.h"
 #include "base/scoped_ptr.h"
 #include "base/linux_util.h"
 #include "base/string_util.h"
 
 namespace {
 
 const char kMimeBmp[] = "image/bmp";
 const char kMimeHtml[] = "text/html";
 const char kMimeText[] = "text/plain";
-const char kMimeWebkitSmartPaste[] = "chromium-internal/webkit-paste";
+const char kMimeWebkitSmartPaste[] = "chromium/x-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);
@@ skipping 151 matching lines @@
 
 void Clipboard::WriteHyperlink(const char* title_data, size_t title_len,
                                const char* url_data, size_t url_len) {
   NOTIMPLEMENTED();
 }
 
 void Clipboard::WriteFiles(const char* file_data, size_t file_len) {
   NOTIMPLEMENTED();
 }
 
+void Clipboard::WriteData(const char* format_name, size_t format_len,
+                          const char* data_data, size_t data_len) {
+  char* data = new char[data_len];
+  memcpy(data, data_data, data_len);
+  std::string format(format_name, format_len);
+  InsertMapping(format.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) const {
   bool format_is_plain_text = GetPlainTextFormatType() == format;
   if (format_is_plain_text) {
     // This tries a number of common text targets.
     if (gtk_clipboard_wait_is_text_available(clipboard_))
       return true;
   }
@@ skipping 33 matching lines @@
       break;
     }
   }
 
   g_free(targets);
   gtk_selection_data_free(data);
 
   return retval;
 }
 
+bool Clipboard::IsFormatAvailableByString(const std::string& format) const {
+  return IsFormatAvailable(format);
+}
+
 void Clipboard::ReadText(string16* result) const {
   result->clear();
   gchar* text = gtk_clipboard_wait_for_text(clipboard_);
 
   if (text == NULL)
     return;
 
   // TODO(estade): do we want to handle the possible error here?
   UTF8ToUTF16(text, strlen(text), result);
   g_free(text);
@@ skipping 18 matching lines @@
 // TODO(port): set *src_url.
 void Clipboard::ReadHTML(string16* markup, std::string* src_url) const {
   markup->clear();
 
   GtkSelectionData* data = gtk_clipboard_wait_for_contents(clipboard_,
       StringToGdkAtom(GetHtmlFormatType()));
 
   if (!data)
     return;
 
-  UTF8ToUTF16(reinterpret_cast<char*>(data->data),
-              strlen(reinterpret_cast<char*>(data->data)),
-              markup);
+  UTF8ToUTF16(reinterpret_cast<char*>(data->data), data->length, markup);
+  gtk_selection_data_free(data);
+}
+
+void Clipboard::ReadBookmark(string16* title, std::string* url) const {
+  // TODO(estade): implement this.
+}
+
+void Clipboard::ReadData(const std::string& format, std::string* result) {
+  GtkSelectionData* data =
+      gtk_clipboard_wait_for_contents(clipboard_, StringToGdkAtom(format));
+  if (!data)
+    return;
+  result->assign(reinterpret_cast<char*>(data->data), data->length);
   gtk_selection_data_free(data);
 }
 
 // static
 Clipboard::FormatType Clipboard::GetPlainTextFormatType() {
   return GdkAtomToString(GDK_TARGET_STRING);
 }
 
 // static
 Clipboard::FormatType Clipboard::GetPlainTextWFormatType() {
@@ skipping 22 matching lines @@
 
   if (iter != clipboard_data_->end()) {
     if (strcmp(kMimeBmp, key) == 0)
       g_object_unref(reinterpret_cast<GdkPixbuf*>(iter->second.first));
     else
       delete[] iter->second.first;
   }
 
   (*clipboard_data_)[key] = std::make_pair(data, data_len);
 }