[gnome-online-accounts/wip/rishi/gobject-modernize: 1/5] alarm: Drop the priv pointer

[Debarshi Ray <debarshir src gnome org>]

commit f39d25742162c8ada63222aa620e7ae50e40805f
Author: Debarshi Ray <debarshir gnome org>
Date:   Thu Nov 28 13:59:39 2019 +0100

    alarm: Drop the priv pointer
    
    The current GObject recommendation is to use the generated
    get_instance_private function instead of a separate priv pointer in the
    instance struct. This saves one pointer per class in the hierarchy
    multiplied by the number of instances of the type, and the function is
    fast enough because it only does pointer arithmetic.
    
    https://gitlab.gnome.org/GNOME/gnome-online-accounts/merge_requests/36

 src/goaidentity/goaalarm.c | 148 ++++++++++++++++++++++++++++-----------------
 src/goaidentity/goaalarm.h |   2 -
 2 files changed, 94 insertions(+), 56 deletions(-)
---
diff --git a/src/goaidentity/goaalarm.c b/src/goaidentity/goaalarm.c
index d64346b4..61a4c146 100644
--- a/src/goaidentity/goaalarm.c
+++ b/src/goaidentity/goaalarm.c
@@ -79,13 +79,16 @@ static void
 goa_alarm_dispose (GObject *object)
 {
   GoaAlarm *self = GOA_ALARM (object);
+  GoaAlarmPrivate *priv;
 
-  g_clear_object (&self->priv->stream);
-  g_clear_pointer (&self->priv->immediate_wakeup_source, g_source_destroy);
-  g_clear_pointer (&self->priv->scheduled_wakeup_source, g_source_destroy);
-  g_clear_pointer (&self->priv->context, g_main_context_unref);
-  g_clear_pointer (&self->priv->time, g_date_time_unref);
-  g_clear_pointer (&self->priv->previous_wakeup_time, g_date_time_unref);
+  priv = goa_alarm_get_instance_private (self);
+
+  g_clear_object (&priv->stream);
+  g_clear_pointer (&priv->immediate_wakeup_source, g_source_destroy);
+  g_clear_pointer (&priv->scheduled_wakeup_source, g_source_destroy);
+  g_clear_pointer (&priv->context, g_main_context_unref);
+  g_clear_pointer (&priv->time, g_date_time_unref);
+  g_clear_pointer (&priv->previous_wakeup_time, g_date_time_unref);
 
   G_OBJECT_CLASS (goa_alarm_parent_class)->dispose (object);
 }
@@ -94,8 +97,11 @@ static void
 goa_alarm_finalize (GObject *object)
 {
   GoaAlarm *self = GOA_ALARM (object);
+  GoaAlarmPrivate *priv;
+
+  priv = goa_alarm_get_instance_private (self);
 
-  g_rec_mutex_clear (&self->priv->lock);
+  g_rec_mutex_clear (&priv->lock);
 
   G_OBJECT_CLASS (goa_alarm_parent_class)->finalize (object);
 }
@@ -128,11 +134,14 @@ goa_alarm_get_property (GObject    *object,
                         GParamSpec *param_spec)
 {
   GoaAlarm *self = GOA_ALARM (object);
+  GoaAlarmPrivate *priv;
+
+  priv = goa_alarm_get_instance_private (self);
 
   switch (property_id)
     {
     case PROP_TIME:
-      g_value_set_boxed (value, self->priv->time);
+      g_value_set_boxed (value, priv->time);
       break;
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, param_spec);
@@ -174,8 +183,10 @@ goa_alarm_class_init (GoaAlarmClass *klass)
 static void
 goa_alarm_init (GoaAlarm *self)
 {
-  self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GOA_TYPE_ALARM, GoaAlarmPrivate);
-  g_rec_mutex_init (&self->priv->lock);
+  GoaAlarmPrivate *priv;
+
+  priv = goa_alarm_get_instance_private (self);
+  g_rec_mutex_init (&priv->lock);
 }
 
 static void
@@ -193,16 +204,19 @@ rearm_alarm (GoaAlarm *self)
 static void
 fire_or_rearm_alarm (GoaAlarm *self)
 {
+  GoaAlarmPrivate *priv;
   GTimeSpan time_until_fire;
   GTimeSpan previous_time_until_fire;
   GDateTime *now;
 
+  priv = goa_alarm_get_instance_private (self);
+
   now = g_date_time_new_now_local ();
-  time_until_fire = g_date_time_difference (self->priv->time, now);
+  time_until_fire = g_date_time_difference (priv->time, now);
 
-  if (self->priv->previous_wakeup_time == NULL)
+  if (priv->previous_wakeup_time == NULL)
     {
-      self->priv->previous_wakeup_time = now;
+      priv->previous_wakeup_time = now;
 
       /* If, according to the time, we're past when we should have fired,
        * then fire the alarm.
@@ -212,12 +226,10 @@ fire_or_rearm_alarm (GoaAlarm *self)
     }
   else
     {
-      previous_time_until_fire =
-          g_date_time_difference (self->priv->time,
-                                  self->priv->previous_wakeup_time);
+      previous_time_until_fire = g_date_time_difference (priv->time, priv->previous_wakeup_time);
 
-      g_date_time_unref (self->priv->previous_wakeup_time);
-      self->priv->previous_wakeup_time = now;
+      g_date_time_unref (priv->previous_wakeup_time);
+      priv->previous_wakeup_time = now;
 
       /* If, according to the time, we're past when we should have fired,
        * and this is the first wakeup where that's been true then fire
@@ -243,11 +255,15 @@ fire_or_rearm_alarm (GoaAlarm *self)
 static gboolean
 on_immediate_wakeup_source_ready (GoaAlarm *self)
 {
-  g_return_val_if_fail (self->priv->type != GOA_ALARM_TYPE_UNSCHEDULED, FALSE);
+  GoaAlarmPrivate *priv;
+
+  priv = goa_alarm_get_instance_private (self);
 
-  g_rec_mutex_lock (&self->priv->lock);
+  g_return_val_if_fail (priv->type != GOA_ALARM_TYPE_UNSCHEDULED, FALSE);
+
+  g_rec_mutex_lock (&priv->lock);
   fire_or_rearm_alarm (self);
-  g_rec_mutex_unlock (&self->priv->lock);
+  g_rec_mutex_unlock (&priv->lock);
   return FALSE;
 }
 
@@ -255,20 +271,22 @@ on_immediate_wakeup_source_ready (GoaAlarm *self)
 static gboolean
 on_timer_source_ready (GObject *stream, GoaAlarm *self)
 {
+  GoaAlarmPrivate *priv;
   gint64 number_of_fires;
   gssize bytes_read;
   gboolean run_again = FALSE;
   GError *error = NULL;
 
   g_return_val_if_fail (GOA_IS_ALARM (self), FALSE);
+  priv = goa_alarm_get_instance_private (self);
 
-  g_rec_mutex_lock (&self->priv->lock);
+  g_rec_mutex_lock (&priv->lock);
 
-  if (self->priv->type != GOA_ALARM_TYPE_TIMER)
+  if (priv->type != GOA_ALARM_TYPE_TIMER)
     {
       g_warning ("GoaAlarm: timer source ready callback called "
                  "when timer source isn't supposed to be used. "
-                 "Current timer type is %u", self->priv->type);
+                 "Current timer type is %u", priv->type);
       goto out;
     }
 
@@ -301,7 +319,7 @@ on_timer_source_ready (GObject *stream, GoaAlarm *self)
   fire_or_rearm_alarm (self);
   run_again = TRUE;
 out:
-  g_rec_mutex_unlock (&self->priv->lock);
+  g_rec_mutex_unlock (&priv->lock);
   g_clear_error (&error);
   return run_again;
 }
@@ -311,12 +329,15 @@ static gboolean
 schedule_wakeups_with_timerfd (GoaAlarm *self)
 {
 #ifdef HAVE_TIMERFD
+  GoaAlarmPrivate *priv;
   struct itimerspec timer_spec;
   int fd;
   int result;
   GSource *source;
   static gboolean seen_before = FALSE;
 
+  priv = goa_alarm_get_instance_private (self);
+
   if (!seen_before)
     {
       g_debug ("GoaAlarm: trying to use kernel timer");
@@ -332,7 +353,7 @@ schedule_wakeups_with_timerfd (GoaAlarm *self)
     }
 
   memset (&timer_spec, 0, sizeof (timer_spec));
-  timer_spec.it_value.tv_sec = g_date_time_to_unix (self->priv->time) + 1;
+  timer_spec.it_value.tv_sec = g_date_time_to_unix (priv->time) + 1;
 
   result = timerfd_settime (fd,
                             TFD_TIMER_ABSTIME | TFD_TIMER_CANCEL_ON_SET,
@@ -344,18 +365,15 @@ schedule_wakeups_with_timerfd (GoaAlarm *self)
       return FALSE;
     }
 
-  self->priv->type = GOA_ALARM_TYPE_TIMER;
-  self->priv->stream = g_unix_input_stream_new (fd, TRUE);
+  priv->type = GOA_ALARM_TYPE_TIMER;
+  priv->stream = g_unix_input_stream_new (fd, TRUE);
 
-  source =
-    g_pollable_input_stream_create_source (G_POLLABLE_INPUT_STREAM
-                                           (self->priv->stream),
-                                           NULL);
-  self->priv->scheduled_wakeup_source = source;
-  g_source_set_callback (self->priv->scheduled_wakeup_source,
+  source = g_pollable_input_stream_create_source (G_POLLABLE_INPUT_STREAM (priv->stream), NULL);
+  priv->scheduled_wakeup_source = source;
+  g_source_set_callback (priv->scheduled_wakeup_source,
                          (GSourceFunc) on_timer_source_ready, self,
                          (GDestroyNotify) clear_wakeup_source_pointer);
-  g_source_attach (self->priv->scheduled_wakeup_source, self->priv->context);
+  g_source_attach (priv->scheduled_wakeup_source, priv->context);
   g_source_unref (source);
 
   return TRUE;
@@ -368,11 +386,14 @@ schedule_wakeups_with_timerfd (GoaAlarm *self)
 static gboolean
 on_timeout_source_ready (GoaAlarm *self)
 {
+  GoaAlarmPrivate *priv;
+
   g_return_val_if_fail (GOA_IS_ALARM (self), FALSE);
+  priv = goa_alarm_get_instance_private (self);
 
-  g_rec_mutex_lock (&self->priv->lock);
+  g_rec_mutex_lock (&priv->lock);
 
-  if (self->priv->type == GOA_ALARM_TYPE_UNSCHEDULED)
+  if (priv->type == GOA_ALARM_TYPE_UNSCHEDULED)
     goto out;
 
   fire_or_rearm_alarm (self);
@@ -380,28 +401,34 @@ on_timeout_source_ready (GoaAlarm *self)
   schedule_wakeups_with_timeout_source (self);
 
 out:
-  g_rec_mutex_unlock (&self->priv->lock);
+  g_rec_mutex_unlock (&priv->lock);
   return FALSE;
 }
 
 static void
 clear_wakeup_source_pointer (GoaAlarm *self)
 {
-  self->priv->scheduled_wakeup_source = NULL;
+  GoaAlarmPrivate *priv;
+
+  priv = goa_alarm_get_instance_private (self);
+  priv->scheduled_wakeup_source = NULL;
 }
 
 static void
 schedule_wakeups_with_timeout_source (GoaAlarm *self)
 {
+  GoaAlarmPrivate *priv;
   GDateTime *now;
   GSource   *source;
   GTimeSpan  time_span;
   guint      interval;
 
-  self->priv->type = GOA_ALARM_TYPE_TIMEOUT;
+  priv = goa_alarm_get_instance_private (self);
+
+  priv->type = GOA_ALARM_TYPE_TIMEOUT;
 
   now = g_date_time_new_now_local ();
-  time_span = g_date_time_difference (self->priv->time, now);
+  time_span = g_date_time_difference (priv->time, now);
   g_date_time_unref (now);
 
   time_span =
@@ -415,13 +442,13 @@ schedule_wakeups_with_timeout_source (GoaAlarm *self)
 
   source = g_timeout_source_new (interval);
 
-  self->priv->scheduled_wakeup_source = source;
-  g_source_set_callback (self->priv->scheduled_wakeup_source,
+  priv->scheduled_wakeup_source = source;
+  g_source_set_callback (priv->scheduled_wakeup_source,
                          (GSourceFunc)
                          on_timeout_source_ready,
                          self, (GDestroyNotify) clear_wakeup_source_pointer);
 
-  g_source_attach (self->priv->scheduled_wakeup_source, self->priv->context);
+  g_source_attach (priv->scheduled_wakeup_source, priv->context);
   g_source_unref (source);
 }
 
@@ -448,50 +475,63 @@ schedule_wakeups (GoaAlarm *self)
 static void
 clear_immediate_wakeup_source_pointer (GoaAlarm *self)
 {
-  self->priv->immediate_wakeup_source = NULL;
+  GoaAlarmPrivate *priv;
+
+  priv = goa_alarm_get_instance_private (self);
+  priv->immediate_wakeup_source = NULL;
 }
 
 static void
 schedule_immediate_wakeup (GoaAlarm *self)
 {
+  GoaAlarmPrivate *priv;
   GSource *source;
 
+  priv = goa_alarm_get_instance_private (self);
+
   source = g_idle_source_new ();
 
-  self->priv->immediate_wakeup_source = source;
-  g_source_set_callback (self->priv->immediate_wakeup_source,
+  priv->immediate_wakeup_source = source;
+  g_source_set_callback (priv->immediate_wakeup_source,
                          (GSourceFunc)
                          on_immediate_wakeup_source_ready,
                          self,
                          (GDestroyNotify) clear_immediate_wakeup_source_pointer);
 
-  g_source_attach (self->priv->immediate_wakeup_source, self->priv->context);
+  g_source_attach (priv->immediate_wakeup_source, priv->context);
   g_source_unref (source);
 }
 
 static void
 goa_alarm_set_time (GoaAlarm *self, GDateTime *time)
 {
-  g_rec_mutex_lock (&self->priv->lock);
+  GoaAlarmPrivate *priv;
+
+  priv = goa_alarm_get_instance_private (self);
+
+  g_rec_mutex_lock (&priv->lock);
 
   g_date_time_ref (time);
-  self->priv->time = time;
+  priv->time = time;
 
-  if (self->priv->context == NULL)
-    self->priv->context = g_main_context_ref (g_main_context_default ());
+  if (priv->context == NULL)
+    priv->context = g_main_context_ref (g_main_context_default ());
 
   schedule_wakeups (self);
 
   /* Wake up right away, in case it's already expired leaving the gate */
   schedule_immediate_wakeup (self);
-  g_rec_mutex_unlock (&self->priv->lock);
+  g_rec_mutex_unlock (&priv->lock);
   g_object_notify (G_OBJECT (self), "time");
 }
 
 GDateTime *
 goa_alarm_get_time (GoaAlarm *self)
 {
-  return self->priv->time;
+  GoaAlarmPrivate *priv;
+
+  priv = goa_alarm_get_instance_private (self);
+  return priv->time;
 }
 
 GoaAlarm *
diff --git a/src/goaidentity/goaalarm.h b/src/goaidentity/goaalarm.h
index c60db732..c0968de3 100644
--- a/src/goaidentity/goaalarm.h
+++ b/src/goaidentity/goaalarm.h
@@ -37,8 +37,6 @@ typedef struct _GoaAlarmPrivate GoaAlarmPrivate;
 struct _GoaAlarm
 {
   GObject parent;
-
-  GoaAlarmPrivate *priv;
 };
 
 struct _GoaAlarmClass