GTK: Seal up GSEALs, focusing on GtkSelectionData.

ui/base/clipboard/clipboard_gtk.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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 "ui/base/clipboard/clipboard.h"
 
 #include <gtk/gtk.h>
 #include <X11/extensions/Xfixes.h>
 #include <X11/Xatom.h>
 #include <map>
 #include <set>
@@ skipping 110 matching lines @@
 
 // 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) {
   Clipboard::TargetMap* data_map =
       reinterpret_cast<Clipboard::TargetMap*>(user_data);
 
-  std::string target_string = GdkAtomToString(selection_data->target);
+  std::string target_string = GdkAtomToString(
+      gtk_selection_data_get_target(selection_data));
   Clipboard::TargetMap::iterator iter = data_map->find(target_string);
 
   if (iter == data_map->end())
     return;
 
   if (target_string == kMimeTypeBitmap) {
     gtk_selection_data_set_pixbuf(selection_data,
         reinterpret_cast<GdkPixbuf*>(iter->second.first));
   } else {
-    gtk_selection_data_set(selection_data, selection_data->target, 8,
+    gtk_selection_data_set(selection_data,
+                           gtk_selection_data_get_target(selection_data), 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) {
@@ skipping 261 matching lines @@
   *contains_filenames = false;
 
   GtkClipboard* clipboard = LookupBackingClipboard(buffer);
   if (!clipboard)
     return;
 
   GtkSelectionData* data = gtk_clipboard_wait_for_contents(
       clipboard, GetWebCustomDataFormatType().ToGdkAtom());
   if (!data)
     return;
-  ReadCustomDataTypes(data->data, data->length, types);
+  ReadCustomDataTypes(gtk_selection_data_get_data(data),
+                      gtk_selection_data_get_length(data),
+                      types);
   gtk_selection_data_free(data);
 }
 
 
 void Clipboard::ReadText(Clipboard::Buffer buffer, string16* result) const {
   GtkClipboard* clipboard = LookupBackingClipboard(buffer);
   if (clipboard == NULL)
     return;
 
   result->clear();
@@ skipping 42 matching lines @@
   if (clipboard == NULL)
     return;
   GtkSelectionData* data = gtk_clipboard_wait_for_contents(clipboard,
       GetHtmlFormatType().ToGdkAtom());
 
   if (!data)
     return;
 
   // If the data starts with 0xFEFF, i.e., Byte Order Mark, assume it is
   // UTF-16, otherwise assume UTF-8.
-  if (data->length >= 2 &&
-      reinterpret_cast<uint16_t*>(data->data)[0] == 0xFEFF) {
-    markup->assign(reinterpret_cast<uint16_t*>(data->data) + 1,
-                   (data->length / 2) - 1);
+  gint data_length = gtk_selection_data_get_length(data);
+  const guchar* raw_data = gtk_selection_data_get_data(data);
+
+  if (data_length >= 2 &&
+      reinterpret_cast<const uint16_t*>(raw_data)[0] == 0xFEFF) {
+    markup->assign(reinterpret_cast<const uint16_t*>(raw_data) + 1,
+                   (data_length / 2) - 1);
   } else {
-    UTF8ToUTF16(reinterpret_cast<char*>(data->data), data->length, markup);
+    UTF8ToUTF16(reinterpret_cast<const char*>(raw_data), data_length, markup);
   }
 
   // If there is a terminating NULL, drop it.
   if (!markup->empty() && markup->at(markup->length() - 1) == '\0')
     markup->resize(markup->length() - 1);
 
   *fragment_start = 0;
   DCHECK(markup->length() <= kuint32max);
   *fragment_end = static_cast<uint32>(markup->length());
 
@@ skipping 22 matching lines @@
                                const string16& type,
                                string16* result) const {
   GtkClipboard* clipboard = LookupBackingClipboard(buffer);
   if (!clipboard)
     return;
 
   GtkSelectionData* data = gtk_clipboard_wait_for_contents(
       clipboard, GetWebCustomDataFormatType().ToGdkAtom());
   if (!data)
     return;
-  ReadCustomDataForType(data->data, data->length, type, result);
+  ReadCustomDataForType(gtk_selection_data_get_data(data),
+                        gtk_selection_data_get_length(data),
+                        type, result);
   gtk_selection_data_free(data);
 }
 
 void Clipboard::ReadBookmark(string16* title, std::string* url) const {
   // TODO(estade): implement this.
   NOTIMPLEMENTED();
 }
 
 void Clipboard::ReadData(const FormatType& format, std::string* result) const {
   GtkSelectionData* data =
       gtk_clipboard_wait_for_contents(clipboard_, format.ToGdkAtom());
   if (!data)
     return;
-  result->assign(reinterpret_cast<char*>(data->data), data->length);
+  result->assign(reinterpret_cast<const char*>(
+                     gtk_selection_data_get_data(data)),
+                 gtk_selection_data_get_length(data));
   gtk_selection_data_free(data);
 }
 
 uint64 Clipboard::GetSequenceNumber(Buffer buffer) {
   if (buffer == BUFFER_STANDARD)
     return SelectionChangeObserver::GetInstance()->clipboard_sequence_number();
   else
     return SelectionChangeObserver::GetInstance()->primary_sequence_number();
 }
 
@@ skipping 52 matching lines @@
       return clipboard_;
     case BUFFER_SELECTION:
       return primary_selection_;
     default:
       NOTREACHED();
       return NULL;
   }
 }
 
 }  // namespace ui