GTK: more signal handler foolproofing.

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 "chrome/browser/browser.h"
 #include "chrome/browser/extensions/extension_browser_event_router.h"
@@ skipping 82 matching lines @@
     // 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);
     }
 
-    g_signal_connect(button_.get(), "button-press-event",
+    signals_.Connect(button_.get(), "button-press-event",
                      G_CALLBACK(OnButtonPress), this);
-    g_signal_connect(button_.get(), "clicked",
+    signals_.Connect(button_.get(), "clicked",
                      G_CALLBACK(OnClicked), this);
-    g_signal_connect_after(button_.get(), "expose-event",
-                           G_CALLBACK(OnExposeEvent), this);
-    g_signal_connect(button_.get(), "drag-begin",
+    signals_.ConnectAfter(button_.get(), "expose-event",
+                          G_CALLBACK(OnExposeEvent), this);
+    signals_.Connect(button_.get(), "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_);
 
@@ skipping 191 matching lines @@
 
   // If we are displaying a tab-specific icon, it will be here.
   GdkPixbuf* tab_specific_icon_;
 
   // If the browser action has a default icon, it will be here.
   GdkPixbuf* default_icon_;
 
   // Same as |default_icon_|, but stored as SkBitmap.
   SkBitmap default_skbitmap_;
 
+  GtkSignalRegistrar signals_;
   NotificationRegistrar registrar_;
 
   // The context menu view and model for this extension action.
   scoped_ptr<MenuGtk> context_menu_;
   scoped_refptr<ExtensionContextMenuModel> context_menu_model_;
 
   friend class BrowserActionsToolbarGtk;
 };
 
 // BrowserActionsToolbarGtk ----------------------------------------------------
@@ skipping 14 matching lines @@
       start_width_(0),
       method_factory_(this) {
   ExtensionsService* extension_service = profile_->GetExtensionsService();
   // The |extension_service| can be NULL in Incognito.
   if (!extension_service)
     return;
 
   GtkWidget* gripper = gtk_button_new();
   GTK_WIDGET_UNSET_FLAGS(gripper, GTK_CAN_FOCUS);
   gtk_widget_add_events(gripper, GDK_POINTER_MOTION_MASK);
-  g_signal_connect(gripper, "motion-notify-event",
+  signals_.Connect(gripper, "motion-notify-event",
                    G_CALLBACK(OnGripperMotionNotifyThunk), this);
-  g_signal_connect(gripper, "expose-event",
+  signals_.Connect(gripper, "expose-event",
                    G_CALLBACK(OnGripperExposeThunk), this);
-  g_signal_connect(gripper, "enter-notify-event",
+  signals_.Connect(gripper, "enter-notify-event",
                    G_CALLBACK(OnGripperEnterNotifyThunk), this);
-  g_signal_connect(gripper, "leave-notify-event",
+  signals_.Connect(gripper, "leave-notify-event",
                    G_CALLBACK(OnGripperLeaveNotifyThunk), this);
-  g_signal_connect(gripper, "button-release-event",
+  signals_.Connect(gripper, "button-release-event",
                    G_CALLBACK(OnGripperButtonReleaseThunk), this);
-  g_signal_connect(gripper, "button-press-event",
+  signals_.Connect(gripper, "button-press-event",
                    G_CALLBACK(OnGripperButtonPressThunk), this);
-  g_signal_connect(overflow_button_.widget(), "button-press-event",
+  signals_.Connect(overflow_button_.widget(), "button-press-event",
                    G_CALLBACK(OnOverflowButtonPressThunk), this);
 
   gtk_box_pack_start(GTK_BOX(hbox_.get()), gripper, FALSE, FALSE, 0);
   gtk_box_pack_start(GTK_BOX(hbox_.get()), button_hbox_.get(), TRUE, TRUE, 0);
   gtk_box_pack_start(GTK_BOX(hbox_.get()), overflow_button_.widget(),
                      FALSE, FALSE, 0);
   gtk_box_pack_start(GTK_BOX(hbox_.get()), separator_, FALSE, FALSE, 0);
 
   model_ = extension_service->toolbar_model();
   model_->AddObserver(this);
   SetupDrags();
 
   if (model_->extensions_initialized()) {
     CreateAllButtons();
     SetContainerWidth();
   }
 
   // We want to connect to "set-focus" on the toplevel window; we have to wait
   // until we are added to a toplevel window to do so.
-  g_signal_connect(widget(), "hierarchy-changed",
+  signals_.Connect(widget(), "hierarchy-changed",
                    G_CALLBACK(OnHierarchyChangedThunk), this);
 
   ViewIDUtil::SetID(button_hbox_.get(), VIEW_ID_BROWSER_ACTION_TOOLBAR);
 }
 
 BrowserActionsToolbarGtk::~BrowserActionsToolbarGtk() {
-  GtkWidget* toplevel = gtk_widget_get_toplevel(widget());
-  if (toplevel) {
-    g_signal_handlers_disconnect_by_func(
-        toplevel, reinterpret_cast<gpointer>(OnSetFocusThunk), this);
-  }
-
   if (model_)
     model_->RemoveObserver(this);
   button_hbox_.Destroy();
   hbox_.Destroy();
 }
 
 int BrowserActionsToolbarGtk::GetCurrentTabId() {
   TabContents* selected_tab = browser_->GetSelectedTabContents();
   if (!selected_tab)
     return -1;
 
   return selected_tab->controller().session_id().id();
 }
 
 void BrowserActionsToolbarGtk::Update() {
   for (ExtensionButtonMap::iterator iter = extension_button_map_.begin();
        iter != extension_button_map_.end(); ++iter) {
     iter->second->UpdateState();
   }
 }
 
 void BrowserActionsToolbarGtk::SetupDrags() {
   GtkTargetEntry drag_target = GetDragTargetEntry();
   gtk_drag_dest_set(button_hbox_.get(), GTK_DEST_DEFAULT_DROP, &drag_target, 1,
                     GDK_ACTION_MOVE);
 
-  g_signal_connect(button_hbox_.get(), "drag-motion",
+  signals_.Connect(button_hbox_.get(), "drag-motion",
                    G_CALLBACK(OnDragMotionThunk), this);
 }
 
 void BrowserActionsToolbarGtk::CreateAllButtons() {
   extension_button_map_.clear();
 
   int i = 0;
   for (ExtensionList::iterator iter = model_->begin();
        iter != model_->end(); ++iter) {
     CreateButtonForExtension(*iter, i++);
@@ skipping 19 matching lines @@
       new BrowserActionButton(this, extension));
   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,
                       GDK_ACTION_MOVE);
   // We ignore whether the drag was a "success" or "failure" in Gtk's opinion.
-  g_signal_connect(button->widget(), "drag-end",
+  signals_.Connect(button->widget(), "drag-end",
                    G_CALLBACK(&OnDragEndThunk), this);
-  g_signal_connect(button->widget(), "drag-failed",
+  signals_.Connect(button->widget(), "drag-failed",
                    G_CALLBACK(&OnDragFailedThunk), this);
 
   // Any time a browser action button is shown or hidden we have to update
   // the chevron state.
-  g_signal_connect(button->widget(), "show",
+  signals_.Connect(button->widget(), "show",
                    G_CALLBACK(&OnButtonShowOrHideThunk), this);
-  g_signal_connect(button->widget(), "hide",
+  signals_.Connect(button->widget(), "hide",
                    G_CALLBACK(&OnButtonShowOrHideThunk), this);
 
   gtk_widget_show(button->widget());
 
   UpdateVisibility();
 }
 
 GtkWidget* BrowserActionsToolbarGtk::GetBrowserActionWidget(
     Extension* extension) {
   ExtensionButtonMap::iterator it = extension_button_map_.find(
@@ skipping 219 matching lines @@
   // several seconds later.
   return TRUE;
 }
 
 void BrowserActionsToolbarGtk::OnHierarchyChanged(
     GtkWidget* widget, GtkWidget* previous_toplevel) {
   GtkWidget* toplevel = gtk_widget_get_toplevel(widget);
   if (!GTK_WIDGET_TOPLEVEL(toplevel))
     return;
 
-  g_signal_connect(toplevel, "set-focus", G_CALLBACK(OnSetFocusThunk), this);
+  signals_.Connect(toplevel, "set-focus", G_CALLBACK(OnSetFocusThunk), this);
 }
 
 void BrowserActionsToolbarGtk::OnSetFocus(GtkWidget* widget,
                                           GtkWidget* focus_widget) {
   ExtensionPopupGtk* popup = ExtensionPopupGtk::get_current_extension_popup();
   // The focus of the parent window has changed. Close the popup. Delay the hide
   // because it will destroy the RenderViewHost, which may still be on the
   // call stack.
   if (!popup || popup->being_inspected())
     return;
@@ skipping 93 matching lines @@
     GtkWidget* menu_item = overflow_menu_->AppendMenuItemWithIcon(
         model_index,
         extension->name(),
         button->GetIcon());
 
     g_object_set_data(G_OBJECT(menu_item), kMenuItemKey, button);
 
     // TODO(estade): set the menu item's tooltip.
   }
 
-  g_signal_connect(overflow_menu_->widget(), "button-press-event",
+  signals_.Connect(overflow_menu_->widget(), "button-press-event",
                    G_CALLBACK(OnOverflowMenuButtonPressThunk), this);
 
   gtk_chrome_button_set_paint_state(GTK_CHROME_BUTTON(overflow),
                                     GTK_STATE_ACTIVE);
   overflow_menu_->PopupAsFromKeyEvent(overflow);
 
   return FALSE;
 }
 
 gboolean BrowserActionsToolbarGtk::OnOverflowMenuButtonPress(
     GtkWidget* overflow, GdkEventButton* event) {
   if (event->button != 3)
     return FALSE;
 
   GtkWidget* menu_item = GTK_MENU_SHELL(overflow)->active_menu_item;
   if (!menu_item)
     return FALSE;
 
   void* data = g_object_get_data(G_OBJECT(menu_item), kMenuItemKey);
   DCHECK(data);
   BrowserActionButton* button = static_cast<BrowserActionButton*>(data);
   button->GetContextMenu()->PopupAsContext(event->time);
   return TRUE;
 }
 
 void BrowserActionsToolbarGtk::OnButtonShowOrHide(GtkWidget* sender) {
   if (!resize_animation_.IsAnimating())
     UpdateChevronVisibility();
 }