GTK: unbreak extension badges.

chrome/browser/gtk/browser_actions_toolbar_gtk.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 "chrome/browser/gtk/browser_actions_toolbar_gtk.h"
 
 #include <vector>
 
 #include "base/i18n/rtl.h"
 #include "chrome/browser/browser.h"
@@ skipping 79 matching lines @@
         tracker_(this),
         tab_specific_icon_(NULL),
         default_icon_(NULL) {
     button_.reset(new CustomDrawButton(
         theme_provider,
         IDR_BROWSER_ACTION,
         IDR_BROWSER_ACTION_P,
         IDR_BROWSER_ACTION_H,
         0,
         NULL));
+    alignment_.Own(gtk_alignment_new(0, 0, 1, 1));
+    gtk_container_add(GTK_CONTAINER(alignment_.get()), button());
+    gtk_widget_show(button());
 
     DCHECK(extension_->browser_action());
 
     UpdateState();
 
     // The Browser Action API does not allow the default icon path to be
     // changed at runtime, so we can load this now and cache it.
     std::string path = extension_->browser_action()->default_icon_path();
     if (!path.empty()) {
       tracker_.LoadImage(extension_, extension_->GetResource(path),
                          gfx::Size(Extension::kBrowserActionIconMaxSize,
                                    Extension::kBrowserActionIconMaxSize),
                          ImageLoadingTracker::DONT_CACHE);
     }
 
-    signals_.Connect(button_->widget(), "button-press-event",
+    signals_.Connect(button(), "button-press-event",
                      G_CALLBACK(OnButtonPress), this);
-    signals_.Connect(button_->widget(), "clicked",
+    signals_.Connect(button(), "clicked",
                      G_CALLBACK(OnClicked), this);
-    signals_.ConnectAfter(button_->widget(), "expose-event",
+    signals_.Connect(button(), "drag-begin",
+                     G_CALLBACK(&OnDragBegin), this);
+    signals_.ConnectAfter(widget(), "expose-event",
                           G_CALLBACK(OnExposeEvent), this);
-    signals_.Connect(button_->widget(), "drag-begin",
-                     G_CALLBACK(&OnDragBegin), this);
 
     registrar_.Add(this, NotificationType::EXTENSION_BROWSER_ACTION_UPDATED,
                    Source<ExtensionAction>(extension->browser_action()));
   }
 
   ~BrowserActionButton() {
     if (tab_specific_icon_)
       g_object_unref(tab_specific_icon_);
 
     if (default_icon_)
       g_object_unref(default_icon_);
+
+    alignment_.Destroy();
   }
 
-  GtkWidget* widget() { return button_->widget(); }
+  GtkWidget* button() { return button_->widget(); }
+
+  GtkWidget* widget() { return alignment_.get(); }
 
   Extension* extension() { return extension_; }
 
   // NotificationObserver implementation.
   void Observe(NotificationType type,
                const NotificationSource& source,
                const NotificationDetails& details) {
     if (type == NotificationType::EXTENSION_BROWSER_ACTION_UPDATED)
       UpdateState();
     else
@@ skipping 11 matching lines @@
 
   // Updates the button based on the latest state from the associated
   // browser action.
   void UpdateState() {
     int tab_id = toolbar_->GetCurrentTabId();
     if (tab_id < 0)
       return;
 
     std::string tooltip = extension_->browser_action()->GetTitle(tab_id);
     if (tooltip.empty())
-      gtk_widget_set_has_tooltip(button_->widget(), FALSE);
+      gtk_widget_set_has_tooltip(button(), FALSE);
     else
-      gtk_widget_set_tooltip_text(button_->widget(), tooltip.c_str());
+      gtk_widget_set_tooltip_text(button(), tooltip.c_str());
 
     SkBitmap image = extension_->browser_action()->GetIcon(tab_id);
     if (!image.isNull()) {
       GdkPixbuf* previous_gdk_icon = tab_specific_icon_;
       tab_specific_icon_ = gfx::GdkPixbufFromSkBitmap(&image);
       SetImage(tab_specific_icon_);
       if (previous_gdk_icon)
         g_object_unref(previous_gdk_icon);
     } else if (default_icon_) {
       SetImage(default_icon_);
     }
-    gtk_widget_queue_draw(button_->widget());
+    gtk_widget_queue_draw(button());
   }
 
   SkBitmap GetIcon() {
     const SkBitmap& image = extension_->browser_action()->GetIcon(
         toolbar_->GetCurrentTabId());
     if (!image.isNull()) {
       return image;
     } else {
       return default_skbitmap_;
     }
@@ skipping 47 matching lines @@
   }
 
   // ExtensionContextMenuModel::PopupDelegate implementation.
   virtual void InspectPopup(ExtensionAction* action) {
     ShowPopup(true);
   }
 
   void SetImage(GdkPixbuf* image) {
     if (!image_) {
       image_ = gtk_image_new_from_pixbuf(image);
-      gtk_button_set_image(GTK_BUTTON(button_->widget()), image_);
+      gtk_button_set_image(GTK_BUTTON(button()), image_);
     } else {
       gtk_image_set_from_pixbuf(GTK_IMAGE(image_), image);
     }
   }
 
   static gboolean OnButtonPress(GtkWidget* widget,
                                 GdkEvent* event,
                                 BrowserActionButton* action) {
     if (event->button.button != 3)
       return FALSE;
@@ skipping 41 matching lines @@
 
   // The toolbar containing this button.
   BrowserActionsToolbarGtk* toolbar_;
 
   // The extension that contains this browser action.
   Extension* extension_;
 
   // The button for this browser action.
   scoped_ptr<CustomDrawButton> button_;
 
+  // The top level widget (parent of |button_|).
+  OwnedWidgetGtk alignment_;
+
   // The one image subwidget in |button_|. We keep this out so we don't alter
   // the widget hierarchy while changing the button image because changing the
   // GTK widget hierarchy invalidates all tooltips and several popular
   // extensions change browser action icon in a loop.
   GtkWidget* image_;
 
   // Loads the button's icons for us on the file thread.
   ImageLoadingTracker tracker_;
 
   // If we are displaying a tab-specific icon, it will be here.
@@ skipping 174 matching lines @@
 
   RemoveButtonForExtension(extension);
   linked_ptr<BrowserActionButton> button(
       new BrowserActionButton(this, extension, theme_provider_));
   gtk_chrome_shrinkable_hbox_pack_start(
       GTK_CHROME_SHRINKABLE_HBOX(button_hbox_.get()), button->widget(), 0);
   gtk_box_reorder_child(GTK_BOX(button_hbox_.get()), button->widget(), index);
   extension_button_map_[extension->id()] = button;
 
   GtkTargetEntry drag_target = GetDragTargetEntry();
-  gtk_drag_source_set(button->widget(), GDK_BUTTON1_MASK, &drag_target, 1,
+  gtk_drag_source_set(button->button(), GDK_BUTTON1_MASK, &drag_target, 1,
                       GDK_ACTION_MOVE);
   // We ignore whether the drag was a "success" or "failure" in Gtk's opinion.
-  signals_.Connect(button->widget(), "drag-end",
+  signals_.Connect(button->button(), "drag-end",
                    G_CALLBACK(&OnDragEndThunk), this);
-  signals_.Connect(button->widget(), "drag-failed",
+  signals_.Connect(button->button(), "drag-failed",
                    G_CALLBACK(&OnDragFailedThunk), this);
 
   // Any time a browser action button is shown or hidden we have to update
   // the chevron state.
   signals_.Connect(button->widget(), "show",
                    G_CALLBACK(&OnButtonShowOrHideThunk), this);
   signals_.Connect(button->widget(), "hide",
                    G_CALLBACK(&OnButtonShowOrHideThunk), this);
 
   gtk_widget_show(button->widget());
@@ skipping 382 matching lines @@
   }
 
   it->second.get()->GetContextMenu()->PopupAsContext(event->time);
   return TRUE;
 }
 
 void BrowserActionsToolbarGtk::OnButtonShowOrHide(GtkWidget* sender) {
   if (!resize_animation_.is_animating())
     UpdateChevronVisibility();
 }