Simultaneously store multiple formats on the linux clipboard.

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

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

1 files changed, 143 insertions, 57 deletions

diff --git a/base/clipboard_linux.cc b/base/clipboard_linux.cc
index af929c3f..1e4686a 100644
--- a/base/clipboard_linux.cc
+++ b/base/clipboard_linux.cc
@@ -6,97 +6,132 @@
 #include "base/string_util.h"
 
 #include <gtk/gtk.h>
-#include <string.h>
+#include <map>
+#include <set>
+#include <string>
+#include <utility>
 
 namespace {
 
 static const char* kMimeHtml = "text/html";
+static const char* kMimeText = "text/plain";
 
-void GetHtml(GtkClipboard* clipboard,
+// 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) {
-  if (selection_data->target != gdk_atom_intern(kMimeHtml, false))
-    return;
+  Clipboard::TargetMap* data_map =
+      reinterpret_cast<Clipboard::TargetMap*>(user_data);
 
-  gtk_selection_data_set(selection_data, gdk_atom_intern(kMimeHtml, false),
-                         8,
-                         static_cast<guchar*>(user_data),
-                         strlen(static_cast<char*>(user_data)));
-}
+  Clipboard::TargetMap::iterator iter =
+      data_map->find(std::string(gdk_atom_name(selection_data->target)));
 
-void ClearHtml(GtkClipboard* clipboard,
-               gpointer user_data) {
-  delete[] static_cast<char*>(user_data);
-}
+  if (iter == data_map->end())
+    return;
 
-void GetNoOp(GtkClipboard* clipboard,
-             GtkSelectionData* selection_data,
-             guint info,
-             gpointer user_data) {
+  gtk_selection_data_set(selection_data, selection_data->target, 8,
+                         iter->second.first,
+                         iter->second.second);
 }
 
-void ClearNoOp(GtkClipboard* clipboard,
+// GtkClipboardClearFunc callback.
+// GTK will call this when new data is set on the clipboard (whether or not we
+// retain ownership) or when gtk_clipboard_clear() is called. We don't do
+// anything because we don't want to clear the clipboard_data_ map if we call
+// set data several times in a row. Instead we manually clear the
+// clipboard_data_ map on Clear() and on Clipboard destruction.
+void ClearData(GtkClipboard* clipboard,
                gpointer user_data) {
 }
 
-}
+}  // namespace
 
 Clipboard::Clipboard() {
   clipboard_ = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
 }
 
 Clipboard::~Clipboard() {
-  // TODO(estade): enable this (must first use gtk_clipboard_set_can_store()?)
-  // gtk_clipboard_store(clipboard_);
+  // TODO(estade): do we want to save clipboard data after we exit?
+  // gtk_clipboard_set_can_store and gtk_clipboard_store work
+  // but have strangely awful performance.
+  Clear();
 }
 
 void Clipboard::Clear() {
-  // gtk_clipboard_clear() does not appear to be enough. We must first grab
-  // ownership of the clipboard by setting data.
-  GtkTargetEntry empty_target[] = {};
-  gtk_clipboard_set_with_data(clipboard_, empty_target, 0,
-                              GetNoOp, ClearNoOp, NULL);
   gtk_clipboard_clear(clipboard_);
+  FreeTargetMap();
 }
 
 void Clipboard::WriteText(const std::wstring& text) {
   std::string utf8_text = WideToUTF8(text);
+  size_t text_len = utf8_text.size() + 1;
+  uint8* text_data = new uint8[text_len];
+  memcpy(text_data, utf8_text.c_str(), text_len);
 
-  gtk_clipboard_set_text(clipboard_, utf8_text.c_str(), utf8_text.size());
+  uint8* old_data = InsertOrOverwrite(kMimeText, text_data, text_len);
+  InsertOrOverwrite("TEXT", text_data, text_len);
+  InsertOrOverwrite("STRING", text_data, text_len);
+  InsertOrOverwrite("UTF8_STRING", text_data, text_len);
+  InsertOrOverwrite("COMPOUND_TEXT", text_data, text_len);
+
+  if (old_data)
+    delete[] old_data;
+              
+  SetGtkClipboard();
 }
 
 void Clipboard::WriteHTML(const std::wstring& markup,
                           const std::string& src_url) {
   // TODO(estade): might not want to ignore src_url
   std::string html = WideToUTF8(markup);
-  char* html_data = new char[html.size() + 1];
-  strcpy(html_data, html.c_str());
+  size_t data_len = html.size() + 1;
+  uint8* html_data = new uint8[data_len];
+  memcpy(html_data, html.c_str(), data_len);
 
-  char target_format[strlen(kMimeHtml) + 1];
-  strcpy(target_format, kMimeHtml);
-  GtkTargetEntry target[] = { {target_format, 0} };
+  uint8* old_data = InsertOrOverwrite(kMimeHtml, html_data, data_len);
 
-  if (!gtk_clipboard_set_with_data(clipboard_, target, 1,
-                                   GetHtml, ClearHtml, html_data)) {
-    delete[] html_data;
-  }
+  if (old_data)
+    delete[] old_data;
+
+  SetGtkClipboard();
 }
 
+// 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 {
-  if (format == GetPlainTextFormatType()) {
-    return gtk_clipboard_wait_is_text_available(clipboard_);
+  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);
+
+  for (int i = 0; i < num; i++) {
+    if (targets[i] == format) {
+      retval = true;
+      break;
+    }
   }
 
-  return gtk_clipboard_wait_is_target_available(clipboard_, format);
+  gtk_selection_data_free(data);
+  g_free(targets);
+
+  return retval;
 }
 
 void Clipboard::ReadText(std::wstring* result) const {
-  if (!result) {
-    NOTREACHED();
-    return;
-  }
-
   result->clear();
   gchar* text = gtk_clipboard_wait_for_text(clipboard_);
 
@@ -109,11 +144,6 @@ void Clipboard::ReadText(std::wstring* result) const {
 }
 
 void Clipboard::ReadAsciiText(std::string* result) const {
-  if (!result) {
-    NOTREACHED();
-    return;
-  }
-
   result->clear();
   gchar* text = gtk_clipboard_wait_for_text(clipboard_);
 
@@ -124,12 +154,8 @@ void Clipboard::ReadAsciiText(std::string* result) const {
   g_free(text);
 }
 
+// TODO(estade): handle different charsets.
 void Clipboard::ReadHTML(std::wstring* markup, std::string* src_url) const {
-  if (!markup) {
-    NOTREACHED();
-    return;
-  }
-
   markup->clear();
 
   GtkSelectionData* data = gtk_clipboard_wait_for_contents(clipboard_,
@@ -138,8 +164,10 @@ void Clipboard::ReadHTML(std::wstring* markup, std::string* src_url) const {
   if (!data)
     return;
 
-  std::string html(reinterpret_cast<char*>(data->data));
-  markup->assign(UTF8ToWide(html));
+  UTF8ToWide(reinterpret_cast<char*>(data->data),
+             strlen(reinterpret_cast<char*>(data->data)),
+             markup);
+  gtk_selection_data_free(data);
 }
 
 // static
@@ -149,7 +177,6 @@ Clipboard::FormatType Clipboard::GetPlainTextFormatType() {
 
 // static
 Clipboard::FormatType Clipboard::GetPlainTextWFormatType() {
-  // all gtk clipboard strings are UTF8
   return GetPlainTextFormatType();
 }
 
@@ -158,3 +185,62 @@ Clipboard::FormatType Clipboard::GetHtmlFormatType() {
   return gdk_atom_intern(kMimeHtml, false);
 }
 
+// Take ownership of the GTK clipboard and inform it of the targets we support.
+void Clipboard::SetGtkClipboard() {
+  GtkTargetEntry targets[clipboard_data_.size()];
+
+  int i = 0;
+  for (Clipboard::TargetMap::iterator iter = clipboard_data_.begin();
+       iter != clipboard_data_.end(); iter++, i++) {
+    char* target_string = new char[iter->first.size() + 1];
+    strcpy(target_string, iter->first.c_str());
+    targets[i].target = target_string;
+    targets[i].flags = 0;
+    targets[i].info = i;
+  }
+
+  gtk_clipboard_set_with_data(clipboard_, targets,
+                              clipboard_data_.size(),
+                              GetData, ClearData,
+                              &clipboard_data_);
+
+  for (size_t i = 0; i < clipboard_data_.size(); i++)
+    delete[] targets[i].target;
+}
+
+// Free the pointers in the clipboard_data_ map and reset the map.
+void Clipboard::FreeTargetMap() {
+  std::set<uint8*> ptrs;
+
+  for (Clipboard::TargetMap::iterator iter = clipboard_data_.begin();
+       iter != clipboard_data_.end(); iter++)
+    ptrs.insert(iter->second.first);
+
+  for (std::set<uint8*>::iterator iter = ptrs.begin();
+       iter != ptrs.end(); iter++)
+    delete[] *iter;
+
+  clipboard_data_.clear();
+}
+
+// Insert the key/value pair in the clipboard_data structure. Overwrite
+// and any old value that might have had that key. If we overwrote something,
+// return the pointer to that something. Otherwise return null.
+uint8* Clipboard::InsertOrOverwrite(std::string key,
+                                    uint8* data, size_t data_len) {
+  std::pair<std::string, std::pair<uint8*, size_t> > mapping =
+      std::make_pair(key, std::make_pair(data, data_len));
+
+  Clipboard::TargetMap::iterator iter = clipboard_data_.find(key);
+  uint8* retval = NULL;
+
+  if (iter == clipboard_data_.end()) {
+    clipboard_data_.insert(mapping);
+  } else {
+    retval = iter->second.first;
+    iter->second = mapping.second;
+  }
+
+  return retval;
+}
+