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>
 #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 kMimeURI[] = "text/uri-list";
 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) {
@@ skipping 11 matching lines @@
 
   std::string target_string = GdkAtomToString(selection_data->target);
   Clipboard::TargetMap::iterator iter = data_map->find(target_string);
 
   if (iter == data_map->end())
     return;
 
   if (target_string == kMimeBmp) {
     gtk_selection_data_set_pixbuf(selection_data,
         reinterpret_cast<GdkPixbuf*>(iter->second.first));
+  } else if (target_string == kMimeURI) {
+    gchar* uri_list[2];
+    uri_list[0] = reinterpret_cast<gchar*>(iter->second.first);
+    uri_list[1] = NULL;
+    gtk_selection_data_set_uris(selection_data, uri_list);
   } else {
     gtk_selection_data_set(selection_data, selection_data->target, 8,
                            reinterpret_cast<guchar*>(iter->second.first),
                            iter->second.second);
   }
 }
 
 // GtkClipboardClearFunc callback.
 // We are guaranteed this will be called exactly once for each call to
 // gtk_clipboard_set_with_data
 void ClearData(GtkClipboard* clipboard,
                gpointer user_data) {
   Clipboard::TargetMap* map =
       reinterpret_cast<Clipboard::TargetMap*>(user_data);
   std::set<char*> ptrs;
 
   for (Clipboard::TargetMap::iterator iter = map->begin();
        iter != map->end(); ++iter) {
     if (iter->first == kMimeBmp)
       g_object_unref(reinterpret_cast<GdkPixbuf*>(iter->second.first));
     else
       ptrs.insert(iter->second.first);
   }
 
   for (std::set<char*>::iterator iter = ptrs.begin();
-       iter != ptrs.end(); ++iter)
+       iter != ptrs.end(); ++iter) {
     delete[] *iter;
+  }
 
   delete map;
 }
 
 // Called on GdkPixbuf destruction; see WriteBitmap().
 void GdkPixbufFree(guchar* pixels, gpointer data) {
   free(pixels);
 }
 
 }  // namespace
@@ skipping 84 matching lines @@
                                8, size->width(), size->height(),
                                size->width() * 4, GdkPixbufFree, NULL);
   // We store the GdkPixbuf*, and the size_t half of the pair is meaningless.
   // Note that this contrasts with the vast majority of entries in our target
   // map, which directly store the data and its length.
   InsertMapping(kMimeBmp, reinterpret_cast<char*>(pixbuf), 0);
 }
 
 void Clipboard::WriteBookmark(const char* title_data, size_t title_len,
                               const char* url_data, size_t url_len) {
-  // TODO(estade): implement this, but for now fail silently so we do not
-  // write error output during layout tests.
-  // NOTIMPLEMENTED();
-}
+  // Write as plain text.
+  WriteText(url_data, url_len);
 
-void Clipboard::WriteHyperlink(const char* title_data, size_t title_len,
-                               const char* url_data, size_t url_len) {
-  NOTIMPLEMENTED();
+  // Write as a URI.
+  char* data = new char[url_len + 1];
+  memcpy(data, url_data, url_len);
+  data[url_len] = NULL;
+  InsertMapping(kMimeURI, data, url_len + 1);
 }
 
 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);
@@ skipping 182 matching lines @@
     case BUFFER_SELECTION:
       result = primary_selection_;
       break;
     default:
       NOTREACHED();
       result = NULL;
       break;
   }
   return result;
 }
-