GTK: Move to gtk_widget_get_allocation() for some of chrome/browser/ui/gtk/

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

 // Copyright (c) 2011 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/metrics/histogram.h"
@@ skipping 278 matching lines @@
   }
   BookmarkBar::State old_state = bookmark_bar_state_;
   bookmark_bar_state_ = state;
   if (state == BookmarkBar::SHOW || state == BookmarkBar::DETACHED)
     Show(old_state, animate_type);
   else
     Hide(old_state, animate_type);
 }
 
 int BookmarkBarGtk::GetHeight() {
-  return event_box_->allocation.height - kBookmarkBarMinimumHeight;
+  GtkAllocation allocation;
+  gtk_widget_get_allocation(event_box_.get(), &allocation);
+  return allocation.height - kBookmarkBarMinimumHeight;
 }
 
 bool BookmarkBarGtk::IsAnimating() {
   return slide_animation_.is_animating();
 }
 
 void BookmarkBarGtk::CalculateMaxHeight() {
-
   if (theme_service_->UsingNativeTheme()) {
     // Get the requisition of our single child instead of the event box itself
     // because the event box probably already has a size request.
     GtkRequisition req;
     gtk_widget_size_request(ntp_padding_box_, &req);
     max_height_ = req.height;
   } else {
     max_height_ = (bookmark_bar_state_ == BookmarkBar::DETACHED) ?
                   kBookmarkBarNTPHeight : kBookmarkBarHeight;
   }
@@ skipping 163 matching lines @@
 void BookmarkBarGtk::SetChevronState() {
   if (!gtk_widget_get_visible(bookmark_hbox_))
     return;
 
   if (show_instructions_) {
     gtk_widget_hide(overflow_button_);
     return;
   }
 
   int extra_space = 0;
-  if (gtk_widget_get_visible(overflow_button_))
-    extra_space = overflow_button_->allocation.width;
+  if (gtk_widget_get_visible(overflow_button_)) {
+    GtkAllocation allocation;
+    gtk_widget_get_allocation(overflow_button_, &allocation);
+    extra_space = allocation.width;
+  }
 
   int overflow_idx = GetFirstHiddenBookmark(extra_space, NULL);
   if (overflow_idx == -1)
     gtk_widget_hide(overflow_button_);
   else
     gtk_widget_show_all(overflow_button_);
 }
 
 void BookmarkBarGtk::UpdateOtherBookmarksVisibility() {
   bool has_other_children = !model_->other_node()->empty();
@@ skipping 61 matching lines @@
     std::vector<GtkWidget*>* showing_folders) {
   int rv = 0;
   // We're going to keep track of how much width we've used as we move along
   // the bookmark bar. If we ever surpass the width of the bookmark bar, we'll
   // know that's the first hidden bookmark.
   int width_used = 0;
   // GTK appears to require one pixel of padding to the side of the first and
   // last buttons on the bar.
   // TODO(gideonwald): figure out the precise source of these extra two pixels
   // and make this calculation more reliable.
-  int total_width = bookmark_toolbar_.get()->allocation.width - 2;
+  GtkAllocation allocation;
+  gtk_widget_get_allocation(bookmark_toolbar_.get(), &allocation);
+  int total_width = allocation.width - 2;
   bool overflow = false;
   GtkRequisition requested_size_;
   GList* toolbar_items =
       gtk_container_get_children(GTK_CONTAINER(bookmark_toolbar_.get()));
   for (GList* iter = toolbar_items; iter; iter = g_list_next(iter)) {
     GtkWidget* tool_item = reinterpret_cast<GtkWidget*>(iter->data);
     gtk_widget_size_request(tool_item, &requested_size_);
     width_used += requested_size_.width;
     // |extra_space| is available if we can remove the chevron, which happens
     // only if there are no more potential overflow bookmarks after this one.
@@ skipping 202 matching lines @@
                                       index);
   if (target_type == ui::GetAtomForTarget(ui::CHROME_BOOKMARK_ITEM)) {
     gdk_drag_status(context, GDK_ACTION_MOVE, time);
   } else {
     gdk_drag_status(context, GDK_ACTION_COPY, time);
   }
 
   return TRUE;
 }
 
-int BookmarkBarGtk::GetToolbarIndexForDragOverFolder(
-    GtkWidget* button, gint x) {
-  int margin = std::min(15, static_cast<int>(0.3 * button->allocation.width));
-  if (x > margin && x < (button->allocation.width - margin))
+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;
 
   gint index = gtk_toolbar_get_item_index(GTK_TOOLBAR(bookmark_toolbar_.get()),
                                           GTK_TOOL_ITEM(button->parent));
   if (x > margin)
     index++;
   return index;
 }
 
 void BookmarkBarGtk::ClearToolbarDropHighlighting() {
@@ skipping 401 matching lines @@
                                              GdkDragContext* context,
                                              gint x,
                                              gint y,
                                              guint time) {
   gint index = gtk_toolbar_get_drop_index(GTK_TOOLBAR(toolbar), x, y);
   return ItemDraggedOverToolbar(context, index, time);
 }
 
 void BookmarkBarGtk::OnToolbarSizeAllocate(GtkWidget* widget,
                                            GtkAllocation* allocation) {
-  if (bookmark_toolbar_.get()->allocation.width ==
-      last_allocation_width_) {
+  if (allocation->width == last_allocation_width_) {
     // If the width hasn't changed, then the visibility of the chevron
     // doesn't need to change. This check prevents us from getting stuck in a
     // loop where allocates are queued indefinitely while the visibility of
     // overflow chevron toggles without actual resizes of the toolbar.
     return;
   }
-  last_allocation_width_ = bookmark_toolbar_.get()->allocation.width;
+  last_allocation_width_ = allocation->width;
 
   SetChevronState();
 }
 
 void BookmarkBarGtk::OnDragReceived(GtkWidget* widget,
                                     GdkDragContext* context,
                                     gint x, gint y,
                                     GtkSelectionData* selection_data,
                                     guint target_type, guint time) {
   if (!edit_bookmarks_enabled_.GetValue()) {
@@ skipping 136 matching lines @@
     gtk_util::DrawThemedToolbarBackground(widget, cr, event, tabstrip_origin,
                                           theme_provider);
 
     cairo_destroy(cr);
   } else {
     gfx::Size tab_contents_size;
     if (!GetTabContentsSize(&tab_contents_size))
       return FALSE;
     gfx::CanvasSkiaPaint canvas(event, true);
 
+    GtkAllocation allocation;
+    gtk_widget_get_allocation(widget, &allocation);
+
     gfx::Rect area = GTK_WIDGET_NO_WINDOW(widget) ?
-        gfx::Rect(widget->allocation) :
-        gfx::Rect(0, 0, widget->allocation.width, widget->allocation.height);
+        gfx::Rect(allocation) :
+        gfx::Rect(0, 0, allocation.width, allocation.height);
     NtpBackgroundUtil::PaintBackgroundDetachedMode(theme_provider, &canvas,
         area, tab_contents_size.height());
   }
 
   return FALSE;  // Propagate expose to children.
 }
 
 void BookmarkBarGtk::OnEventBoxDestroy(GtkWidget* widget) {
   if (model_)
     model_->RemoveObserver(this);
@@ skipping 24 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);
 }