GTK: Store the contents of the clipboard to the clipboard manager on exit.

app/clipboard/clipboard_linux.cc

 // Copyright (c) 2010 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 "app/clipboard/clipboard.h"
 
 #include <gtk/gtk.h>
 #include <map>
 #include <set>
 #include <string>
@@ skipping 83 matching lines @@
 }
 
 }  // namespace
 
 Clipboard::Clipboard() : clipboard_data_(NULL) {
   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.
+  gtk_clipboard_store(clipboard_);

[Evan Stade, 2010/11/30 21:37:11]

shouldn't we only call this if we own the clipboard?

[Elliot Glaysher, 2010/11/30 21:50:29]

I'm not sure I understand. What does that mean and how would I check for it?

[Elliot Glaysher, 2010/11/30 22:03:36]

OK, I don't think so. I did the following test:

- Copy text in chrome
- Paste text in gedit.
- Copy text from terminal.
- Close chrome
- Paste text in gedit. It was the terminal text.

I think gtk_clipboard_store() is checking to make sure we don't clobber when we
don't own the clipboard.

[Evan Stade, 2010/11/30 22:05:00]

actually, this might not be the right place to call this as the clipboard
ownership timeline doesn't seem to be tied to the Clipboard object's lifetime.

Is it necessary at all to call this? The docs seem to state it will
automatically be called when the app exits.

 }
 
 void Clipboard::WriteObjects(const ObjectMap& objects) {
   clipboard_data_ = new TargetMap();
 
   for (ObjectMap::const_iterator iter = objects.begin();
        iter != objects.end(); ++iter) {
     DispatchObject(static_cast<ObjectType>(iter->first), iter->second);
   }
 
@@ skipping 14 matching lines @@
       new GtkTargetEntry[clipboard_data_->size()]);
 
   int i = 0;
   for (Clipboard::TargetMap::iterator iter = clipboard_data_->begin();
        iter != clipboard_data_->end(); ++iter, ++i) {
     targets[i].target = const_cast<char*>(iter->first.c_str());
     targets[i].flags = 0;
     targets[i].info = 0;
   }
 
-  gtk_clipboard_set_with_data(clipboard_, targets.get(),
-                              clipboard_data_->size(),
-                              GetData, ClearData,
-                              clipboard_data_);
+  if (gtk_clipboard_set_with_data(clipboard_, targets.get(),
+                                  clipboard_data_->size(),
+                                  GetData, ClearData,
+                                  clipboard_data_)) {
+    gtk_clipboard_set_can_store(clipboard_,
+                                targets.get(),
+                                clipboard_data_->size());
+  }
 
   // clipboard_data_ now owned by the GtkClipboard.
   clipboard_data_ = NULL;
 }
 
 void Clipboard::WriteText(const char* text_data, size_t text_len) {
   char* data = new char[text_len];
   memcpy(data, text_data, text_len);
 
   InsertMapping(kMimeText, data, text_len);
@@ skipping 251 matching lines @@
   switch (clipboard) {
     case BUFFER_STANDARD:
       return clipboard_;
     case BUFFER_SELECTION:
       return primary_selection_;
     default:
       NOTREACHED();
       return NULL;
   }
 }