iface-modem-3gpp: refactor private data handling

Instead of having separate contexts for different things, setup a
interface-wide private struct.

1 files changed, 226 insertions, 262 deletions

diff --git a/src/mm-iface-modem-3gpp.c b/src/mm-iface-modem-3gpp.c
index 16af6af8..c440af71 100644
--- a/src/mm-iface-modem-3gpp.c
+++ b/src/mm-iface-modem-3gpp.c
@@ -28,15 +28,58 @@
 #include "mm-error-helpers.h"
 #include "mm-log.h"
 
-#define REGISTRATION_CHECK_TIMEOUT_SEC 30
-
 #define SUBSYSTEM_3GPP "3gpp"
 
-#define REGISTRATION_STATE_CONTEXT_TAG    "3gpp-registration-state-context-tag"
-#define REGISTRATION_CHECK_CONTEXT_TAG    "3gpp-registration-check-context-tag"
+/*****************************************************************************/
+/* Private data context */
+
+#define PRIVATE_TAG "iface-modem-3gpp-private-tag"
+static GQuark private_quark;
+
+typedef struct {
+    /* Registration state */
+    MMModem3gppRegistrationState  cs;
+    MMModem3gppRegistrationState  ps;
+    MMModem3gppRegistrationState  eps;
+    gboolean                      manual_registration;
+    GCancellable                 *pending_registration_cancellable;
+    gboolean                      reloading_registration_info;
+    /* Registration checks */
+    guint    check_timeout_source;
+    gboolean check_running;
+} Private;
+
+static void
+private_free (Private *priv)
+{
+    if (priv->pending_registration_cancellable) {
+        g_cancellable_cancel (priv->pending_registration_cancellable);
+        g_object_unref (priv->pending_registration_cancellable);
+    }
+    if (priv->check_timeout_source)
+        g_source_remove (priv->check_timeout_source);
+    g_slice_free (Private, priv);
+}
+
+static Private *
+get_private (MMIfaceModem3gpp *self)
+{
+    Private *priv;
+
+    if (G_UNLIKELY (!private_quark))
+        private_quark = g_quark_from_static_string (PRIVATE_TAG);
+
+    priv = g_object_get_qdata (G_OBJECT (self), private_quark);
+    if (!priv) {
+        priv = g_slice_new0 (Private);
+        priv->cs = MM_MODEM_3GPP_REGISTRATION_STATE_UNKNOWN;
+        priv->ps = MM_MODEM_3GPP_REGISTRATION_STATE_UNKNOWN;
+        priv->eps = MM_MODEM_3GPP_REGISTRATION_STATE_UNKNOWN;
+        g_object_set_qdata_full (G_OBJECT (self), private_quark, priv, (GDestroyNotify)private_free);
+    }
 
-static GQuark registration_state_context_quark;
-static GQuark registration_check_context_quark;
+    return priv;
+}
 
 /*****************************************************************************/
 
@@ -69,52 +112,6 @@ mm_iface_modem_3gpp_bind_simple_status (MMIfaceModem3gpp *self,
 
 /*****************************************************************************/
 
-typedef struct {
-    MMModem3gppRegistrationState cs;
-    MMModem3gppRegistrationState ps;
-    MMModem3gppRegistrationState eps;
-    gboolean manual_registration;
-    GCancellable *pending_registration_cancellable;
-    gboolean reloading_registration_info;
-} RegistrationStateContext;
-
-static void
-registration_state_context_free (RegistrationStateContext *ctx)
-{
-    if (ctx->pending_registration_cancellable) {
-        g_cancellable_cancel (ctx->pending_registration_cancellable);
-        g_object_unref (ctx->pending_registration_cancellable);
-    }
-    g_slice_free (RegistrationStateContext, ctx);
-}
-
-static RegistrationStateContext *
-get_registration_state_context (MMIfaceModem3gpp *self)
-{
-    RegistrationStateContext *ctx;
-
-    if (G_UNLIKELY (!registration_state_context_quark))
-        registration_state_context_quark =  (g_quark_from_static_string (
-                                                 REGISTRATION_STATE_CONTEXT_TAG));
-
-    ctx = g_object_get_qdata (G_OBJECT (self), registration_state_context_quark);
-    if (!ctx) {
-        /* Create context and keep it as object data */
-        ctx = g_slice_new0 (RegistrationStateContext);
-        ctx->cs = MM_MODEM_3GPP_REGISTRATION_STATE_UNKNOWN;
-        ctx->ps = MM_MODEM_3GPP_REGISTRATION_STATE_UNKNOWN;
-        ctx->eps = MM_MODEM_3GPP_REGISTRATION_STATE_UNKNOWN;
-
-        g_object_set_qdata_full (
-            G_OBJECT (self),
-            registration_state_context_quark,
-            ctx,
-            (GDestroyNotify)registration_state_context_free);
-    }
-
-    return ctx;
-}
-
 #define REG_STATE_IS_REGISTERED(state)                                    \
     (state == MM_MODEM_3GPP_REGISTRATION_STATE_HOME ||                    \
      state == MM_MODEM_3GPP_REGISTRATION_STATE_ROAMING ||                 \
@@ -129,54 +126,57 @@ get_registration_state_context (MMIfaceModem3gpp *self)
      state == MM_MODEM_3GPP_REGISTRATION_STATE_DENIED)
 
 static MMModem3gppRegistrationState
-get_consolidated_reg_state (RegistrationStateContext *ctx)
+get_consolidated_reg_state (MMIfaceModem3gpp *self)
 {
-    MMModem3gppRegistrationState consolidated = MM_MODEM_3GPP_REGISTRATION_STATE_UNKNOWN;
+    Private                      *priv;
+    MMModem3gppRegistrationState  consolidated = MM_MODEM_3GPP_REGISTRATION_STATE_UNKNOWN;
+
+    priv = get_private (self);
 
     /* Some devices (Blackberries for example) will respond to +CGREG, but
      * return ERROR for +CREG, probably because their firmware is just stupid.
      * So here we prefer the +CREG response, but if we never got a successful
      * +CREG response, we'll take +CGREG instead.
      */
-    if (ctx->cs == MM_MODEM_3GPP_REGISTRATION_STATE_HOME ||
-        ctx->cs == MM_MODEM_3GPP_REGISTRATION_STATE_ROAMING) {
-        consolidated = ctx->cs;
+    if (priv->cs == MM_MODEM_3GPP_REGISTRATION_STATE_HOME ||
+        priv->cs == MM_MODEM_3GPP_REGISTRATION_STATE_ROAMING) {
+        consolidated = priv->cs;
         goto out;
     }
-    if (ctx->ps == MM_MODEM_3GPP_REGISTRATION_STATE_HOME ||
-        ctx->ps == MM_MODEM_3GPP_REGISTRATION_STATE_ROAMING) {
-        consolidated = ctx->ps;
+    if (priv->ps == MM_MODEM_3GPP_REGISTRATION_STATE_HOME ||
+        priv->ps == MM_MODEM_3GPP_REGISTRATION_STATE_ROAMING) {
+        consolidated = priv->ps;
         goto out;
     }
-    if (ctx->eps == MM_MODEM_3GPP_REGISTRATION_STATE_HOME ||
-        ctx->eps == MM_MODEM_3GPP_REGISTRATION_STATE_ROAMING) {
-        consolidated = ctx->eps;
+    if (priv->eps == MM_MODEM_3GPP_REGISTRATION_STATE_HOME ||
+        priv->eps == MM_MODEM_3GPP_REGISTRATION_STATE_ROAMING) {
+        consolidated = priv->eps;
         goto out;
     }
 
     /* Searching? */
-    if (ctx->cs  == MM_MODEM_3GPP_REGISTRATION_STATE_SEARCHING ||
-        ctx->ps  == MM_MODEM_3GPP_REGISTRATION_STATE_SEARCHING ||
-        ctx->eps == MM_MODEM_3GPP_REGISTRATION_STATE_SEARCHING) {
+    if (priv->cs  == MM_MODEM_3GPP_REGISTRATION_STATE_SEARCHING ||
+        priv->ps  == MM_MODEM_3GPP_REGISTRATION_STATE_SEARCHING ||
+        priv->eps == MM_MODEM_3GPP_REGISTRATION_STATE_SEARCHING) {
          consolidated = MM_MODEM_3GPP_REGISTRATION_STATE_SEARCHING;
          goto out;
     }
 
     /* If at least one state is DENIED and the others are UNKNOWN or IDLE, use DENIED */
-    if ((ctx->cs == MM_MODEM_3GPP_REGISTRATION_STATE_DENIED ||
-         ctx->ps == MM_MODEM_3GPP_REGISTRATION_STATE_DENIED ||
-         ctx->eps == MM_MODEM_3GPP_REGISTRATION_STATE_DENIED) &&
-        REG_STATE_IS_UNKNOWN_IDLE_DENIED (ctx->cs) &&
-        REG_STATE_IS_UNKNOWN_IDLE_DENIED (ctx->ps) &&
-        REG_STATE_IS_UNKNOWN_IDLE_DENIED (ctx->eps)) {
+    if ((priv->cs == MM_MODEM_3GPP_REGISTRATION_STATE_DENIED ||
+         priv->ps == MM_MODEM_3GPP_REGISTRATION_STATE_DENIED ||
+         priv->eps == MM_MODEM_3GPP_REGISTRATION_STATE_DENIED) &&
+        REG_STATE_IS_UNKNOWN_IDLE_DENIED (priv->cs) &&
+        REG_STATE_IS_UNKNOWN_IDLE_DENIED (priv->ps) &&
+        REG_STATE_IS_UNKNOWN_IDLE_DENIED (priv->eps)) {
         consolidated = MM_MODEM_3GPP_REGISTRATION_STATE_DENIED;
         goto out;
     }
 
     /* Emergency services? */
-    if (ctx->cs  == MM_MODEM_3GPP_REGISTRATION_STATE_EMERGENCY_ONLY ||
-        ctx->ps  == MM_MODEM_3GPP_REGISTRATION_STATE_EMERGENCY_ONLY ||
-        ctx->eps == MM_MODEM_3GPP_REGISTRATION_STATE_EMERGENCY_ONLY) {
+    if (priv->cs  == MM_MODEM_3GPP_REGISTRATION_STATE_EMERGENCY_ONLY ||
+        priv->ps  == MM_MODEM_3GPP_REGISTRATION_STATE_EMERGENCY_ONLY ||
+        priv->eps == MM_MODEM_3GPP_REGISTRATION_STATE_EMERGENCY_ONLY) {
          consolidated = MM_MODEM_3GPP_REGISTRATION_STATE_EMERGENCY_ONLY;
          goto out;
     }
@@ -193,29 +193,29 @@ get_consolidated_reg_state (RegistrationStateContext *ctx)
      * We also warn in that case, because ideally we should always report the
      * LTE registration state first, not this one.
      */
-    if (ctx->cs == MM_MODEM_3GPP_REGISTRATION_STATE_HOME_SMS_ONLY ||
-        ctx->cs == MM_MODEM_3GPP_REGISTRATION_STATE_ROAMING_SMS_ONLY ||
-        ctx->cs == MM_MODEM_3GPP_REGISTRATION_STATE_HOME_CSFB_NOT_PREFERRED ||
-        ctx->cs == MM_MODEM_3GPP_REGISTRATION_STATE_ROAMING_CSFB_NOT_PREFERRED) {
+    if (priv->cs == MM_MODEM_3GPP_REGISTRATION_STATE_HOME_SMS_ONLY ||
+        priv->cs == MM_MODEM_3GPP_REGISTRATION_STATE_ROAMING_SMS_ONLY ||
+        priv->cs == MM_MODEM_3GPP_REGISTRATION_STATE_HOME_CSFB_NOT_PREFERRED ||
+        priv->cs == MM_MODEM_3GPP_REGISTRATION_STATE_ROAMING_CSFB_NOT_PREFERRED) {
         mm_warn ("3GPP CSFB registration state is consolidated: %s",
-                 mm_modem_3gpp_registration_state_get_string (ctx->cs));
-        consolidated = ctx->cs;
+                 mm_modem_3gpp_registration_state_get_string (priv->cs));
+        consolidated = priv->cs;
         goto out;
     }
 
     /* Idle? */
-    if (ctx->cs  == MM_MODEM_3GPP_REGISTRATION_STATE_IDLE ||
-        ctx->ps  == MM_MODEM_3GPP_REGISTRATION_STATE_IDLE ||
-        ctx->eps == MM_MODEM_3GPP_REGISTRATION_STATE_IDLE) {
+    if (priv->cs  == MM_MODEM_3GPP_REGISTRATION_STATE_IDLE ||
+        priv->ps  == MM_MODEM_3GPP_REGISTRATION_STATE_IDLE ||
+        priv->eps == MM_MODEM_3GPP_REGISTRATION_STATE_IDLE) {
          consolidated = MM_MODEM_3GPP_REGISTRATION_STATE_IDLE;
          goto out;
     }
 
  out:
     mm_dbg ("building consolidated registration state: cs '%s', ps '%s', eps '%s' --> '%s'",
-            mm_modem_3gpp_registration_state_get_string (ctx->cs),
-            mm_modem_3gpp_registration_state_get_string (ctx->ps),
-            mm_modem_3gpp_registration_state_get_string (ctx->eps),
+            mm_modem_3gpp_registration_state_get_string (priv->cs),
+            mm_modem_3gpp_registration_state_get_string (priv->ps),
+            mm_modem_3gpp_registration_state_get_string (priv->eps),
             mm_modem_3gpp_registration_state_get_string (consolidated));
 
     return consolidated;
@@ -226,10 +226,10 @@ get_consolidated_reg_state (RegistrationStateContext *ctx)
 typedef struct {
     MMIfaceModem3gpp *self;
     MmGdbusModem3gpp *skeleton;
-    GCancellable *cancellable;
-    gchar *operator_id;
-    GTimer *timer;
-    guint max_registration_time;
+    GCancellable     *cancellable;
+    gchar            *operator_id;
+    GTimer           *timer;
+    guint             max_registration_time;
 } RegisterInNetworkContext;
 
 static void
@@ -239,13 +239,12 @@ register_in_network_context_free (RegisterInNetworkContext *ctx)
         g_timer_destroy (ctx->timer);
 
     if (ctx->cancellable) {
-        RegistrationStateContext *registration_state_context;
+        Private *priv;
 
         /* Clear our cancellable if still around */
-        registration_state_context = get_registration_state_context (ctx->self);
-        if (registration_state_context->pending_registration_cancellable == ctx->cancellable)
-            g_clear_object (&registration_state_context->pending_registration_cancellable);
-
+        priv = get_private (ctx->self);
+        if (priv->pending_registration_cancellable == ctx->cancellable)
+            g_clear_object (&priv->pending_registration_cancellable);
         g_object_unref (ctx->cancellable);
     }
 
@@ -257,7 +256,7 @@ register_in_network_context_free (RegisterInNetworkContext *ctx)
 }
 
 static void
-register_in_network_context_complete_failed (GTask *task,
+register_in_network_context_complete_failed (GTask  *task,
                                              GError *error)
 {
     RegisterInNetworkContext *ctx;
@@ -275,41 +274,23 @@ register_in_network_context_complete_failed (GTask *task,
 }
 
 gboolean
-mm_iface_modem_3gpp_register_in_network_finish (MMIfaceModem3gpp *self,
-                                                GAsyncResult *res,
-                                                GError **error)
+mm_iface_modem_3gpp_register_in_network_finish (MMIfaceModem3gpp  *self,
+                                                GAsyncResult      *res,
+                                                GError           **error)
 {
     return g_task_propagate_boolean (G_TASK (res), error);
 }
 
-static void run_registration_checks_ready (MMIfaceModem3gpp *self,
-                                           GAsyncResult *res,
-                                           GTask *task);
-
-static gboolean
-run_registration_checks_again (GTask *task)
-{
-    RegisterInNetworkContext *ctx;
-
-    ctx = g_task_get_task_data (task);
-
-    /* Get fresh registration state */
-    mm_iface_modem_3gpp_run_registration_checks (
-        ctx->self,
-        (GAsyncReadyCallback)run_registration_checks_ready,
-        task);
-    return G_SOURCE_REMOVE;
-}
+static gboolean run_registration_checks (GTask *task);
 
 static void
 run_registration_checks_ready (MMIfaceModem3gpp *self,
-                               GAsyncResult *res,
-                               GTask *task)
+                               GAsyncResult     *res,
+                               GTask            *task)
 {
-    RegisterInNetworkContext *ctx;
-    GError *error = NULL;
-    RegistrationStateContext *registration_state_context;
-    MMModem3gppRegistrationState current_registration_state;
+    RegisterInNetworkContext     *ctx;
+    GError                       *error = NULL;
+    MMModem3gppRegistrationState  current_registration_state;
 
     ctx = g_task_get_task_data (task);
 
@@ -320,8 +301,7 @@ run_registration_checks_ready (MMIfaceModem3gpp *self,
         return;
     }
 
-    registration_state_context = get_registration_state_context (ctx->self);
-    current_registration_state = get_consolidated_reg_state (registration_state_context);
+    current_registration_state = get_consolidated_reg_state (ctx->self);
 
     /* If we got a final state and it's denied, we can assume the registration is
      * finished */
@@ -362,13 +342,28 @@ run_registration_checks_ready (MMIfaceModem3gpp *self,
      * well.
      */
     mm_dbg ("Modem not yet registered in a 3GPP network... will recheck soon");
-    g_timeout_add_seconds (3, (GSourceFunc)run_registration_checks_again, task);
+    g_timeout_add_seconds (3, (GSourceFunc)run_registration_checks, task);
+}
+
+static gboolean
+run_registration_checks (GTask *task)
+{
+    RegisterInNetworkContext *ctx;
+
+    ctx = g_task_get_task_data (task);
+
+    /* Get fresh registration state */
+    mm_iface_modem_3gpp_run_registration_checks (
+        ctx->self,
+        (GAsyncReadyCallback)run_registration_checks_ready,
+        task);
+    return G_SOURCE_REMOVE;
 }
 
 static void
 register_in_network_ready (MMIfaceModem3gpp *self,
-                           GAsyncResult *res,
-                           GTask *task)
+                           GAsyncResult     *res,
+                           GTask            *task)
 {
     GError *error = NULL;
 
@@ -380,24 +375,23 @@ register_in_network_ready (MMIfaceModem3gpp *self,
 
     /* Now try to gather current registration status until we're registered or
      * the time goes off */
-    mm_iface_modem_3gpp_run_registration_checks (
-        self,
-        (GAsyncReadyCallback)run_registration_checks_ready,
-        task);
+    run_registration_checks (task);
 }
 
 void
-mm_iface_modem_3gpp_register_in_network (MMIfaceModem3gpp *self,
-                                         const gchar *operator_id,
-                                         guint max_registration_time,
-                                         GAsyncReadyCallback callback,
-                                         gpointer user_data)
+mm_iface_modem_3gpp_register_in_network (MMIfaceModem3gpp    *self,
+                                         const gchar         *operator_id,
+                                         guint                max_registration_time,
+                                         GAsyncReadyCallback  callback,
+                                         gpointer             user_data)
 {
     RegisterInNetworkContext *ctx;
-    const gchar *current_operator_code;
-    RegistrationStateContext *registration_state_context;
-    GError *error = NULL;
-    GTask *task;
+    const gchar              *current_operator_code;
+    GError                   *error = NULL;
+    GTask                    *task;
+    Private                  *priv;
+
+    priv = get_private (self);
 
     ctx = g_slice_new0 (RegisterInNetworkContext);
     ctx->self = g_object_ref (self);
@@ -427,13 +421,10 @@ mm_iface_modem_3gpp_register_in_network (MMIfaceModem3gpp *self,
         return;
     }
 
-    /* Get registration state context */
-    registration_state_context = get_registration_state_context (self);
-
     /* (Try to) cancel previous registration request */
-    if (registration_state_context->pending_registration_cancellable) {
-        g_cancellable_cancel (registration_state_context->pending_registration_cancellable);
-        g_clear_object (&registration_state_context->pending_registration_cancellable);
+    if (priv->pending_registration_cancellable) {
+        g_cancellable_cancel (priv->pending_registration_cancellable);
+        g_clear_object (&priv->pending_registration_cancellable);
     }
 
     current_operator_code = mm_gdbus_modem3gpp_get_operator_code (ctx->skeleton);
@@ -443,7 +434,7 @@ mm_iface_modem_3gpp_register_in_network (MMIfaceModem3gpp *self,
         /* If already registered with the requested operator, we're done */
         if (current_operator_code &&
             g_str_equal (current_operator_code, ctx->operator_id)) {
-            registration_state_context->manual_registration = TRUE;
+            priv->manual_registration = TRUE;
             mm_dbg ("Already registered in selected network '%s'...",
                     current_operator_code);
             g_task_return_boolean (task, TRUE);
@@ -452,18 +443,19 @@ mm_iface_modem_3gpp_register_in_network (MMIfaceModem3gpp *self,
         }
 
         /* Manual registration to a new operator required */
-        mm_dbg ("Launching manual network registration (%s)...",
-                ctx->operator_id);
-        registration_state_context->manual_registration = TRUE;
+        mm_dbg ("Launching manual network registration (%s)...", ctx->operator_id);
+        priv->manual_registration = TRUE;
     }
     /* Automatic registration requested? */
     else {
-        MMModem3gppRegistrationState reg_state = mm_gdbus_modem3gpp_get_registration_state (ctx->skeleton);
+        MMModem3gppRegistrationState reg_state;
+
+        reg_state = mm_gdbus_modem3gpp_get_registration_state (ctx->skeleton);
 
         /* If the modem is already registered and the last time it was asked
          * automatic registration, we're done */
         if ((current_operator_code || REG_STATE_IS_REGISTERED (reg_state)) &&
-            !registration_state_context->manual_registration) {
+            !priv->manual_registration) {
             mm_dbg ("Already registered in network '%s',"
                     " automatic registration not launched...",
                     current_operator_code);
@@ -474,15 +466,14 @@ mm_iface_modem_3gpp_register_in_network (MMIfaceModem3gpp *self,
 
         /* Automatic registration to a new operator requested */
         mm_dbg ("Launching automatic network registration...");
-        registration_state_context->manual_registration = FALSE;
+        priv->manual_registration = FALSE;
     }
 
     ctx->cancellable = g_cancellable_new ();
 
     /* Keep an accessible reference to the cancellable, so that we can cancel
      * previous request when needed */
-    registration_state_context->pending_registration_cancellable =
-        g_object_ref (ctx->cancellable);
+    priv->pending_registration_cancellable = g_object_ref (ctx->cancellable);
 
     ctx->timer = g_timer_new ();
     MM_IFACE_MODEM_3GPP_GET_INTERFACE (self)->register_in_network (
@@ -1308,14 +1299,13 @@ mm_iface_modem_3gpp_clear_current_operator (MMIfaceModem3gpp *self)
 /*****************************************************************************/
 
 void
-mm_iface_modem_3gpp_update_access_technologies (MMIfaceModem3gpp *self,
-                                                MMModemAccessTechnology access_tech)
+mm_iface_modem_3gpp_update_access_technologies (MMIfaceModem3gpp        *self,
+                                                MMModemAccessTechnology  access_tech)
 {
-    MMModem3gppRegistrationState state;
-    RegistrationStateContext *ctx;
+    Private                      *priv;
+    MMModem3gppRegistrationState  state;
 
-    ctx = get_registration_state_context (self);
-    g_assert (ctx);
+    priv = get_private (self);
 
     g_object_get (self,
                   MM_IFACE_MODEM_3GPP_REGISTRATION_STATE, &state,
@@ -1323,7 +1313,7 @@ mm_iface_modem_3gpp_update_access_technologies (MMIfaceModem3gpp *self,
 
     /* Even if registration state didn't change, report access technology,
      * but only if something valid to report */
-    if (REG_STATE_IS_REGISTERED (state) || ctx->reloading_registration_info) {
+    if (REG_STATE_IS_REGISTERED (state) || priv->reloading_registration_info) {
         if (access_tech != MM_MODEM_ACCESS_TECHNOLOGY_UNKNOWN)
             mm_iface_modem_update_access_technologies (MM_IFACE_MODEM (self),
                                                        access_tech,
@@ -1340,11 +1330,10 @@ mm_iface_modem_3gpp_update_location (MMIfaceModem3gpp *self,
                                      gulong tracking_area_code,
                                      gulong cell_id)
 {
-    MMModem3gppRegistrationState state;
-    RegistrationStateContext *ctx;
+    Private                      *priv;
+    MMModem3gppRegistrationState  state;
 
-    ctx = get_registration_state_context (self);
-    g_assert (ctx);
+    priv = get_private (self);
 
     if (!MM_IS_IFACE_MODEM_LOCATION (self))
         return;
@@ -1357,7 +1346,7 @@ mm_iface_modem_3gpp_update_location (MMIfaceModem3gpp *self,
      * location updates, but only if something valid to report. For the case
      * where we're registering (loading current registration info after a state
      * change to registered), we also allow LAC/CID updates. */
-    if (REG_STATE_IS_REGISTERED (state) || ctx->reloading_registration_info) {
+    if (REG_STATE_IS_REGISTERED (state) || priv->reloading_registration_info) {
         if ((location_area_code > 0 || tracking_area_code > 0) && cell_id > 0)
             mm_iface_modem_location_3gpp_update_lac_tac_ci (MM_IFACE_MODEM_LOCATION (self),
                                                             location_area_code,
@@ -1371,11 +1360,13 @@ mm_iface_modem_3gpp_update_location (MMIfaceModem3gpp *self,
 
 static void
 update_registration_reload_current_registration_info_ready (MMIfaceModem3gpp *self,
-                                                            GAsyncResult *res,
-                                                            gpointer user_data)
+                                                            GAsyncResult     *res,
+                                                            gpointer          user_data)
 {
-    MMModem3gppRegistrationState new_state;
-    RegistrationStateContext *ctx;
+    Private                      *priv;
+    MMModem3gppRegistrationState  new_state;
+
+    priv = get_private (self);
 
     new_state = GPOINTER_TO_UINT (user_data);
 
@@ -1394,14 +1385,13 @@ update_registration_reload_current_registration_info_ready (MMIfaceModem3gpp *se
                                            MM_MODEM_STATE_REGISTERED,
                                            MM_MODEM_STATE_CHANGE_REASON_UNKNOWN);
 
-    ctx = get_registration_state_context (self);
-    ctx->reloading_registration_info = FALSE;
+    priv->reloading_registration_info = FALSE;
 }
 
 static void
-update_non_registered_state (MMIfaceModem3gpp *self,
-                             MMModem3gppRegistrationState old_state,
-                             MMModem3gppRegistrationState new_state)
+update_non_registered_state (MMIfaceModem3gpp             *self,
+                             MMModem3gppRegistrationState  old_state,
+                             MMModem3gppRegistrationState  new_state)
 {
     /* Not registered neither in home nor roaming network */
     mm_iface_modem_3gpp_clear_current_operator (self);
@@ -1422,20 +1412,19 @@ update_non_registered_state (MMIfaceModem3gpp *self,
 }
 
 static void
-update_registration_state (MMIfaceModem3gpp *self,
-                           MMModem3gppRegistrationState new_state,
-                           gboolean deferrable)
+update_registration_state (MMIfaceModem3gpp             *self,
+                           MMModem3gppRegistrationState  new_state,
+                           gboolean                      deferrable)
 {
-    MMModem3gppRegistrationState old_state = MM_MODEM_3GPP_REGISTRATION_STATE_UNKNOWN;
-    RegistrationStateContext *ctx;
+    Private                      *priv;
+    MMModem3gppRegistrationState  old_state = MM_MODEM_3GPP_REGISTRATION_STATE_UNKNOWN;
+
+    priv = get_private (self);
 
     g_object_get (self,
                   MM_IFACE_MODEM_3GPP_REGISTRATION_STATE, &old_state,
                   NULL);
 
-    ctx = get_registration_state_context (self);
-    g_assert (ctx);
-
     /* Only set new state if different */
     if (new_state == old_state)
         return;
@@ -1444,7 +1433,7 @@ update_registration_state (MMIfaceModem3gpp *self,
         MMModemState modem_state;
 
         /* If already reloading registration info, skip it */
-        if (ctx->reloading_registration_info)
+        if (priv->reloading_registration_info)
             return;
 
         /* If the modem isn't already enabled, this registration state update
@@ -1469,7 +1458,7 @@ update_registration_state (MMIfaceModem3gpp *self,
 
         /* Reload current registration info. ONLY update the state to REGISTERED
          * after having loaded operator code/name/subscription state */
-        ctx->reloading_registration_info = TRUE;
+        priv->reloading_registration_info = TRUE;
         mm_iface_modem_3gpp_reload_current_registration_info (
             self,
             (GAsyncReadyCallback)update_registration_reload_current_registration_info_ready,
@@ -1486,11 +1475,11 @@ update_registration_state (MMIfaceModem3gpp *self,
 }
 
 void
-mm_iface_modem_3gpp_update_cs_registration_state (MMIfaceModem3gpp *self,
-                                                  MMModem3gppRegistrationState state)
+mm_iface_modem_3gpp_update_cs_registration_state (MMIfaceModem3gpp             *self,
+                                                  MMModem3gppRegistrationState  state)
 {
-    RegistrationStateContext *ctx;
-    gboolean supported = FALSE;
+    Private  *priv;
+    gboolean  supported = FALSE;
 
     g_object_get (self,
                   MM_IFACE_MODEM_3GPP_CS_NETWORK_SUPPORTED, &supported,
@@ -1499,17 +1488,17 @@ mm_iface_modem_3gpp_update_cs_registration_state (MMIfaceModem3gpp *self,
     if (!supported)
         return;
 
-    ctx = get_registration_state_context (self);
-    ctx->cs = state;
-    update_registration_state (self, get_consolidated_reg_state (ctx), TRUE);
+    priv = get_private (self);
+    priv->cs = state;
+    update_registration_state (self, get_consolidated_reg_state (self), TRUE);
 }
 
 void
-mm_iface_modem_3gpp_update_ps_registration_state (MMIfaceModem3gpp *self,
-                                                  MMModem3gppRegistrationState state)
+mm_iface_modem_3gpp_update_ps_registration_state (MMIfaceModem3gpp             *self,
+                                                  MMModem3gppRegistrationState  state)
 {
-    RegistrationStateContext *ctx;
-    gboolean supported = FALSE;
+    Private  *priv;
+    gboolean  supported = FALSE;
 
     g_object_get (self,
                   MM_IFACE_MODEM_3GPP_PS_NETWORK_SUPPORTED, &supported,
@@ -1518,16 +1507,16 @@ mm_iface_modem_3gpp_update_ps_registration_state (MMIfaceModem3gpp *self,
     if (!supported)
         return;
 
-    ctx = get_registration_state_context (self);
-    ctx->ps = state;
-    update_registration_state (self, get_consolidated_reg_state (ctx), TRUE);
+    priv = get_private (self);
+    priv->ps = state;
+    update_registration_state (self, get_consolidated_reg_state (self), TRUE);
 }
 
 void
-mm_iface_modem_3gpp_update_eps_registration_state (MMIfaceModem3gpp *self,
-                                                   MMModem3gppRegistrationState state)
+mm_iface_modem_3gpp_update_eps_registration_state (MMIfaceModem3gpp             *self,
+                                                   MMModem3gppRegistrationState  state)
 {
-    RegistrationStateContext *ctx;
+    Private  *priv;
     gboolean supported = FALSE;
 
     g_object_get (self,
@@ -1537,32 +1526,24 @@ mm_iface_modem_3gpp_update_eps_registration_state (MMIfaceModem3gpp *self,
     if (!supported)
         return;
 
-    ctx = get_registration_state_context (self);
-    ctx->eps = state;
-    update_registration_state (self, get_consolidated_reg_state (ctx), TRUE);
+    priv = get_private (self);
+    priv->eps = state;
+    update_registration_state (self, get_consolidated_reg_state (self), TRUE);
 }
 
 /*****************************************************************************/
+/* Periodic registration checks */
 
-typedef struct {
-    guint timeout_source;
-    gboolean running;
-} RegistrationCheckContext;
-
-static void
-registration_check_context_free (RegistrationCheckContext *ctx)
-{
-    if (ctx->timeout_source)
-        g_source_remove (ctx->timeout_source);
-    g_free (ctx);
-}
+#define REGISTRATION_CHECK_TIMEOUT_SEC 30
 
 static void
 periodic_registration_checks_ready (MMIfaceModem3gpp *self,
-                                    GAsyncResult *res)
+                                    GAsyncResult     *res)
 {
-    RegistrationCheckContext *ctx;
-    GError *error = NULL;
+    Private *priv;
+    GError  *error = NULL;
+
+    priv = get_private (self);
 
     mm_iface_modem_3gpp_run_registration_checks_finish (self, res, &error);
     if (error) {
@@ -1570,21 +1551,19 @@ periodic_registration_checks_ready (MMIfaceModem3gpp *self,
         g_error_free (error);
     }
 
-    /* Remove the running tag */
-    ctx = g_object_get_qdata (G_OBJECT (self), registration_check_context_quark);
-    if (ctx)
-        ctx->running = FALSE;
+    priv->check_running = FALSE;
 }
 
 static gboolean
 periodic_registration_check (MMIfaceModem3gpp *self)
 {
-    RegistrationCheckContext *ctx;
+    Private *priv;
+
+    priv = get_private (self);
 
     /* Only launch a new one if not one running already */
-    ctx = g_object_get_qdata (G_OBJECT (self), registration_check_context_quark);
-    if (!ctx->running) {
-        ctx->running = TRUE;
+    if (!priv->check_running) {
+        priv->check_running = TRUE;
         mm_iface_modem_3gpp_run_registration_checks (
             self,
             (GAsyncReadyCallback)periodic_registration_checks_ready,
@@ -1596,14 +1575,16 @@ periodic_registration_check (MMIfaceModem3gpp *self)
 static void
 periodic_registration_check_disable (MMIfaceModem3gpp *self)
 {
-    if (G_UNLIKELY (!registration_check_context_quark))
-        registration_check_context_quark = (g_quark_from_static_string (
-                                                REGISTRATION_CHECK_CONTEXT_TAG));
+    Private *priv;
+
+    priv = get_private (self);
+
+    /* Do nothing if already disabled */
+    if (!priv->check_timeout_source)
+        return;
 
-    /* Overwriting the data will free the previous context */
-    g_object_set_qdata (G_OBJECT (self),
-                        registration_check_context_quark,
-                        NULL);
+    g_source_remove (priv->check_timeout_source);
+    priv->check_timeout_source = 0;
 
     mm_dbg ("Periodic 3GPP registration checks disabled");
 }
@@ -1611,28 +1592,19 @@ periodic_registration_check_disable (MMIfaceModem3gpp *self)
 static void
 periodic_registration_check_enable (MMIfaceModem3gpp *self)
 {
-    RegistrationCheckContext *ctx;
-
-    if (G_UNLIKELY (!registration_check_context_quark))
-        registration_check_context_quark = (g_quark_from_static_string (
-                                                REGISTRATION_CHECK_CONTEXT_TAG));
+    Private *priv;
 
-    ctx = g_object_get_qdata (G_OBJECT (self), registration_check_context_quark);
+    priv = get_private (self);
 
-    /* If context is already there, we're already enabled */
-    if (ctx)
+    /* Do nothing if already enabled */
+    if (priv->check_timeout_source)
         return;
 
     /* Create context and keep it as object data */
     mm_dbg ("Periodic 3GPP registration checks enabled");
-    ctx = g_new0 (RegistrationCheckContext, 1);
-    ctx->timeout_source = g_timeout_add_seconds (REGISTRATION_CHECK_TIMEOUT_SEC,
-                                                 (GSourceFunc)periodic_registration_check,
-                                                 self);
-    g_object_set_qdata_full (G_OBJECT (self),
-                             registration_check_context_quark,
-                             ctx,
-                             (GDestroyNotify)registration_check_context_free);
+    priv->check_timeout_source = g_timeout_add_seconds (REGISTRATION_CHECK_TIMEOUT_SEC,
+                                                        (GSourceFunc)periodic_registration_check,
+                                                        self);
 }
 
 /*****************************************************************************/
@@ -2549,14 +2521,6 @@ mm_iface_modem_3gpp_initialize (MMIfaceModem3gpp *self,
 void
 mm_iface_modem_3gpp_shutdown (MMIfaceModem3gpp *self)
 {
-    /* Remove RegistrationCheckContext object to make sure any pending
-     * invocation of periodic_registration_check is cancelled before the
-     * DBus skeleton is removed. */
-    if (G_LIKELY (registration_check_context_quark))
-        g_object_set_qdata (G_OBJECT (self),
-                            registration_check_context_quark,
-                            NULL);
-
     /* Unexport DBus interface and remove the skeleton */
     mm_gdbus_object_skeleton_set_modem3gpp (MM_GDBUS_OBJECT_SKELETON (self), NULL);
     g_object_set (self,