* cache the modest-conf keynames, so we don't have to re-calculate

  them all the time. this showed up high in oprofile, and indeed
  the cache seems to make things faster.

pmo-trunk-r3393

diff --git a/src/modest-account-mgr.c b/src/modest-account-mgr.c
index b9e6727..b43860f 100644 (file)
--- a/src/modest-account-mgr.c
+++ b/src/modest-account-mgr.c
@@ -39,6 +39,10 @@ static void modest_account_mgr_init       (ModestAccountMgr * obj);
 static void modest_account_mgr_finalize   (GObject * obj);
 static void modest_account_mgr_base_init  (gpointer g_class);
 
+static const gchar *
+_modest_account_mgr_get_account_keyname_cached (ModestAccountMgrPrivate *priv, const gchar* account_name,
+                                               const gchar *name, gboolean is_server);
+
 /* list my signals */
 enum {
        ACCOUNT_INSERTED_SIGNAL,
@@ -321,6 +325,21 @@ modest_account_mgr_init (ModestAccountMgr * obj)
        priv->timeout       = 0;
        
        priv->notification_id_accounts = g_hash_table_new_full (g_int_hash, g_int_equal, g_free, g_free);
+
+       /* we maintain hashes for the modest-conf keys we build from account name
+        * + key. many seem to be used often, and generating them showed up high
+        * in oprofile */
+       /* both hashes are hashes to hashes;
+        * account-key => keyname ==> account-key-name
+        */     
+       priv->server_account_key_hash = g_hash_table_new_full (g_str_hash,
+                                                              g_str_equal,
+                                                              g_free,
+                                                              (GDestroyNotify)g_hash_table_destroy);
+       priv->account_key_hash        = g_hash_table_new_full (g_str_hash,
+                                                              g_str_equal,
+                                                              g_free,
+                                                              (GDestroyNotify)g_hash_table_destroy);
 }
 
 static void
@@ -350,6 +369,15 @@ modest_account_mgr_finalize (GObject * obj)
                g_source_remove (priv->timeout);
        priv->timeout = 0;
 
+       if (priv->server_account_key_hash) {
+               g_hash_table_destroy (priv->server_account_key_hash);
+               priv->server_account_key_hash = NULL;
+       }
+       
+       if (priv->account_key_hash) {
+               g_hash_table_destroy (priv->account_key_hash);
+               priv->account_key_hash = NULL;
+       }
 
        G_OBJECT_CLASS(parent_class)->finalize (obj);
 }
@@ -393,7 +421,7 @@ modest_account_mgr_add_account (ModestAccountMgr *self,
                                gboolean enabled)
 {
        ModestAccountMgrPrivate *priv;
-       gchar *key;
+       const gchar *key;
        gboolean ok;
        gchar *default_account;
        GError *err = NULL;
@@ -408,15 +436,14 @@ modest_account_mgr_add_account (ModestAccountMgr *self,
         * we create the account by adding an account 'dir', with the name <name>,
         * and in that the 'display_name' string key
         */
-       key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_DISPLAY_NAME, FALSE);
+       key = _modest_account_mgr_get_account_keyname_cached (priv, name, MODEST_ACCOUNT_DISPLAY_NAME,
+                                                             FALSE);
        if (modest_account_mgr_account_exists (self, key, FALSE)) {
                g_printerr ("modest: account already exists\n");
-               g_free (key);
                return FALSE;
        }
        
        ok = modest_conf_set_string (priv->modest_conf, key, name, &err);
-       g_free (key);
        if (!ok) {
                g_printerr ("modest: cannot set display name\n");
                if (err) {
@@ -427,12 +454,12 @@ modest_account_mgr_add_account (ModestAccountMgr *self,
        }
        
        if (store_account) {
-               key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_STORE_ACCOUNT, FALSE);
+               key = _modest_account_mgr_get_account_keyname_cached (priv, name, MODEST_ACCOUNT_STORE_ACCOUNT,
+                                                                     FALSE);
                ok = modest_conf_set_string (priv->modest_conf, key, store_account, &err);
-               g_free (key);
                if (!ok) {
                        g_printerr ("modest: failed to set store account '%s'\n",
-                               store_account);
+                                   store_account);
                        if (err) {
                                g_printerr ("modest: Error adding store account conf: %s\n", err->message);
                                g_error_free (err);
@@ -442,10 +469,10 @@ modest_account_mgr_add_account (ModestAccountMgr *self,
        }
        
        if (transport_account) {
-               key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_TRANSPORT_ACCOUNT,
-                                                              FALSE);
+               key = _modest_account_mgr_get_account_keyname_cached (priv, name,
+                                                                     MODEST_ACCOUNT_TRANSPORT_ACCOUNT,
+                                                                     FALSE);
                ok = modest_conf_set_string (priv->modest_conf, key, transport_account, &err);
-               g_free (key);
                if (!ok) {
                        g_printerr ("modest: failed to set transport account '%s'\n",
                                    transport_account);
@@ -463,7 +490,6 @@ modest_account_mgr_add_account (ModestAccountMgr *self,
        modest_account_mgr_set_bool (self, name,
                MODEST_ACCOUNT_LEAVE_ON_SERVER, TRUE, FALSE /* not server account */);
 
-
        modest_account_mgr_set_enabled (self, name, enabled);
 
        /* Notify the observers */
@@ -489,7 +515,7 @@ modest_account_mgr_add_server_account (ModestAccountMgr * self,
                                       ModestAuthProtocol auth)
 {
        ModestAccountMgrPrivate *priv;
-       gchar *key;
+       const gchar *key;
        gboolean ok = TRUE;
        GError *err = NULL;
 
@@ -500,10 +526,9 @@ modest_account_mgr_add_server_account (ModestAccountMgr * self,
        priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 
        /* hostname */
-       key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_HOSTNAME, TRUE);
+       key = _modest_account_mgr_get_account_keyname_cached (priv, name, MODEST_ACCOUNT_HOSTNAME, TRUE);
        if (modest_conf_key_exists (priv->modest_conf, key, &err)) {
                g_printerr ("modest: server account '%s' already exists\n", name);
-               g_free (key);
                ok =  FALSE;
        }
        if (!ok)
@@ -515,37 +540,34 @@ modest_account_mgr_add_server_account (ModestAccountMgr * self,
                g_error_free (err);
                ok = FALSE;
        }
-       g_free (key);
        if (!ok)
                goto cleanup;
        
        /* username */
-       key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_USERNAME, TRUE);
+       key = _modest_account_mgr_get_account_keyname_cached (priv, name, MODEST_ACCOUNT_USERNAME, TRUE);
        ok = modest_conf_set_string (priv->modest_conf, key, null_means_empty (username), &err);
        if (err) {
                g_printerr ("modest: failed to set %s: %s\n", key, err->message);
                g_error_free (err);
                ok = FALSE;
        }
-       g_free (key);
        if (!ok)
                goto cleanup;
        
        
        /* password */
-       key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_PASSWORD, TRUE);
+       key = _modest_account_mgr_get_account_keyname_cached (priv, name, MODEST_ACCOUNT_PASSWORD, TRUE);
        ok = modest_conf_set_string (priv->modest_conf, key, null_means_empty (password), &err);
        if (err) {
                g_printerr ("modest: failed to set %s: %s\n", key, err->message);
                g_error_free (err);
                ok = FALSE;
        }
-       g_free (key);
        if (!ok)
                goto cleanup;
 
        /* proto */
-       key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_PROTO, TRUE);
+       key = _modest_account_mgr_get_account_keyname_cached (priv, name, MODEST_ACCOUNT_PROTO, TRUE);
        ok = modest_conf_set_string (priv->modest_conf, key,
                                     modest_protocol_info_get_transport_store_protocol_name(proto),
                                     &err);
@@ -554,26 +576,24 @@ modest_account_mgr_add_server_account (ModestAccountMgr * self,
                g_error_free (err);
                ok = FALSE;
        }
-       g_free (key);
        if (!ok)
                goto cleanup;
 
 
        /* portnumber */
-       key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_PORT, TRUE);
+       key = _modest_account_mgr_get_account_keyname_cached (priv, name, MODEST_ACCOUNT_PORT, TRUE);
        ok = modest_conf_set_int (priv->modest_conf, key, portnumber, &err);
        if (err) {
                g_printerr ("modest: failed to set %s: %s\n", key, err->message);
                g_error_free (err);
                ok = FALSE;
        }
-       g_free (key);
        if (!ok)
                goto cleanup;
 
        
        /* auth mechanism */
-       key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_AUTH_MECH, TRUE);
+       key = _modest_account_mgr_get_account_keyname_cached (priv, name, MODEST_ACCOUNT_AUTH_MECH, TRUE);
        ok = modest_conf_set_string (priv->modest_conf, key,
                                     modest_protocol_info_get_auth_protocol_name (auth),
                                     &err);
@@ -582,7 +602,6 @@ modest_account_mgr_add_server_account (ModestAccountMgr * self,
                g_error_free (err);
                ok = FALSE;
        }
-       g_free (key);
        if (!ok)
                goto cleanup;
        
@@ -607,7 +626,7 @@ modest_account_mgr_add_server_account_uri (ModestAccountMgr * self,
                                           const gchar *uri)
 {
        ModestAccountMgrPrivate *priv;
-       gchar *key;
+       const gchar *key;
        gboolean ok;
        
        g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), FALSE);
@@ -617,13 +636,11 @@ modest_account_mgr_add_server_account_uri (ModestAccountMgr * self,
        
        priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
        
-       
        /* proto */
-       key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_PROTO, TRUE);
+       key = _modest_account_mgr_get_account_keyname_cached (priv, name, MODEST_ACCOUNT_PROTO, TRUE);
        ok = modest_conf_set_string (priv->modest_conf, key,
                                     modest_protocol_info_get_transport_store_protocol_name(proto),
                                     NULL);
-       g_free (key);
 
        if (!ok) {
                g_printerr ("modest: failed to set proto\n");
@@ -631,9 +648,8 @@ modest_account_mgr_add_server_account_uri (ModestAccountMgr * self,
        }
        
        /* uri */
-       key = _modest_account_mgr_get_account_keyname (name, MODEST_ACCOUNT_URI, TRUE);
+       key = _modest_account_mgr_get_account_keyname_cached (priv, name, MODEST_ACCOUNT_URI, TRUE);
        ok = modest_conf_set_string (priv->modest_conf, key, uri, NULL);
-       g_free (key);
 
        if (!ok) {
                g_printerr ("modest: failed to set uri\n");
@@ -651,16 +667,16 @@ real_remove_account (ModestConf *conf,
                     gboolean server_account)
 {
        GError *err = NULL;
-       gchar *key = NULL;
-
+       gchar *key;
+       
        key = _modest_account_mgr_get_account_keyname (acc_name, NULL, server_account);
        modest_conf_remove_key (conf, key, &err);
-       g_free (key);       
 
        if (err) {
                g_printerr ("modest: error removing key: %s\n", err->message);
                g_error_free (err);
        }
+       g_free (key);
 }
 
 gboolean
@@ -789,8 +805,9 @@ modest_account_mgr_account_names (ModestAccountMgr * self, gboolean only_enabled
                 * parent modest account already exists.
                 */
                if (add) {
-                       gchar* server_account_name = modest_account_mgr_get_string (self, account_name_key, MODEST_ACCOUNT_STORE_ACCOUNT,
-                                                                           FALSE);
+                       gchar* server_account_name = modest_account_mgr_get_string
+                               (self, account_name_key, MODEST_ACCOUNT_STORE_ACCOUNT,
+                                FALSE);
                        if (server_account_name) {
                                if (!modest_account_mgr_account_exists (self, server_account_name, TRUE))
                                        add = FALSE;
@@ -799,8 +816,9 @@ modest_account_mgr_account_names (ModestAccountMgr * self, gboolean only_enabled
                }
                
                if (add) {
-                       gchar* server_account_name = modest_account_mgr_get_string (self, account_name_key, MODEST_ACCOUNT_TRANSPORT_ACCOUNT,
-                                                                           FALSE);
+                       gchar* server_account_name = modest_account_mgr_get_string
+                               (self, account_name_key, MODEST_ACCOUNT_TRANSPORT_ACCOUNT,
+                                FALSE);
                        if (server_account_name) {
                                if (!modest_account_mgr_account_exists (self, server_account_name, TRUE))
                                        add = FALSE;
@@ -843,7 +861,7 @@ modest_account_mgr_get_string (ModestAccountMgr *self, const gchar *name,
 
        ModestAccountMgrPrivate *priv;
 
-       gchar *keyname;
+       const gchar *keyname;
        gchar *retval;
        GError *err = NULL;
 
@@ -851,7 +869,9 @@ modest_account_mgr_get_string (ModestAccountMgr *self, const gchar *name,
        g_return_val_if_fail (name, NULL);
        g_return_val_if_fail (key, NULL);
 
-       keyname = _modest_account_mgr_get_account_keyname (name, key, server_account);
+       priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
+       
+       keyname = _modest_account_mgr_get_account_keyname_cached (priv, name, key, server_account);
        
        priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
        retval = modest_conf_get_string (priv->modest_conf, keyname, &err);     
@@ -860,7 +880,6 @@ modest_account_mgr_get_string (ModestAccountMgr *self, const gchar *name,
                g_error_free (err);
                retval = NULL;
        }
-       g_free (keyname);
 
        return retval;
 }
@@ -882,7 +901,7 @@ modest_account_mgr_get_int (ModestAccountMgr *self, const gchar *name, const gch
 {
        ModestAccountMgrPrivate *priv;
 
-       gchar *keyname;
+       const gchar *keyname;
        gint retval;
        GError *err = NULL;
        
@@ -890,16 +909,16 @@ modest_account_mgr_get_int (ModestAccountMgr *self, const gchar *name, const gch
        g_return_val_if_fail (name, -1);
        g_return_val_if_fail (key, -1);
 
-       keyname = _modest_account_mgr_get_account_keyname (name, key, server_account);
-
        priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
+
+       keyname = _modest_account_mgr_get_account_keyname_cached (priv, name, key, server_account);
+       
        retval = modest_conf_get_int (priv->modest_conf, keyname, &err);
        if (err) {
                g_printerr ("modest: error getting int '%s': %s\n", keyname, err->message);
                g_error_free (err);
                retval = -1;
        }
-       g_free (keyname);
 
        return retval;
 }
@@ -912,7 +931,7 @@ modest_account_mgr_get_bool (ModestAccountMgr * self, const gchar *account,
 {
        ModestAccountMgrPrivate *priv;
 
-       gchar *keyname;
+       const gchar *keyname;
        gboolean retval;
        GError *err = NULL;
 
@@ -920,16 +939,17 @@ modest_account_mgr_get_bool (ModestAccountMgr * self, const gchar *account,
        g_return_val_if_fail (account, FALSE);
        g_return_val_if_fail (key, FALSE);
 
-       keyname = _modest_account_mgr_get_account_keyname (account, key, server_account);
-       
        priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
+       ///keyname = _modest_account_mgr_get_account_keyname (account, key, server_account);
+
+       keyname = _modest_account_mgr_get_account_keyname_cached (priv, account, key, server_account);
+               
        retval = modest_conf_get_bool (priv->modest_conf, keyname, &err);               
        if (err) {
                g_printerr ("modest: error getting bool '%s': %s\n", keyname, err->message);
                g_error_free (err);
                retval = FALSE;
        }
-       g_free (keyname);
 
        return retval;
 }
@@ -943,15 +963,16 @@ modest_account_mgr_get_list (ModestAccountMgr *self, const gchar *name,
 {
        ModestAccountMgrPrivate *priv;
 
-       gchar *keyname;
+       const gchar *keyname;
        GSList *retval;
        GError *err = NULL;
        
        g_return_val_if_fail (MODEST_IS_ACCOUNT_MGR(self), NULL);
        g_return_val_if_fail (name, NULL);
        g_return_val_if_fail (key, NULL);
-
-       keyname = _modest_account_mgr_get_account_keyname (name, key, server_account);
+       
+       keyname = _modest_account_mgr_get_account_keyname_cached (priv, name, key,
+                                                                 server_account);
        
        priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
        retval = modest_conf_get_list (priv->modest_conf, keyname, list_type, &err);
@@ -961,8 +982,6 @@ modest_account_mgr_get_list (ModestAccountMgr *self, const gchar *name,
                g_error_free (err);
                retval = FALSE;
        }
-       g_free (keyname);
-
        return retval;
 }
 
@@ -973,7 +992,7 @@ modest_account_mgr_set_string (ModestAccountMgr * self, const gchar * name,
 {
        ModestAccountMgrPrivate *priv;
 
-       gchar *keyname;
+       const gchar *keyname;
        gboolean retval;
        GError *err = NULL;
 
@@ -981,17 +1000,16 @@ modest_account_mgr_set_string (ModestAccountMgr * self, const gchar * name,
        g_return_val_if_fail (name, FALSE);
        g_return_val_if_fail (key, FALSE);
 
-       keyname = _modest_account_mgr_get_account_keyname (name, key, server_account);
-       
        priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 
+       keyname = _modest_account_mgr_get_account_keyname_cached (priv, name, key, server_account);
+       
        retval = modest_conf_set_string (priv->modest_conf, keyname, val, &err);
        if (err) {
                g_printerr ("modest: error setting string '%s': %s\n", keyname, err->message);
                g_error_free (err);
                retval = FALSE;
        }
-       g_free (keyname);       
        return retval;
 }
 
@@ -1011,7 +1029,7 @@ modest_account_mgr_set_int (ModestAccountMgr * self, const gchar * name,
 {
        ModestAccountMgrPrivate *priv;
 
-       gchar *keyname;
+       const gchar *keyname;
        gboolean retval;
        GError *err = NULL;
        
@@ -1019,17 +1037,16 @@ modest_account_mgr_set_int (ModestAccountMgr * self, const gchar * name,
        g_return_val_if_fail (name, FALSE);
        g_return_val_if_fail (key, FALSE);
 
-       keyname = _modest_account_mgr_get_account_keyname (name, key, server_account);
-       
        priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
 
+       keyname = _modest_account_mgr_get_account_keyname_cached (priv, name, key, server_account);
+       
        retval = modest_conf_set_int (priv->modest_conf, keyname, val, &err);
        if (err) {
                g_printerr ("modest: error setting int '%s': %s\n", keyname, err->message);
                g_error_free (err);
                retval = FALSE;
        }
-       g_free (keyname);
        return retval;
 }
 
@@ -1041,7 +1058,7 @@ modest_account_mgr_set_bool (ModestAccountMgr * self, const gchar * name,
 {
        ModestAccountMgrPrivate *priv;
 
-       gchar *keyname;
+       const gchar *keyname;
        gboolean retval;
        GError *err = NULL;
 
@@ -1049,17 +1066,16 @@ modest_account_mgr_set_bool (ModestAccountMgr * self, const gchar * name,
        g_return_val_if_fail (name, FALSE);
        g_return_val_if_fail (key, FALSE);
 
-       keyname = _modest_account_mgr_get_account_keyname (name, key, server_account);
-
        priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
-
+       keyname = _modest_account_mgr_get_account_keyname_cached (priv, name, key, server_account);
+       
        retval = modest_conf_set_bool (priv->modest_conf, keyname, val, &err);
        if (err) {
                g_printerr ("modest: error setting bool '%s': %s\n", keyname, err->message);
                g_error_free (err);
                retval = FALSE;
        }
-       g_free (keyname);
+
        return retval;
 }
 
@@ -1073,7 +1089,7 @@ modest_account_mgr_set_list (ModestAccountMgr *self,
                             gboolean server_account)
 {
        ModestAccountMgrPrivate *priv;
-       gchar *keyname;
+       const gchar *keyname;
        GError *err = NULL;
        gboolean retval;
        
@@ -1082,16 +1098,16 @@ modest_account_mgr_set_list (ModestAccountMgr *self,
        g_return_val_if_fail (key,  FALSE);
        g_return_val_if_fail (val,  FALSE);
 
-       keyname = _modest_account_mgr_get_account_keyname (name, key, server_account);
-       
        priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
+
+       keyname = _modest_account_mgr_get_account_keyname_cached (priv, name, key, server_account);
+       
        retval = modest_conf_set_list (priv->modest_conf, keyname, val, list_type, &err);
        if (err) {
                g_printerr ("modest: error setting list '%s': %s\n", keyname, err->message);
                g_error_free (err);
                retval = FALSE;
        }
-       g_free (keyname);
 
        return retval;
 }
@@ -1102,15 +1118,15 @@ modest_account_mgr_account_exists (ModestAccountMgr * self, const gchar* name,
 {
        ModestAccountMgrPrivate *priv;
 
-       gchar *keyname;
+       const gchar *keyname;
        gboolean retval;
        GError *err = NULL;
 
        g_return_val_if_fail (self, FALSE);
         g_return_val_if_fail (name, FALSE);
 
-       keyname = _modest_account_mgr_get_account_keyname (name, NULL, server_account);
        priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
+       keyname = _modest_account_mgr_get_account_keyname_cached (priv, name, NULL, server_account);
        retval = modest_conf_key_exists (priv->modest_conf, keyname, &err);
        if (err) {
                g_printerr ("modest: error determining existance of '%s': %s\n", keyname,
@@ -1118,7 +1134,6 @@ modest_account_mgr_account_exists (ModestAccountMgr * self, const gchar* name,
                g_error_free (err);
                retval = FALSE;
        }
-       g_free (keyname);
        return retval;
 }
 
@@ -1166,7 +1181,7 @@ modest_account_mgr_unset (ModestAccountMgr *self, const gchar *name,
 {
        ModestAccountMgrPrivate *priv;
        
-       gchar *keyname;
+       const gchar *keyname;
        gboolean retval;
        GError *err = NULL;
        
@@ -1174,9 +1189,9 @@ modest_account_mgr_unset (ModestAccountMgr *self, const gchar *name,
         g_return_val_if_fail (name, FALSE);
         g_return_val_if_fail (key, FALSE);
 
-       keyname = _modest_account_mgr_get_account_keyname (name, key, server_account);
-
        priv = MODEST_ACCOUNT_MGR_GET_PRIVATE (self);
+       keyname = _modest_account_mgr_get_account_keyname_cached (priv, name, key, server_account);
+
        retval = modest_conf_remove_key (priv->modest_conf, keyname, &err);
        if (err) {
                g_printerr ("modest: error unsetting'%s': %s\n", keyname,
@@ -1184,7 +1199,6 @@ modest_account_mgr_unset (ModestAccountMgr *self, const gchar *name,
                g_error_free (err);
                retval = FALSE;
        }
-       g_free (keyname);
        return retval;
 }
 
@@ -1245,6 +1259,7 @@ _modest_account_mgr_account_from_key (const gchar *key, gboolean *is_account_key
 
 
 
+
 /* optimization: only with non-alphanum chars, escaping is needed */
 inline static gboolean
 is_alphanum (const gchar* str)
@@ -1261,9 +1276,12 @@ is_alphanum (const gchar* str)
 }
                
 
+
+
 /* must be freed by caller */
 gchar *
-_modest_account_mgr_get_account_keyname (const gchar *account_name, const gchar * name, gboolean server_account)
+_modest_account_mgr_get_account_keyname (const gchar *account_name, const gchar* name,
+                                        gboolean server_account)
 {
        gchar *retval = NULL;   
        gchar *namespace = server_account ? MODEST_SERVER_ACCOUNT_NAMESPACE : MODEST_ACCOUNT_NAMESPACE;
@@ -1271,7 +1289,7 @@ _modest_account_mgr_get_account_keyname (const gchar *account_name, const gchar
        
        if (!account_name)
                return g_strdup (namespace);
-       
+
        /* optimization: only escape names when need to be escaped */
        if (is_alphanum (account_name))
                escaped_account_name = (gchar*)account_name;
@@ -1295,16 +1313,73 @@ _modest_account_mgr_get_account_keyname (const gchar *account_name, const gchar
                g_free (retval);
                retval = NULL;
        }
-
+       
        /* g_free is only needed if we actually allocated anything */
        if (name != escaped_name)
                g_free (escaped_name);
        if (account_name != escaped_account_name)
                g_free (escaped_account_name);
-       
+
        return retval;
 }
 
+
+#if 0
+static void
+f2 (gchar*key, gchar* val, gpointer user_data)
+{
+       g_debug (">>%s:%s", key, val);
+}
+
+
+static void
+f1 (gchar*key, GHashTable* h, gpointer user_data)
+{
+       g_debug (">%s", key);
+       g_hash_table_foreach (h, (GHFunc)f2, NULL);
+}
+#endif 
+
+
+static const gchar *
+_modest_account_mgr_get_account_keyname_cached (ModestAccountMgrPrivate *priv, const gchar* account_name,
+                                               const gchar *name, gboolean is_server)
+{
+       //return _modest_account_mgr_get_account_keyname (account_name, name, is_server);
+       
+       
+       GHashTable *hash = is_server ? priv->server_account_key_hash : priv->account_key_hash;
+       GHashTable *account_hash;
+       gchar *key = NULL;
+       const gchar *search_name;
+       
+       //g_hash_table_foreach (hash, (GHFunc)f1, NULL); 
+
+       if (!account_name)
+               return is_server ? MODEST_SERVER_ACCOUNT_NAMESPACE : MODEST_ACCOUNT_NAMESPACE;
+
+       search_name = name ? name : "<dummy>";
+       
+       account_hash = g_hash_table_lookup (hash, account_name);        
+       if (!account_hash) { /* no hash for this account yet? create it */
+               account_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);         
+               key = _modest_account_mgr_get_account_keyname (account_name, name, is_server);
+               g_hash_table_insert (account_hash, g_strdup(search_name), key);
+               g_hash_table_insert (hash, g_strdup(account_name), account_hash);
+               return key;
+       }
+       
+       /* we have a hash for this account, but do we have the key? */  
+       key = g_hash_table_lookup (account_hash, search_name);
+       if (!key) {
+               key = _modest_account_mgr_get_account_keyname (account_name, name, is_server);
+               g_hash_table_insert (account_hash, g_strdup(search_name), key);
+       }
+       
+       return key;
+}
+
+
 gboolean
 modest_account_mgr_has_accounts (ModestAccountMgr* self, gboolean enabled)
 {