GTK: Do more GSEALing.

chrome/browser/ui/gtk/bookmarks/bookmark_bar_gtk.cc

 // 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 "chrome/browser/ui/gtk/bookmarks/bookmark_bar_gtk.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
@@ skipping 626 matching lines @@
   } else {
     gtk_util::StopActingAsRoundedWindow(paint_box_);
     gtk_event_box_set_visible_window(GTK_EVENT_BOX(paint_box_), FALSE);
     gtk_alignment_set_padding(GTK_ALIGNMENT(ntp_padding_box_), 0, 0, 0, 0);
     gtk_container_set_border_width(GTK_CONTAINER(bookmark_hbox_), 0);
   }
 
   UpdateEventBoxPaintability();
   // |window_| can be NULL during testing.
   // Listen for parent size allocations. Only connect once.
-  if (window_ && detached && widget()->parent &&
-      g_signal_handler_find(widget()->parent, G_SIGNAL_MATCH_FUNC,
-          0, 0, NULL, reinterpret_cast<gpointer>(OnParentSizeAllocateThunk),
-          NULL) == 0) {
-    g_signal_connect(widget()->parent, "size-allocate",
-                     G_CALLBACK(OnParentSizeAllocateThunk), this);
+  if (window_ && detached) {
+    GtkWidget* parent = gtk_widget_get_parent(widget());
+    if (parent &&
+        g_signal_handler_find(parent, G_SIGNAL_MATCH_FUNC,
+            0, 0, NULL, reinterpret_cast<gpointer>(OnParentSizeAllocateThunk),
+            NULL) == 0) {
+      g_signal_connect(parent, "size-allocate",
+                       G_CALLBACK(OnParentSizeAllocateThunk), this);
+    }
   }
 }
 
 void BookmarkBarGtk::UpdateEventBoxPaintability() {
   gtk_widget_set_app_paintable(
       event_box_.get(),
       (!theme_service_->UsingNativeTheme() ||
        bookmark_bar_state_ == BookmarkBar::DETACHED));
   // When using the GTK+ theme, we need to have the event box be visible so
   // buttons don't get a halo color from the background.  When using Chromium
@@ skipping 148 matching lines @@
 
 int BookmarkBarGtk::GetToolbarIndexForDragOverFolder(GtkWidget* button,
                                                      gint x) {
   GtkAllocation allocation;
   gtk_widget_get_allocation(button, &allocation);
 
   int margin = std::min(15, static_cast<int>(0.3 * allocation.width));
   if (x > margin && x < (allocation.width - margin))
     return -1;
 
+  GtkWidget* parent = gtk_widget_get_parent(button);
   gint index = gtk_toolbar_get_item_index(GTK_TOOLBAR(bookmark_toolbar_.get()),
-                                          GTK_TOOL_ITEM(button->parent));
+                                          GTK_TOOL_ITEM(parent));
   if (x > margin)
     index++;
   return index;
 }
 
 void BookmarkBarGtk::ClearToolbarDropHighlighting() {
   if (toolbar_drop_item_) {
     g_object_unref(toolbar_drop_item_);
     toolbar_drop_item_ = NULL;
   }
@@ skipping 306 matching lines @@
   Profile* profile = browser_->profile();
   RecordAppLaunch(profile, node->url());
   bookmark_utils::OpenAll(window_->GetNativeHandle(), profile, page_navigator_,
       node, gtk_util::DispositionForCurrentButtonPressEvent());
 
   content::RecordAction(UserMetricsAction("ClickedBookmarkBarURLButton"));
 }
 
 void BookmarkBarGtk::OnButtonDragBegin(GtkWidget* button,
                                        GdkDragContext* drag_context) {
+  GtkWidget* button_parent = gtk_widget_get_parent(button);
+
   // The parent tool item might be removed during the drag. Ref it so |button|
   // won't get destroyed.
-  g_object_ref(button->parent);
+  g_object_ref(button_parent);
 
   const BookmarkNode* node = GetNodeForToolButton(button);
   DCHECK(!dragged_node_);
   dragged_node_ = node;
   DCHECK(dragged_node_);
 
   drag_icon_ = bookmark_utils::GetDragRepresentationForNode(
       node, model_, theme_service_);
 
   // We have to jump through some hoops to get the drag icon to line up because
   // it is a different size than the button.
   GtkRequisition req;
   gtk_widget_size_request(drag_icon_, &req);
   gfx::Rect button_rect = gtk_util::WidgetBounds(button);
   gfx::Point drag_icon_relative =
       gfx::Rect(req.width, req.height).CenterPoint().Add(
           (last_pressed_coordinates_.Subtract(button_rect.CenterPoint())));
   gtk_drag_set_icon_widget(drag_context, drag_icon_,
                            drag_icon_relative.x(),
                            drag_icon_relative.y());
 
   // Hide our node, but reserve space for it on the toolbar.
   int index = gtk_toolbar_get_item_index(GTK_TOOLBAR(bookmark_toolbar_.get()),
-                                         GTK_TOOL_ITEM(button->parent));
+                                         GTK_TOOL_ITEM(button_parent));
   gtk_widget_hide(button);
   toolbar_drop_item_ = CreateBookmarkToolItem(dragged_node_);
   g_object_ref_sink(GTK_OBJECT(toolbar_drop_item_));
   gtk_toolbar_set_drop_highlight_item(GTK_TOOLBAR(bookmark_toolbar_.get()),
                                       GTK_TOOL_ITEM(toolbar_drop_item_), index);
   // Make sure it stays hidden for the duration of the drag.
   gtk_widget_set_no_show_all(button, TRUE);
 }
 
 void BookmarkBarGtk::OnButtonDragEnd(GtkWidget* button,
                                      GdkDragContext* drag_context) {
   gtk_widget_show(button);
   gtk_widget_set_no_show_all(button, FALSE);
 
   ClearToolbarDropHighlighting();
 
   DCHECK(dragged_node_);
   dragged_node_ = NULL;
 
   DCHECK(drag_icon_);
   gtk_widget_destroy(drag_icon_);
   drag_icon_ = NULL;
 
-  g_object_unref(button->parent);
+  g_object_unref(gtk_widget_get_parent(button));
 }
 
 void BookmarkBarGtk::OnButtonDragGet(GtkWidget* widget,
                                      GdkDragContext* context,
                                      GtkSelectionData* selection_data,
                                      guint target_type,
                                      guint time) {
   const BookmarkNode* node = bookmark_utils::BookmarkNodeForWidget(widget);
   bookmark_utils::WriteBookmarkToSelection(node, selection_data, target_type,
                                            browser_->profile());
@@ skipping 63 matching lines @@
   } else {
     index = GetToolbarIndexForDragOverFolder(widget, x);
     if (index < 0) {
       dest_node = GetNodeForToolButton(widget);
       index = dest_node->child_count();
     }
   }
 
   switch (target_type) {
     case ui::CHROME_BOOKMARK_ITEM: {
-      Pickle pickle(reinterpret_cast<char*>(selection_data->data),
-                    selection_data->length);
+      gint length = gtk_selection_data_get_length(selection_data);
+      Pickle pickle(reinterpret_cast<const char*>(
+          gtk_selection_data_get_data(selection_data)), length);
       BookmarkNodeData drag_data;
       if (drag_data.ReadFromPickle(&pickle)) {
         dnd_success = bookmark_utils::PerformBookmarkDrop(
             browser_->profile(),
             drag_data,
             dest_node,
             index) != ui::DragDropTypes::DRAG_NONE;
       }
       break;
     }
@@ skipping 81 matching lines @@
   TRACE_EVENT0("ui::gtk", "BookmarkBarGtk::OnEventBoxExpose");
   GtkThemeService* theme_provider = theme_service_;
 
   // We don't need to render the toolbar image in GTK mode, except when
   // detached.
   if (theme_provider->UsingNativeTheme() &&
       bookmark_bar_state_ != BookmarkBar::DETACHED)
     return FALSE;
 
   if (bookmark_bar_state_ != BookmarkBar::DETACHED) {
-    cairo_t* cr = gdk_cairo_create(GDK_DRAWABLE(widget->window));
+    cairo_t* cr = gdk_cairo_create(gtk_widget_get_window(widget));
     gdk_cairo_rectangle(cr, &event->area);
     cairo_clip(cr);
 
     // Paint the background theme image.
     gfx::Point tabstrip_origin =
         tabstrip_origin_provider_->GetTabStripOriginForWidget(widget);
     gtk_util::DrawThemedToolbarBackground(widget, cr, event, tabstrip_origin,
                                           theme_provider);
 
     cairo_destroy(cr);
@@ skipping 46 matching lines @@
 void BookmarkBarGtk::OnEditBookmarksEnabledChanged() {
   GtkDestDefaults dest_defaults =
       *edit_bookmarks_enabled_ ? GTK_DEST_DEFAULT_ALL :
                                  GTK_DEST_DEFAULT_DROP;
   gtk_drag_dest_set(overflow_button_, dest_defaults, NULL, 0, kDragAction);
   gtk_drag_dest_set(other_bookmarks_button_, dest_defaults,
                     NULL, 0, kDragAction);
   ui::SetDestTargetList(overflow_button_, kDestTargetList);
   ui::SetDestTargetList(other_bookmarks_button_, kDestTargetList);
 }