Change the ChromiumPasteboard to have a notion of an alternate clipboard...

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>
@@ skipping 74 matching lines @@
 
 // Called on GdkPixbuf destruction; see WriteBitmap().
 void GdkPixbufFree(guchar* pixels, gpointer data) {
   free(pixels);
 }
 
 }  // namespace
 
 Clipboard::Clipboard() {
   clipboard_ = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
+  primary_selection_ = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
 }
 
 Clipboard::~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.
 }
 
 void Clipboard::WriteObjects(const ObjectMap& objects) {
   clipboard_data_ = new TargetMap();
@@ skipping 95 matching lines @@
                           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 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;
   if (format_is_plain_text) {
     // This tries a number of common text targets.
-    if (gtk_clipboard_wait_is_text_available(clipboard_))
+    if (gtk_clipboard_wait_is_text_available(clipboard))
       return true;
   }
 
   bool retval = false;
   GdkAtom* targets = NULL;
   GtkSelectionData* data =
-      gtk_clipboard_wait_for_contents(clipboard_,
+      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);
 
   // Some programs post data to the clipboard without any targets. If this is
   // the case we attempt to make sense of the contents as text. This is pretty
   // unfortunate since it means we have to actually copy the data to see if it
   // is available, but at least this path shouldn't be hit for conforming
   // programs.
   if (num <= 0) {
     if (format_is_plain_text) {
-      gchar* text = gtk_clipboard_wait_for_text(clipboard_);
+      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) {
       retval = true;
       break;
     }
   }
 
   g_free(targets);
   gtk_selection_data_free(data);
 
   return retval;
 }
 
-bool Clipboard::IsFormatAvailableByString(const std::string& format) const {
-  return IsFormatAvailable(format);
+bool Clipboard::IsFormatAvailableByString(const std::string& format,
+                                          Clipboard::Buffer buffer) const {
+  return IsFormatAvailable(format, buffer);
 }
 
-void Clipboard::ReadText(string16* result) const {
+void Clipboard::ReadText(Clipboard::Buffer buffer, string16* result) const {
+  GtkClipboard* clipboard = LookupBackingClipboard(buffer);
+  if (clipboard == NULL)
+    return;
+
   result->clear();
-  gchar* text = gtk_clipboard_wait_for_text(clipboard_);
+  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);
 }
 
-void Clipboard::ReadAsciiText(std::string* result) const {
+void Clipboard::ReadAsciiText(Clipboard::Buffer buffer,
+                              std::string* result) const {
+  GtkClipboard* clipboard = LookupBackingClipboard(buffer);
+  if (clipboard == NULL)
+    return;
+
   result->clear();
-  gchar* text = gtk_clipboard_wait_for_text(clipboard_);
+  gchar* text = gtk_clipboard_wait_for_text(clipboard);
 
   if (text == NULL)
     return;
 
   result->assign(text);
   g_free(text);
 }
 
 void Clipboard::ReadFile(FilePath* file) const {
   *file = FilePath();
 }
 
 // TODO(estade): handle different charsets.
 // TODO(port): set *src_url.
-void Clipboard::ReadHTML(string16* markup, std::string* src_url) const {
+void Clipboard::ReadHTML(Clipboard::Buffer buffer, string16* markup,
+                         std::string* src_url) const {
+  GtkClipboard* clipboard = LookupBackingClipboard(buffer);
+  if (clipboard == NULL)
+    return;
   markup->clear();
 
-  GtkSelectionData* data = gtk_clipboard_wait_for_contents(clipboard_,
+  GtkSelectionData* data = gtk_clipboard_wait_for_contents(clipboard,
       StringToGdkAtom(GetHtmlFormatType()));
 
   if (!data)
     return;
 
   UTF8ToUTF16(reinterpret_cast<char*>(data->data), data->length, markup);
   gtk_selection_data_free(data);
 }
 
 void Clipboard::ReadBookmark(string16* title, std::string* url) const {
@@ skipping 41 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);
 }
+
+GtkClipboard* Clipboard::LookupBackingClipboard(Buffer clipboard) const {
+  GtkClipboard* result;
+
+  switch (clipboard) {
+    case BUFFER_STANDARD:
+      result = clipboard_;
+      break;
+    case BUFFER_SELECTION:
+      result = primary_selection_;
+      break;
+    default:
+      NOTREACHED();
+      result = NULL;
+      break;
+  }
+  return result;
+}
+