sharing: Replace GObject boilerplace with G_DECLARE_TYPE

6 files changed, 163 insertions, 267 deletions

diff --git a/panels/sharing/cc-sharing-networks.c b/panels/sharing/cc-sharing-networks.c
index 672ac98d6..6064db3be 100644
--- a/panels/sharing/cc-sharing-networks.c
+++ b/panels/sharing/cc-sharing-networks.c
@@ -28,7 +28,9 @@
 #include "gsd-sharing-enums.h"
 #include "list-box-helper.h"
 
-struct _CcSharingNetworksPrivate {
+struct _CcSharingNetworks {
+  GtkGrid parent_instance;
+
   GtkWidget *listbox;
 
   GtkWidget *current_row;
@@ -46,8 +48,7 @@ struct _CcSharingNetworksPrivate {
 };
 
 
-G_DEFINE_TYPE_WITH_CODE (CcSharingNetworks, cc_sharing_networks, GTK_TYPE_GRID,
-			 G_ADD_PRIVATE (CcSharingNetworks))
+G_DEFINE_TYPE (CcSharingNetworks, cc_sharing_networks, GTK_TYPE_GRID)
 
 enum {
   PROP_0,
@@ -84,16 +85,16 @@ cc_sharing_networks_update_status (CcSharingNetworks *self)
 {
   CcSharingStatus status;
 
-  if (self->priv->networks == NULL)
+  if (self->networks == NULL)
     status = CC_SHARING_STATUS_OFF;
-  else if (gtk_widget_is_visible (self->priv->current_switch) &&
-	   gtk_switch_get_active (GTK_SWITCH (self->priv->current_switch)))
+  else if (gtk_widget_is_visible (self->current_switch) &&
+	   gtk_switch_get_active (GTK_SWITCH (self->current_switch)))
     status = CC_SHARING_STATUS_ACTIVE;
   else
     status = CC_SHARING_STATUS_ENABLED;
 
-  if (status != self->priv->status) {
-    self->priv->status = status;
+  if (status != self->status) {
+    self->status = status;
     g_object_notify (G_OBJECT (self), "status");
   }
 }
@@ -106,16 +107,16 @@ cc_sharing_update_networks (CcSharingNetworks *self)
   GVariantIter iter;
   GError *error = NULL;
 
-  g_list_free_full (self->priv->networks, cc_sharing_network_free);
-  self->priv->networks = NULL;
+  g_list_free_full (self->networks, cc_sharing_network_free);
+  self->networks = NULL;
 
-  if (!gsd_sharing_call_list_networks_sync (self->priv->proxy, self->priv->service_name, &networks, NULL, &error)) {
+  if (!gsd_sharing_call_list_networks_sync (self->proxy, self->service_name, &networks, NULL, &error)) {
     g_warning ("couldn't list networks: %s", error->message);
-    g_dbus_proxy_set_cached_property (G_DBUS_PROXY (self->priv->proxy),
+    g_dbus_proxy_set_cached_property (G_DBUS_PROXY (self->proxy),
 				      "SharingStatus",
 				      g_variant_new_uint32 (GSD_SHARING_STATUS_OFFLINE));
     g_error_free (error);
-    cc_list_box_adjust_scrolling (GTK_LIST_BOX (self->priv->listbox));
+    cc_list_box_adjust_scrolling (GTK_LIST_BOX (self->listbox));
     return;
   }
 
@@ -127,10 +128,10 @@ cc_sharing_update_networks (CcSharingNetworks *self)
     net->uuid = uuid;
     net->network_name = network_name;
     net->carrier_type = carrier_type;
-    self->priv->networks = g_list_prepend (self->priv->networks, net);
+    self->networks = g_list_prepend (self->networks, net);
   }
-  self->priv->networks = g_list_reverse (self->priv->networks);
-  cc_list_box_adjust_scrolling (GTK_LIST_BOX (self->priv->listbox));
+  self->networks = g_list_reverse (self->networks);
+  cc_list_box_adjust_scrolling (GTK_LIST_BOX (self->listbox));
 
   g_variant_unref (networks);
 }
@@ -147,14 +148,14 @@ cc_sharing_networks_remove_network (GtkWidget         *button,
   row = g_object_get_data (G_OBJECT (button), "row");
   uuid = g_object_get_data (G_OBJECT (row), "uuid");
 
-  ret = gsd_sharing_call_disable_service_sync (self->priv->proxy,
-					       self->priv->service_name,
+  ret = gsd_sharing_call_disable_service_sync (self->proxy,
+					       self->service_name,
 					       uuid,
 					       NULL,
 					       &error);
   if (!ret) {
     g_warning ("Failed to remove service %s: %s",
-	       self->priv->service_name, error->message);
+	       self->service_name, error->message);
     g_error_free (error);
   }
 
@@ -172,14 +173,14 @@ cc_sharing_networks_enable_network (GtkSwitch *widget,
   gboolean ret;
 
   if (state) {
-    ret = gsd_sharing_call_enable_service_sync (self->priv->proxy,
-						self->priv->service_name,
+    ret = gsd_sharing_call_enable_service_sync (self->proxy,
+						self->service_name,
 						NULL,
 						&error);
   } else {
-    ret = gsd_sharing_call_disable_service_sync (self->priv->proxy,
-						 self->priv->service_name,
-						 gsd_sharing_get_current_network (self->priv->proxy),
+    ret = gsd_sharing_call_disable_service_sync (self->proxy,
+						 self->service_name,
+						 gsd_sharing_get_current_network (self->proxy),
 						 NULL,
 						 &error);
   }
@@ -188,7 +189,7 @@ cc_sharing_networks_enable_network (GtkSwitch *widget,
     gtk_switch_set_state (widget, state);
   } else {
     g_warning ("Failed to %s service %s: %s", state ? "enable" : "disable",
-	       self->priv->service_name, error->message);
+	       self->service_name, error->message);
     g_error_free (error);
     g_signal_handlers_block_by_func (widget,
                                      cc_sharing_networks_enable_network, self);
@@ -269,13 +270,13 @@ cc_sharing_networks_new_current_row (CcSharingNetworks *self)
   w = gtk_image_new_from_icon_name ("image-missing", GTK_ICON_SIZE_MENU);
   gtk_widget_set_margin_end (w, 12);
   gtk_container_add (GTK_CONTAINER (box), w);
-  self->priv->current_icon = w;
+  self->current_icon = w;
 
   /* Label */
   w = gtk_label_new ("");
   gtk_container_add (GTK_CONTAINER (box), w);
   gtk_widget_set_margin_end (w, 12);
-  self->priv->current_label = w;
+  self->current_label = w;
 
   w = gtk_switch_new ();
   gtk_widget_set_margin_top (w, 3);
@@ -285,7 +286,7 @@ cc_sharing_networks_new_current_row (CcSharingNetworks *self)
   gtk_box_pack_end (GTK_BOX (box), w, FALSE, FALSE, 0);
   g_signal_connect (G_OBJECT (w), "state-set",
 		    G_CALLBACK (cc_sharing_networks_enable_network), self);
-  self->priv->current_switch = w;
+  self->current_switch = w;
   g_object_set_data (G_OBJECT (w), "row", row);
 
   gtk_widget_show_all (box);
@@ -322,34 +323,34 @@ cc_sharing_update_networks_box (CcSharingNetworks *self)
   const char *current_network;
   GList *children, *l;
 
-  children = gtk_container_get_children (GTK_CONTAINER (self->priv->listbox));
+  children = gtk_container_get_children (GTK_CONTAINER (self->listbox));
   for (l = children; l != NULL; l = l->next) {
     GtkWidget *row = l->data;
 
-    if (row != self->priv->current_row &&
-	row != self->priv->no_network_row)
+    if (row != self->current_row &&
+	row != self->no_network_row)
       gtk_widget_destroy (row);
   }
   g_list_free (children);
 
-  current_network = gsd_sharing_get_current_network (self->priv->proxy);
+  current_network = gsd_sharing_get_current_network (self->proxy);
 
   if (current_network != NULL &&
       !g_str_equal (current_network, "")) {
     gboolean available;
     const char *carrier_type, *icon_name, *current_network_name;
 
-    gtk_widget_show (self->priv->current_row);
+    gtk_widget_show (self->current_row);
     current_visible = TRUE;
 
     /* Network name */
-    g_object_set_data_full (G_OBJECT (self->priv->current_row),
+    g_object_set_data_full (G_OBJECT (self->current_row),
 			    "uuid", g_strdup (current_network), g_free);
-    current_network_name = gsd_sharing_get_current_network_name (self->priv->proxy);
-    gtk_label_set_label (GTK_LABEL (self->priv->current_label), current_network_name);
+    current_network_name = gsd_sharing_get_current_network_name (self->proxy);
+    gtk_label_set_label (GTK_LABEL (self->current_label), current_network_name);
 
     /* Icon */
-    carrier_type = gsd_sharing_get_carrier_type (self->priv->proxy);
+    carrier_type = gsd_sharing_get_carrier_type (self->proxy);
     if (g_strcmp0 (carrier_type, "802-11-wireless") == 0) {
       icon_name = "network-wireless-signal-excellent-symbolic";
     } else if (g_strcmp0 (carrier_type, "802-3-ethernet") == 0) {
@@ -357,26 +358,26 @@ cc_sharing_update_networks_box (CcSharingNetworks *self)
     } else {
       icon_name = "network-wired-symbolic";
     }
-    gtk_image_set_from_icon_name (GTK_IMAGE (self->priv->current_icon), icon_name, GTK_ICON_SIZE_SMALL_TOOLBAR);
+    gtk_image_set_from_icon_name (GTK_IMAGE (self->current_icon), icon_name, GTK_ICON_SIZE_SMALL_TOOLBAR);
 
     /* State */
-    available = gsd_sharing_get_sharing_status (self->priv->proxy) == GSD_SHARING_STATUS_AVAILABLE;
-    gtk_widget_set_sensitive (self->priv->current_switch, available);
+    available = gsd_sharing_get_sharing_status (self->proxy) == GSD_SHARING_STATUS_AVAILABLE;
+    gtk_widget_set_sensitive (self->current_switch, available);
     //FIXME add a subtitle explaining why it's disabled
   } else {
-    gtk_widget_hide (self->priv->current_row);
+    gtk_widget_hide (self->current_row);
     current_visible = FALSE;
   }
 
-  for (l = self->priv->networks; l != NULL; l = l->next) {
+  for (l = self->networks; l != NULL; l = l->next) {
     CcSharingNetwork *net = l->data;
     GtkWidget *row;
 
     if (g_strcmp0 (net->uuid, current_network) == 0) {
-      g_signal_handlers_block_by_func (self->priv->current_switch,
+      g_signal_handlers_block_by_func (self->current_switch,
 				       cc_sharing_networks_enable_network, self);
-      gtk_switch_set_state (GTK_SWITCH (self->priv->current_switch), TRUE);
-      g_signal_handlers_unblock_by_func (self->priv->current_switch,
+      gtk_switch_set_state (GTK_SWITCH (self->current_switch), TRUE);
+      g_signal_handlers_unblock_by_func (self->current_switch,
 					 cc_sharing_networks_enable_network, self);
       continue;
     }
@@ -385,19 +386,19 @@ cc_sharing_update_networks_box (CcSharingNetworks *self)
 				       net->network_name,
 				       net->carrier_type,
 				       self);
-    gtk_list_box_insert (GTK_LIST_BOX (self->priv->listbox), row, -1);
+    gtk_list_box_insert (GTK_LIST_BOX (self->listbox), row, -1);
   }
 
-  if (self->priv->networks == NULL &&
+  if (self->networks == NULL &&
       !current_visible) {
-    gtk_widget_show (self->priv->no_network_row);
+    gtk_widget_show (self->no_network_row);
   } else {
-    gtk_widget_hide (self->priv->no_network_row);
+    gtk_widget_hide (self->no_network_row);
   }
 
   cc_sharing_networks_update_status (self);
 
-  cc_list_box_adjust_scrolling (GTK_LIST_BOX (self->priv->listbox));
+  cc_list_box_adjust_scrolling (GTK_LIST_BOX (self->listbox));
 }
 
 static void
@@ -418,23 +419,23 @@ cc_sharing_networks_constructed (GObject *object)
 
   self = CC_SHARING_NETWORKS (object);
 
-  gtk_list_box_set_header_func (GTK_LIST_BOX (self->priv->listbox),
+  gtk_list_box_set_header_func (GTK_LIST_BOX (self->listbox),
 				cc_list_box_update_header_func, NULL,
 				NULL);
 
-  cc_list_box_setup_scrolling (GTK_LIST_BOX (self->priv->listbox), 3);
+  cc_list_box_setup_scrolling (GTK_LIST_BOX (self->listbox), 3);
 
-  self->priv->current_row = cc_sharing_networks_new_current_row (self);
-  gtk_list_box_insert (GTK_LIST_BOX (self->priv->listbox), self->priv->current_row, -1);
-  g_object_set_data (G_OBJECT (self), "switch", self->priv->current_switch);
+  self->current_row = cc_sharing_networks_new_current_row (self);
+  gtk_list_box_insert (GTK_LIST_BOX (self->listbox), self->current_row, -1);
+  g_object_set_data (G_OBJECT (self), "switch", self->current_switch);
 
-  self->priv->no_network_row = cc_sharing_networks_new_no_network_row (self);
-  gtk_list_box_insert (GTK_LIST_BOX (self->priv->listbox), self->priv->no_network_row, -1);
+  self->no_network_row = cc_sharing_networks_new_no_network_row (self);
+  gtk_list_box_insert (GTK_LIST_BOX (self->listbox), self->no_network_row, -1);
 
   cc_sharing_update_networks (self);
   cc_sharing_update_networks_box (self);
 
-  g_signal_connect (self->priv->proxy, "notify::current-network",
+  g_signal_connect (self->proxy, "notify::current-network",
 		    G_CALLBACK (current_network_changed), self);
 }
 
@@ -442,7 +443,6 @@ static void
 cc_sharing_networks_init (CcSharingNetworks *self)
 {
   gtk_widget_init_template (GTK_WIDGET (self));
-  self->priv = cc_sharing_networks_get_instance_private (self);
 }
 
 GtkWidget *
@@ -470,10 +470,10 @@ cc_sharing_networks_set_property (GObject      *object,
 
   switch (prop_id) {
   case PROP_SERVICE_NAME:
-    self->priv->service_name = g_value_dup_string (value);
+    self->service_name = g_value_dup_string (value);
     break;
   case PROP_PROXY:
-    self->priv->proxy = g_value_dup_object (value);
+    self->proxy = g_value_dup_object (value);
     break;
   default:
     G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -493,7 +493,7 @@ cc_sharing_networks_get_property (GObject      *object,
 
   switch (prop_id) {
   case PROP_STATUS:
-    g_value_set_uint (value, self->priv->status);
+    g_value_set_uint (value, self->status);
     break;
   default:
     G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -511,14 +511,14 @@ cc_sharing_networks_finalize (GObject *object)
 
   self = CC_SHARING_NETWORKS (object);
 
-  g_return_if_fail (self->priv != NULL);
+  g_return_if_fail (self != NULL);
 
-  g_clear_object (&self->priv->proxy);
-  g_clear_pointer (&self->priv->service_name, g_free);
+  g_clear_object (&self->proxy);
+  g_clear_pointer (&self->service_name, g_free);
 
-  if (self->priv->networks != NULL) {
-    g_list_free_full (self->priv->networks, cc_sharing_network_free);
-    self->priv->networks = NULL;
+  if (self->networks != NULL) {
+    g_list_free_full (self->networks, cc_sharing_network_free);
+    self->networks = NULL;
   }
 
   G_OBJECT_CLASS (cc_sharing_networks_parent_class)->finalize (object);
@@ -563,7 +563,7 @@ cc_sharing_networks_class_init (CcSharingNetworksClass *klass)
   gtk_widget_class_set_template_from_resource (widget_class,
                                                "/org/gnome/control-center/sharing/networks.ui");
 
-  gtk_widget_class_bind_template_child_private (widget_class, CcSharingNetworks, listbox);
+  gtk_widget_class_bind_template_child (widget_class, CcSharingNetworks, listbox);
 }
 
 /*
diff --git a/panels/sharing/cc-sharing-networks.h b/panels/sharing/cc-sharing-networks.h
index b1f6c1490..8abe10bf1 100644
--- a/panels/sharing/cc-sharing-networks.h
+++ b/panels/sharing/cc-sharing-networks.h
@@ -24,28 +24,8 @@
 
 G_BEGIN_DECLS
 
-#define CC_TYPE_SHARING_NETWORKS             (cc_sharing_networks_get_type ())
-#define CC_SHARING_NETWORKS(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), CC_TYPE_SHARING_NETWORKS, CcSharingNetworks))
-#define CC_SHARING_NETWORKS_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), CC_TYPE_SHARING_NETWORKS, CcSharingNetworksClass))
-#define CC_IS_SHARING_NETWORKS(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CC_TYPE_SHARING_NETWORKS))
-#define CC_IS_SHARING_NETWORKS_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), CC_TYPE_SHARING_NETWORKS))
-#define CC_SHARING_NETWORKS_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), CC_TYPE_SHARING_NETWORKS, CcSharingNetworksClass))
-
-typedef struct _CcSharingNetworks        CcSharingNetworks;
-typedef struct _CcSharingNetworksPrivate CcSharingNetworksPrivate;
-typedef struct _CcSharingNetworksClass   CcSharingNetworksClass;
-
-struct _CcSharingNetworks
-{
-  GtkGrid parent_instance;
-
-  CcSharingNetworksPrivate *priv;
-};
-
-struct _CcSharingNetworksClass
-{
-  GtkGridClass parent_class;
-};
+#define CC_TYPE_SHARING_NETWORKS (cc_sharing_networks_get_type ())
+G_DECLARE_FINAL_TYPE (CcSharingNetworks, cc_sharing_networks, CC, SHARING_NETWORKS, GtkGrid)
 
 typedef enum {
   CC_SHARING_STATUS_UNSET,
@@ -54,7 +34,6 @@ typedef enum {
   CC_SHARING_STATUS_ACTIVE
 } CcSharingStatus;
 
-GType          cc_sharing_networks_get_type  (void) G_GNUC_CONST;
 GtkWidget    * cc_sharing_networks_new       (GDBusProxy *proxy,
 					      const char *service_name);
 
diff --git a/panels/sharing/cc-sharing-panel.c b/panels/sharing/cc-sharing-panel.c
index 1352f7e8f..c7ea62c1f 100644
--- a/panels/sharing/cc-sharing-panel.c
+++ b/panels/sharing/cc-sharing-panel.c
@@ -38,12 +38,6 @@
 #include <glib/gi18n.h>
 #include <config.h>
 
-CC_PANEL_REGISTER (CcSharingPanel, cc_sharing_panel)
-
-#define PANEL_PRIVATE(o) \
-  (G_TYPE_INSTANCE_GET_PRIVATE ((o), CC_TYPE_SHARING_PANEL, CcSharingPanelPrivate))
-
-
 static void cc_sharing_panel_setup_label_with_hostname (CcSharingPanel *self, GtkWidget *label);
 static GtkWidget *cc_sharing_panel_new_media_sharing_row (const char     *uri_or_path,
                                                           CcSharingPanel *self);
@@ -61,14 +55,16 @@ _gtk_builder_get_widget (GtkBuilder  *builder,
   return w;
 }
 
-#define WID(y) _gtk_builder_get_widget (priv->builder, y)
+#define WID(y) _gtk_builder_get_widget (self->builder, y)
 
 #define VINO_SCHEMA_ID "org.gnome.Vino"
 #define FILE_SHARING_SCHEMA_ID "org.gnome.desktop.file-sharing"
 #define GNOME_REMOTE_DESKTOP_SCHEMA_ID "org.gnome.desktop.remote-desktop"
 
-struct _CcSharingPanelPrivate
+struct _CcSharingPanel
 {
+  CcPanel parent_instance;
+
   GtkBuilder *builder;
 
   GtkWidget *master_switch;
@@ -91,6 +87,8 @@ struct _CcSharingPanelPrivate
   guint remote_desktop_name_watch;
 };
 
+CC_PANEL_REGISTER (CcSharingPanel, cc_sharing_panel)
+
 #define OFF_IF_VISIBLE(x) { if (gtk_widget_is_visible(x) && gtk_widget_is_sensitive(x)) gtk_switch_set_active (GTK_SWITCH(x), FALSE); }
 
 static void
@@ -98,7 +96,6 @@ cc_sharing_panel_master_switch_notify (GtkSwitch      *gtkswitch,
                                        GParamSpec     *pspec,
                                        CcSharingPanel *self)
 {
-  CcSharingPanelPrivate *priv = self->priv;
   gboolean active;
 
   active = gtk_switch_get_active (gtkswitch);
@@ -106,9 +103,9 @@ cc_sharing_panel_master_switch_notify (GtkSwitch      *gtkswitch,
   if (!active)
     {
       /* disable all services if the master switch is not active */
-      OFF_IF_VISIBLE(priv->media_sharing_switch);
-      OFF_IF_VISIBLE(priv->personal_file_sharing_switch);
-      OFF_IF_VISIBLE(priv->screen_sharing_switch);
+      OFF_IF_VISIBLE(self->media_sharing_switch);
+      OFF_IF_VISIBLE(self->personal_file_sharing_switch);
+      OFF_IF_VISIBLE(self->screen_sharing_switch);
 
       gtk_switch_set_active (GTK_SWITCH (WID ("remote-login-switch")), FALSE);
     }
@@ -119,65 +116,65 @@ cc_sharing_panel_master_switch_notify (GtkSwitch      *gtkswitch,
 static void
 cc_sharing_panel_constructed (GObject *object)
 {
-  CcSharingPanelPrivate *priv = CC_SHARING_PANEL (object)->priv;
+  CcSharingPanel *self = CC_SHARING_PANEL (object);
 
   G_OBJECT_CLASS (cc_sharing_panel_parent_class)->constructed (object);
 
   /* add the master switch */
   cc_shell_embed_widget_in_header (cc_panel_get_shell (CC_PANEL (object)),
-                                   gtk_widget_get_parent (priv->master_switch));
+                                   gtk_widget_get_parent (self->master_switch));
 }
 
 static void
 cc_sharing_panel_dispose (GObject *object)
 {
-  CcSharingPanelPrivate *priv = CC_SHARING_PANEL (object)->priv;
+  CcSharingPanel *self = CC_SHARING_PANEL (object);
 
-  if (priv->remote_desktop_name_watch)
-    g_bus_unwatch_name (priv->remote_desktop_name_watch);
-  priv->remote_desktop_name_watch = 0;
+  if (self->remote_desktop_name_watch)
+    g_bus_unwatch_name (self->remote_desktop_name_watch);
+  self->remote_desktop_name_watch = 0;
 
-  g_clear_object (&priv->builder);
+  g_clear_object (&self->builder);
 
-  if (priv->media_sharing_dialog)
+  if (self->media_sharing_dialog)
     {
-      gtk_widget_destroy (priv->media_sharing_dialog);
-      priv->media_sharing_dialog = NULL;
+      gtk_widget_destroy (self->media_sharing_dialog);
+      self->media_sharing_dialog = NULL;
     }
 
-  if (priv->personal_file_sharing_dialog)
+  if (self->personal_file_sharing_dialog)
     {
-      gtk_widget_destroy (priv->personal_file_sharing_dialog);
-      priv->personal_file_sharing_dialog = NULL;
+      gtk_widget_destroy (self->personal_file_sharing_dialog);
+      self->personal_file_sharing_dialog = NULL;
     }
 
-  if (priv->remote_login_cancellable)
+  if (self->remote_login_cancellable)
     {
-      g_cancellable_cancel (priv->remote_login_cancellable);
-      g_clear_object (&priv->remote_login_cancellable);
+      g_cancellable_cancel (self->remote_login_cancellable);
+      g_clear_object (&self->remote_login_cancellable);
     }
 
-  if (priv->hostname_cancellable)
+  if (self->hostname_cancellable)
     {
-      g_cancellable_cancel (priv->hostname_cancellable);
-      g_clear_object (&priv->hostname_cancellable);
+      g_cancellable_cancel (self->hostname_cancellable);
+      g_clear_object (&self->hostname_cancellable);
     }
 
-  if (priv->remote_login_dialog)
+  if (self->remote_login_dialog)
     {
-      gtk_widget_destroy (priv->remote_login_dialog);
-      priv->remote_login_dialog = NULL;
+      gtk_widget_destroy (self->remote_login_dialog);
+      self->remote_login_dialog = NULL;
     }
 
-  if (priv->screen_sharing_dialog)
+  if (self->screen_sharing_dialog)
     {
-      gtk_widget_destroy (priv->screen_sharing_dialog);
-      priv->screen_sharing_dialog = NULL;
+      gtk_widget_destroy (self->screen_sharing_dialog);
+      self->screen_sharing_dialog = NULL;
     }
 
-  g_cancellable_cancel (priv->sharing_proxy_cancellable);
-  g_clear_object (&priv->sharing_proxy_cancellable);
-  g_clear_object (&priv->sharing_proxy);
+  g_cancellable_cancel (self->sharing_proxy_cancellable);
+  g_clear_object (&self->sharing_proxy_cancellable);
+  g_clear_object (&self->sharing_proxy);
 
   G_OBJECT_CLASS (cc_sharing_panel_parent_class)->dispose (object);
 }
@@ -194,8 +191,6 @@ cc_sharing_panel_class_init (CcSharingPanelClass *klass)
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
   CcPanelClass *panel_class = CC_PANEL_CLASS (klass);
 
-  g_type_class_add_private (klass, sizeof (CcSharingPanelPrivate));
-
   object_class->constructed = cc_sharing_panel_constructed;
   object_class->dispose = cc_sharing_panel_dispose;
 
@@ -208,7 +203,6 @@ static void
 cc_sharing_panel_run_dialog (CcSharingPanel *self,
                              const gchar    *dialog_name)
 {
-  CcSharingPanelPrivate *priv = self->priv;
   GtkWidget *dialog, *parent;
 
   dialog = WID (dialog_name);
@@ -278,7 +272,7 @@ cc_sharing_panel_switch_to_label_transform_func (GBinding       *binding,
 
   /* ensure the master switch is active if one of the services is active */
   if (active)
-    gtk_switch_set_active (GTK_SWITCH (self->priv->master_switch), TRUE);
+    gtk_switch_set_active (GTK_SWITCH (self->master_switch), TRUE);
 
   return TRUE;
 }
@@ -315,7 +309,7 @@ cc_sharing_panel_networks_to_label_transform_func (GBinding       *binding,
 
   /* ensure the master switch is active if one of the services is active */
   if (status != CC_SHARING_STATUS_OFF)
-    gtk_switch_set_active (GTK_SWITCH (self->priv->master_switch), TRUE);
+    gtk_switch_set_active (GTK_SWITCH (self->master_switch), TRUE);
 
   return TRUE;
 }
@@ -369,7 +363,6 @@ cc_sharing_panel_add_folder (GtkListBox     *box,
                              GtkListBoxRow  *row,
                              CcSharingPanel *self)
 {
-  CcSharingPanelPrivate *priv = self->priv;
   GtkWidget *dialog;
   gchar *folder = NULL;
   gboolean matching = FALSE;
@@ -433,7 +426,6 @@ static void
 cc_sharing_panel_remove_folder (GtkButton      *button,
                                 CcSharingPanel *self)
 {
-  CcSharingPanelPrivate *priv = self->priv;
   GtkWidget *row;
 
   row = g_object_get_data (G_OBJECT (button), "row");
@@ -446,7 +438,6 @@ cc_sharing_panel_media_sharing_dialog_response (GtkDialog      *dialog,
                                                 gint            reponse_id,
                                                 CcSharingPanel *self)
 {
-  CcSharingPanelPrivate *priv = self->priv;
   GPtrArray *folders;
   GtkWidget *box;
   GList *rows, *l;
@@ -597,7 +588,6 @@ cc_sharing_panel_new_add_media_sharing_row (CcSharingPanel *self)
 static void
 cc_sharing_panel_setup_media_sharing_dialog (CcSharingPanel *self)
 {
-  CcSharingPanelPrivate *priv = self->priv;
   gchar **folders, **list;
   GtkWidget *box, *networks, *grid, *w;
   char *path;
@@ -643,14 +633,14 @@ cc_sharing_panel_setup_media_sharing_dialog (CcSharingPanel *self)
 
   g_strfreev (folders);
 
-  networks = cc_sharing_networks_new (self->priv->sharing_proxy, "rygel");
+  networks = cc_sharing_networks_new (self->sharing_proxy, "rygel");
   grid = WID ("grid4");
   gtk_grid_attach (GTK_GRID (grid), networks, 0, 4, 2, 1);
   gtk_widget_show (networks);
 
   w = cc_sharing_switch_new (networks);
   gtk_header_bar_pack_start (GTK_HEADER_BAR (WID ("media-sharing-headerbar")), w);
-  self->priv->media_sharing_switch = w;
+  self->media_sharing_switch = w;
 
   cc_sharing_panel_bind_networks_to_label (self, networks,
                                            WID ("media-sharing-status-label"));
@@ -686,7 +676,6 @@ cc_sharing_panel_setup_label (CcSharingPanel *self,
                               GtkWidget      *label,
                               const gchar    *hostname)
 {
-  CcSharingPanelPrivate *priv = self->priv;
   gchar *text;
 
   if (label == WID ("personal-file-sharing-label"))
@@ -729,7 +718,7 @@ cc_sharing_panel_get_host_name_fqdn_done (GDBusConnection *connection,
         {
           gchar *hostname;
 
-          hostname = cc_hostname_entry_get_hostname (CC_HOSTNAME_ENTRY (data->panel->priv->hostname_entry));
+          hostname = cc_hostname_entry_get_hostname (CC_HOSTNAME_ENTRY (data->panel->hostname_entry));
 
           cc_sharing_panel_setup_label (data->panel, data->label, hostname);
 
@@ -768,7 +757,7 @@ cc_sharing_panel_bus_ready (GObject         *object,
         {
           gchar *hostname;
 
-          hostname = cc_hostname_entry_get_hostname (CC_HOSTNAME_ENTRY (data->panel->priv->hostname_entry));
+          hostname = cc_hostname_entry_get_hostname (CC_HOSTNAME_ENTRY (data->panel->hostname_entry));
 
           cc_sharing_panel_setup_label (data->panel, data->label, hostname);
 
@@ -789,7 +778,7 @@ cc_sharing_panel_bus_ready (GObject         *object,
                           (GVariantType*)"(s)",
                           G_DBUS_CALL_FLAGS_NONE,
                           -1,
-                          data->panel->priv->hostname_cancellable,
+                          data->panel->hostname_cancellable,
                           (GAsyncReadyCallback) cc_sharing_panel_get_host_name_fqdn_done,
                           data);
 }
@@ -828,7 +817,7 @@ cc_sharing_panel_setup_label_with_hostname (CcSharingPanel *self,
   get_hostname_data->panel = self;
   get_hostname_data->label = label;
   g_bus_get (G_BUS_TYPE_SYSTEM,
-             self->priv->hostname_cancellable,
+             self->hostname_cancellable,
              (GAsyncReadyCallback) cc_sharing_panel_bus_ready,
              get_hostname_data);
 }
@@ -866,7 +855,6 @@ file_sharing_password_changed (GtkEntry *entry)
 static void
 cc_sharing_panel_setup_personal_file_sharing_dialog (CcSharingPanel *self)
 {
-  CcSharingPanelPrivate *priv = self->priv;
   GSettings *settings;
   GtkWidget *networks, *grid, *w;
 
@@ -894,14 +882,14 @@ cc_sharing_panel_setup_personal_file_sharing_dialog (CcSharingPanel *self)
                     "notify::text", G_CALLBACK (file_sharing_password_changed),
                     NULL);
 
-  networks = cc_sharing_networks_new (self->priv->sharing_proxy, "gnome-user-share-webdav");
+  networks = cc_sharing_networks_new (self->sharing_proxy, "gnome-user-share-webdav");
   grid = WID ("grid2");
   gtk_grid_attach (GTK_GRID (grid), networks, 0, 3, 2, 1);
   gtk_widget_show (networks);
 
   w = cc_sharing_switch_new (networks);
   gtk_header_bar_pack_start (GTK_HEADER_BAR (WID ("personal-file-sharing-headerbar")), w);
-  self->priv->personal_file_sharing_switch = w;
+  self->personal_file_sharing_switch = w;
 
   cc_sharing_panel_bind_networks_to_label (self,
                                            networks,
@@ -913,14 +901,12 @@ remote_login_switch_activate (GtkSwitch      *remote_login_switch,
                               GParamSpec     *pspec,
                               CcSharingPanel *self)
 {
-  cc_remote_login_set_enabled (self->priv->remote_login_cancellable, remote_login_switch);
+  cc_remote_login_set_enabled (self->remote_login_cancellable, remote_login_switch);
 }
 
 static void
 cc_sharing_panel_setup_remote_login_dialog (CcSharingPanel *self)
 {
-  CcSharingPanelPrivate *priv = self->priv;
-
   cc_sharing_panel_bind_switch_to_label (self, WID ("remote-login-switch"),
                                          WID ("remote-login-status-label"));
 
@@ -930,7 +916,7 @@ cc_sharing_panel_setup_remote_login_dialog (CcSharingPanel *self)
                     G_CALLBACK (remote_login_switch_activate), self);
   gtk_widget_set_sensitive (WID ("remote-login-switch"), FALSE);
 
-  cc_remote_login_get_enabled (self->priv->remote_login_cancellable,
+  cc_remote_login_get_enabled (self->remote_login_cancellable,
                                GTK_SWITCH (WID ("remote-login-switch")),
                                WID ("remote-login-button"));
 }
@@ -957,8 +943,6 @@ cc_sharing_panel_check_schema_available (CcSharingPanel *self,
 static void
 screen_sharing_show_cb (GtkWidget *widget, CcSharingPanel *self)
 {
-  CcSharingPanelPrivate *priv = self->priv;
-
   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (WID ("show-password-checkbutton")),
                                 FALSE);
 }
@@ -969,7 +953,6 @@ screen_sharing_hide_cb (GtkWidget *widget, CcSharingPanel *self)
   GtkToggleButton *ac_radio;
   GtkEntry    *pw_entry;
   const gchar *password;
-  CcSharingPanelPrivate *priv = self->priv;
 
   ac_radio = GTK_TOGGLE_BUTTON (WID ("approve-connections-radiobutton"));
   pw_entry = GTK_ENTRY (WID ("remote-control-password-entry"));
@@ -1014,7 +997,6 @@ screen_sharing_password_insert_text_cb (GtkEditable *editable,
 static void
 cc_sharing_panel_setup_screen_sharing_dialog_vino (CcSharingPanel *self)
 {
-  CcSharingPanelPrivate *priv = self->priv;
   GSettings *settings;
   GtkWidget *networks, *box, *w;
 
@@ -1050,24 +1032,24 @@ cc_sharing_panel_setup_screen_sharing_dialog_vino (CcSharingPanel *self)
                           G_BINDING_SYNC_CREATE);
 
   /* make sure the password entry is hidden by default */
-  g_signal_connect (priv->screen_sharing_dialog, "show",
+  g_signal_connect (self->screen_sharing_dialog, "show",
                     G_CALLBACK (screen_sharing_show_cb), self);
 
-  g_signal_connect (priv->screen_sharing_dialog, "hide",
+  g_signal_connect (self->screen_sharing_dialog, "hide",
                     G_CALLBACK (screen_sharing_hide_cb), self);
 
   /* accept at most 8 bytes in password entry */
   g_signal_connect (WID ("remote-control-password-entry"), "insert-text",
                     G_CALLBACK (screen_sharing_password_insert_text_cb), self);
 
-  networks = cc_sharing_networks_new (self->priv->sharing_proxy, "vino-server");
+  networks = cc_sharing_networks_new (self->sharing_proxy, "vino-server");
   box = WID ("remote-control-box");
   gtk_box_pack_end (GTK_BOX (box), networks, TRUE, TRUE, 0);
   gtk_widget_show (networks);
 
   w = cc_sharing_switch_new (networks);
   gtk_header_bar_pack_start (GTK_HEADER_BAR (WID ("screen-sharing-headerbar")), w);
-  self->priv->screen_sharing_switch = w;
+  self->screen_sharing_switch = w;
 
   cc_sharing_panel_bind_networks_to_label (self, networks,
                                            WID ("screen-sharing-status-label"));
@@ -1076,17 +1058,16 @@ cc_sharing_panel_setup_screen_sharing_dialog_vino (CcSharingPanel *self)
 static void
 cc_sharing_panel_setup_screen_sharing_dialog_gnome_remote_desktop (CcSharingPanel *self)
 {
-  CcSharingPanelPrivate *priv = self->priv;
   GtkWidget *networks, *w;
 
-  networks = cc_sharing_networks_new (self->priv->sharing_proxy, "gnome-remote-desktop");
+  networks = cc_sharing_networks_new (self->sharing_proxy, "gnome-remote-desktop");
   gtk_widget_hide (WID ("remote-control-box"));
   gtk_grid_attach (GTK_GRID (WID ("grid3")), networks, 0, 1, 2, 1);
   gtk_widget_show (networks);
 
   w = cc_sharing_switch_new (networks);
   gtk_header_bar_pack_start (GTK_HEADER_BAR (WID ("screen-sharing-headerbar")), w);
-  self->priv->screen_sharing_switch = w;
+  self->screen_sharing_switch = w;
 
   cc_sharing_panel_bind_networks_to_label (self, networks,
                                            WID ("screen-sharing-status-label"));
@@ -1099,10 +1080,9 @@ remote_desktop_name_appeared (GDBusConnection *connection,
                               gpointer         user_data)
 {
   CcSharingPanel *self = CC_SHARING_PANEL (user_data);
-  CcSharingPanelPrivate *priv = self->priv;
 
-  g_bus_unwatch_name (priv->remote_desktop_name_watch);
-  priv->remote_desktop_name_watch = 0;
+  g_bus_unwatch_name (self->remote_desktop_name_watch);
+  self->remote_desktop_name_watch = 0;
 
   cc_sharing_panel_setup_screen_sharing_dialog_gnome_remote_desktop (self);
   gtk_widget_show (WID ("screen-sharing-button"));
@@ -1111,12 +1091,10 @@ remote_desktop_name_appeared (GDBusConnection *connection,
 static void
 check_remote_desktop_available (CcSharingPanel *self)
 {
-  CcSharingPanelPrivate *priv = self->priv;
-
   if (!cc_sharing_panel_check_schema_available (self, GNOME_REMOTE_DESKTOP_SCHEMA_ID))
     return;
 
-  priv->remote_desktop_name_watch = g_bus_watch_name (G_BUS_TYPE_SESSION,
+  self->remote_desktop_name_watch = g_bus_watch_name (G_BUS_TYPE_SESSION,
                                                       "org.gnome.Mutter.RemoteDesktop",
                                                       G_BUS_NAME_WATCHER_FLAGS_NONE,
                                                       remote_desktop_name_appeared,
@@ -1131,7 +1109,6 @@ sharing_proxy_ready (GObject      *source,
                      gpointer      user_data)
 {
   CcSharingPanel *self;
-  CcSharingPanelPrivate *priv;
   GDBusProxy *proxy;
   GError *error = NULL;
 
@@ -1144,8 +1121,7 @@ sharing_proxy_ready (GObject      *source,
   }
 
   self = CC_SHARING_PANEL (user_data);
-  priv = self->priv;
-  priv->sharing_proxy = proxy;
+  self->sharing_proxy = proxy;
 
   /* media sharing */
   cc_sharing_panel_setup_media_sharing_dialog (self);
@@ -1177,7 +1153,6 @@ sharing_proxy_ready (GObject      *source,
 static void
 cc_sharing_panel_init (CcSharingPanel *self)
 {
-  CcSharingPanelPrivate *priv = self->priv = PANEL_PRIVATE (self);
   GtkWidget *box;
   GError *err = NULL;
   gchar *objects[] = {
@@ -1190,37 +1165,37 @@ cc_sharing_panel_init (CcSharingPanel *self)
 
   g_resources_register (cc_sharing_get_resource ());
 
-  priv->builder = gtk_builder_new ();
+  self->builder = gtk_builder_new ();
 
-  gtk_builder_add_objects_from_resource (priv->builder,
+  gtk_builder_add_objects_from_resource (self->builder,
                                          "/org/gnome/control-center/sharing/sharing.ui",
                                          objects, &err);
 
   if (err)
     g_error ("Error loading CcSharingPanel user interface: %s", err->message);
 
-  priv->hostname_entry = WID ("hostname-entry");
+  self->hostname_entry = WID ("hostname-entry");
 
   gtk_container_add (GTK_CONTAINER (self), WID ("sharing-panel"));
 
   g_signal_connect (WID ("main-list-box"), "row-activated",
                     G_CALLBACK (cc_sharing_panel_main_list_box_row_activated), self);
 
-  priv->hostname_cancellable = g_cancellable_new ();
+  self->hostname_cancellable = g_cancellable_new ();
 
-  priv->media_sharing_dialog = WID ("media-sharing-dialog");
-  priv->personal_file_sharing_dialog = WID ("personal-file-sharing-dialog");
-  priv->remote_login_dialog = WID ("remote-login-dialog");
-  priv->remote_login_cancellable = g_cancellable_new ();
-  priv->screen_sharing_dialog = WID ("screen-sharing-dialog");
+  self->media_sharing_dialog = WID ("media-sharing-dialog");
+  self->personal_file_sharing_dialog = WID ("personal-file-sharing-dialog");
+  self->remote_login_dialog = WID ("remote-login-dialog");
+  self->remote_login_cancellable = g_cancellable_new ();
+  self->screen_sharing_dialog = WID ("screen-sharing-dialog");
 
-  g_signal_connect (priv->media_sharing_dialog, "response",
+  g_signal_connect (self->media_sharing_dialog, "response",
                     G_CALLBACK (gtk_widget_hide), NULL);
-  g_signal_connect (priv->personal_file_sharing_dialog, "response",
+  g_signal_connect (self->personal_file_sharing_dialog, "response",
                     G_CALLBACK (gtk_widget_hide), NULL);
-  g_signal_connect (priv->remote_login_dialog, "response",
+  g_signal_connect (self->remote_login_dialog, "response",
                     G_CALLBACK (gtk_widget_hide), NULL);
-  g_signal_connect (priv->screen_sharing_dialog, "response",
+  g_signal_connect (self->screen_sharing_dialog, "response",
                     G_CALLBACK (gtk_widget_hide), NULL);
 
   gtk_list_box_set_activate_on_single_click (GTK_LIST_BOX (WID ("main-list-box")),
@@ -1232,24 +1207,24 @@ cc_sharing_panel_init (CcSharingPanel *self)
   /* create the master switch */
   box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
 
-  priv->master_switch = gtk_switch_new ();
-  atk_object_set_name (ATK_OBJECT (gtk_widget_get_accessible (priv->master_switch)), _("Sharing"));
-  gtk_widget_set_valign (priv->master_switch, GTK_ALIGN_CENTER);
-  gtk_box_pack_start (GTK_BOX (box), priv->master_switch, FALSE, FALSE, 4);
+  self->master_switch = gtk_switch_new ();
+  atk_object_set_name (ATK_OBJECT (gtk_widget_get_accessible (self->master_switch)), _("Sharing"));
+  gtk_widget_set_valign (self->master_switch, GTK_ALIGN_CENTER);
+  gtk_box_pack_start (GTK_BOX (box), self->master_switch, FALSE, FALSE, 4);
   gtk_widget_show_all (box);
 
   /* start the panel in the disabled state */
-  gtk_switch_set_active (GTK_SWITCH (priv->master_switch), FALSE);
+  gtk_switch_set_active (GTK_SWITCH (self->master_switch), FALSE);
   gtk_widget_set_sensitive (WID ("main-list-box"), FALSE);
-  g_signal_connect (priv->master_switch, "notify::active",
+  g_signal_connect (self->master_switch, "notify::active",
                     G_CALLBACK (cc_sharing_panel_master_switch_notify), self);
 
-  priv->sharing_proxy_cancellable = g_cancellable_new ();
+  self->sharing_proxy_cancellable = g_cancellable_new ();
   gsd_sharing_proxy_new_for_bus (G_BUS_TYPE_SESSION,
                                  G_DBUS_PROXY_FLAGS_NONE,
                                  "org.gnome.SettingsDaemon.Sharing",
                                  "/org/gnome/SettingsDaemon/Sharing",
-                                 priv->sharing_proxy_cancellable,
+                                 self->sharing_proxy_cancellable,
                                  sharing_proxy_ready,
                                  self);
 
diff --git a/panels/sharing/cc-sharing-panel.h b/panels/sharing/cc-sharing-panel.h
index 9004fd8e5..17f84dbde 100644
--- a/panels/sharing/cc-sharing-panel.h
+++ b/panels/sharing/cc-sharing-panel.h
@@ -26,45 +26,8 @@
 
 G_BEGIN_DECLS
 
-#define CC_TYPE_SHARING_PANEL cc_sharing_panel_get_type()
-
-#define CC_SHARING_PANEL(obj) \
-  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
-  CC_TYPE_SHARING_PANEL, CcSharingPanel))
-
-#define CC_SHARING_PANEL_CLASS(klass) \
-  (G_TYPE_CHECK_CLASS_CAST ((klass), \
-  CC_TYPE_SHARING_PANEL, CcSharingPanelClass))
-
-#define CC_SHARING_IS_PANEL(obj) \
-  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
-  CC_TYPE_SHARING_PANEL))
-
-#define CC_SHARING_IS_PANEL_CLASS(klass) \
-  (G_TYPE_CHECK_CLASS_TYPE ((klass), \
-  CC_TYPE_SHARING_PANEL))
-
-#define CC_SHARING_PANEL_GET_CLASS(obj) \
-  (G_TYPE_INSTANCE_GET_CLASS ((obj), \
-  CC_TYPE_SHARING_PANEL, CcSharingPanelClass))
-
-typedef struct _CcSharingPanel CcSharingPanel;
-typedef struct _CcSharingPanelClass CcSharingPanelClass;
-typedef struct _CcSharingPanelPrivate CcSharingPanelPrivate;
-
-struct _CcSharingPanel
-{
-  CcPanel parent;
-
-  CcSharingPanelPrivate *priv;
-};
-
-struct _CcSharingPanelClass
-{
-  CcPanelClass parent_class;
-};
-
-GType cc_sharing_panel_get_type (void) G_GNUC_CONST;
+#define CC_TYPE_SHARING_PANEL (cc_sharing_panel_get_type ())
+G_DECLARE_FINAL_TYPE (CcSharingPanel, cc_sharing_panel, CC, SHARING_PANEL, CcPanel)
 
 CcSharingPanel *cc_sharing_panel_new (void);
 
diff --git a/panels/sharing/cc-sharing-switch.c b/panels/sharing/cc-sharing-switch.c
index 56e5c2df5..4c752148b 100644
--- a/panels/sharing/cc-sharing-switch.c
+++ b/panels/sharing/cc-sharing-switch.c
@@ -23,12 +23,13 @@
 #include <gio/gio.h>
 #include "cc-sharing-switch.h"
 
-struct _CcSharingSwitchPrivate {
+struct _CcSharingSwitch {
+  GtkSwitch  parent_instance;
+
   GtkWidget *widget;
 };
 
-G_DEFINE_TYPE_WITH_CODE (CcSharingSwitch, cc_sharing_switch, GTK_TYPE_SWITCH,
-			 G_ADD_PRIVATE (CcSharingSwitch))
+G_DEFINE_TYPE (CcSharingSwitch, cc_sharing_switch, GTK_TYPE_SWITCH)
 
 enum {
   PROP_0,
@@ -49,7 +50,7 @@ cc_sharing_switch_constructed (GObject *object)
 
   self = CC_SHARING_SWITCH (object);
 
-  other_sw = g_object_get_data (G_OBJECT (self->priv->widget), "switch");
+  other_sw = g_object_get_data (G_OBJECT (self->widget), "switch");
 
   g_object_bind_property (other_sw, "visible", self, "visible", G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL);
   g_object_bind_property (other_sw, "state", self, "state", G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL);
@@ -62,7 +63,6 @@ cc_sharing_switch_constructed (GObject *object)
 static void
 cc_sharing_switch_init (CcSharingSwitch *self)
 {
-  self->priv = cc_sharing_switch_get_instance_private (self);
 }
 
 GtkWidget *
@@ -87,7 +87,7 @@ cc_sharing_switch_set_property (GObject      *object,
 
   switch (prop_id) {
   case PROP_WIDGET:
-    self->priv->widget = g_value_dup_object (value);
+    self->widget = g_value_dup_object (value);
     break;
   default:
     G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
@@ -105,9 +105,9 @@ cc_sharing_switch_finalize (GObject *object)
 
   self = CC_SHARING_SWITCH (object);
 
-  g_return_if_fail (self->priv != NULL);
+  g_return_if_fail (self != NULL);
 
-  g_clear_object (&self->priv->widget);
+  g_clear_object (&self->widget);
 
   G_OBJECT_CLASS (cc_sharing_switch_parent_class)->finalize (object);
 }
diff --git a/panels/sharing/cc-sharing-switch.h b/panels/sharing/cc-sharing-switch.h
index 7fcc5e4ab..9a42f0ffc 100644
--- a/panels/sharing/cc-sharing-switch.h
+++ b/panels/sharing/cc-sharing-switch.h
@@ -24,30 +24,9 @@
 
 G_BEGIN_DECLS
 
-#define CC_TYPE_SHARING_SWITCH             (cc_sharing_switch_get_type ())
-#define CC_SHARING_SWITCH(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), CC_TYPE_SHARING_SWITCH, CcSharingSwitch))
-#define CC_SHARING_SWITCH_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), CC_TYPE_SHARING_SWITCH, CcSharingSwitchClass))
-#define CC_IS_SHARING_SWITCH(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CC_TYPE_SHARING_SWITCH))
-#define CC_IS_SHARING_SWITCH_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), CC_TYPE_SHARING_SWITCH))
-#define CC_SHARING_SWITCH_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), CC_TYPE_SHARING_SWITCH, CcSharingSwitchClass))
+#define CC_TYPE_SHARING_SWITCH (cc_sharing_switch_get_type ())
+G_DECLARE_FINAL_TYPE (CcSharingSwitch, cc_sharing_switch, CC, SHARING_SWITCH, GtkSwitch)
 
-typedef struct _CcSharingSwitch        CcSharingSwitch;
-typedef struct _CcSharingSwitchPrivate CcSharingSwitchPrivate;
-typedef struct _CcSharingSwitchClass   CcSharingSwitchClass;
-
-struct _CcSharingSwitch
-{
-  GtkSwitch parent_instance;
-
-  CcSharingSwitchPrivate *priv;
-};
-
-struct _CcSharingSwitchClass
-{
-  GtkSwitchClass parent_class;
-};
-
-GType          cc_sharing_switch_get_type  (void) G_GNUC_CONST;
 GtkWidget    * cc_sharing_switch_new       (GtkWidget *widget);
 
 G_END_DECLS