GTK: more signal handler foolproofing.

chrome/browser/gtk/rounded_window.cc

 // Copyright (c) 2009 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/rounded_window.h"
 
 #include <gtk/gtk.h>
 #include <math.h>
 
+#include "app/gtk_signal.h"
 #include "base/i18n/rtl.h"
 #include "chrome/browser/gtk/gtk_util.h"
 
 namespace gtk_util {
 
 namespace {
 
 const char* kRoundedData = "rounded-window-data";
 
 // If the border radius is less than |kMinRoundedBorderSize|, we don't actually
 // round the corners, we just truncate the corner.
 const int kMinRoundedBorderSize = 8;
 
 struct RoundedWindowData {
   // Expected window size. Used to detect when we need to reshape the window.
   int expected_width;
   int expected_height;
 
   // Color of the border.
   GdkColor border_color;
 
   // Radius of the edges in pixels.
   int corner_size;
 
   // Which corners should be rounded?
   int rounded_edges;
 
   // Which sides of the window should have an internal border?
   int drawn_borders;
+
+  // Keeps track of attached signal handlers.
+  GtkSignalRegistrar signals;
 };
 
 // Callback from GTK to release allocated memory.
 void FreeRoundedWindowData(gpointer data) {
   delete static_cast<RoundedWindowData*>(data);
 }
 
 enum FrameType {
   FRAME_MASK,
   FRAME_STROKE,
@@ skipping 200 matching lines @@
 
 }  // namespace
 
 void ActAsRoundedWindow(
     GtkWidget* widget, const GdkColor& color, int corner_size,
     int rounded_edges, int drawn_borders) {
   DCHECK(widget);
   DCHECK(!g_object_get_data(G_OBJECT(widget), kRoundedData));
 
   gtk_widget_set_app_paintable(widget, TRUE);
-  g_signal_connect(widget, "expose-event",
-                   G_CALLBACK(OnRoundedWindowExpose), NULL);
-  g_signal_connect(widget, "style-set", G_CALLBACK(OnStyleSet), NULL);
 
   RoundedWindowData* data = new RoundedWindowData;
+  data->signals.Connect(widget, "expose-event",
+                        G_CALLBACK(OnRoundedWindowExpose), NULL);
+  data->signals.Connect(widget, "style-set", G_CALLBACK(OnStyleSet), NULL);
+
   data->expected_width = -1;
   data->expected_height = -1;
 
   data->border_color = color;
   data->corner_size = corner_size;
 
   data->rounded_edges = rounded_edges;
   data->drawn_borders = drawn_borders;
 
   g_object_set_data_full(G_OBJECT(widget), kRoundedData,
                          data, FreeRoundedWindowData);
 }
 
 void StopActingAsRoundedWindow(GtkWidget* widget) {
-  g_signal_handlers_disconnect_by_func(widget,
-      reinterpret_cast<gpointer>(OnRoundedWindowExpose), NULL);
-  g_signal_handlers_disconnect_by_func(widget,
-      reinterpret_cast<gpointer>(OnStyleSet), NULL);
-
-  delete static_cast<RoundedWindowData*>(
-      g_object_steal_data(G_OBJECT(widget), kRoundedData));
+  g_object_set_data(G_OBJECT(widget), kRoundedData, NULL);
 
   if (GTK_WIDGET_REALIZED(widget))
     gdk_window_shape_combine_mask(widget->window, NULL, 0, 0);
 }
 
 bool IsActingAsRoundedWindow(GtkWidget* widget) {
   return g_object_get_data(G_OBJECT(widget), kRoundedData) != NULL;
 }
 
 void SetRoundedWindowEdgesAndBorders(GtkWidget* widget,
@@ skipping 11 matching lines @@
 
 void SetRoundedWindowBorderColor(GtkWidget* widget, GdkColor color) {
   DCHECK(widget);
   RoundedWindowData* data = static_cast<RoundedWindowData*>(
       g_object_get_data(G_OBJECT(widget), kRoundedData));
   DCHECK(data);
   data->border_color = color;
 }
 
 }  // namespace gtk_util