Merge branch 'empathy-account'

23 files changed, 1070 insertions, 494 deletions

diff --git a/libempathy/Makefile.am b/libempathy/Makefile.am
index 2877dc6ae..27671543a 100644
--- a/libempathy/Makefile.am
+++ b/libempathy/Makefile.am
@@ -24,6 +24,8 @@ BUILT_SOURCES = 					\
 lib_LTLIBRARIES = libempathy.la
 
 libempathy_la_SOURCES =					\
+	empathy-account.c			\
+	empathy-account-priv.h			\
 	empathy-account-manager.c			\
 	empathy-chatroom.c				\
 	empathy-chatroom-manager.c			\
@@ -74,6 +76,7 @@ libempathy_la_LDFLAGS =		\
        -export-symbols-regex ^empathy_
 
 libempathy_headers =				\
+	empathy-account.h		\
 	empathy-account-manager.h		\
 	empathy-chatroom.h			\
 	empathy-chatroom-manager.h		\
diff --git a/libempathy/empathy-account-manager.c b/libempathy/empathy-account-manager.c
index ff9fd2525..fd8a21b1d 100644
--- a/libempathy/empathy-account-manager.c
+++ b/libempathy/empathy-account-manager.c
@@ -16,6 +16,7 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  *
  * Authors: Cosimo Cecchi <cosimo.cecchi@collabora.co.uk>
+ *          Sjoerd Simons <sjoerd.simons@collabora.co.uk>
  */
 
 #include "config.h"
@@ -23,6 +24,7 @@
 #include <libmissioncontrol/mc-account-monitor.h>
 
 #include "empathy-account-manager.h"
+#include "empathy-account-priv.h"
 #include "empathy-marshal.h"
 #include "empathy-utils.h"
 
@@ -35,22 +37,13 @@ typedef struct {
   McAccountMonitor *monitor;
   MissionControl   *mc;
 
-  GHashTable       *accounts; /* McAccount -> AccountData */
-  GHashTable       *connections; /* TpConnection -> McAccount */
+  /* (owned) unique name -> (reffed) EmpathyAccount */
+  GHashTable       *accounts;
   int               connected;
   int               connecting;
   gboolean          dispose_run;
 } EmpathyAccountManagerPriv;
 
-typedef struct {
-  TpConnection *connection;
-  TpConnectionPresenceType presence;
-  TpConnectionStatus status;
-  gboolean is_enabled;
-
-  guint source_id;
-} AccountData;
-
 enum {
   ACCOUNT_CREATED,
   ACCOUNT_DELETED,
@@ -68,122 +61,154 @@ static EmpathyAccountManager *manager_singleton = NULL;
 
 G_DEFINE_TYPE (EmpathyAccountManager, empathy_account_manager, G_TYPE_OBJECT);
 
-static AccountData *
-account_data_new (McPresence presence,
-                  TpConnectionStatus status,
-                  gboolean is_enabled)
+static TpConnectionPresenceType
+mc_presence_to_tp_presence (McPresence presence)
 {
-  AccountData *retval;
+  switch (presence)
+    {
+      case MC_PRESENCE_OFFLINE:
+        return TP_CONNECTION_PRESENCE_TYPE_OFFLINE;
+      case MC_PRESENCE_AVAILABLE:
+        return TP_CONNECTION_PRESENCE_TYPE_AVAILABLE;
+      case MC_PRESENCE_AWAY:
+        return TP_CONNECTION_PRESENCE_TYPE_AWAY;
+      case MC_PRESENCE_EXTENDED_AWAY:
+        return TP_CONNECTION_PRESENCE_TYPE_EXTENDED_AWAY;
+      case MC_PRESENCE_HIDDEN:
+        return TP_CONNECTION_PRESENCE_TYPE_HIDDEN;
+      case MC_PRESENCE_DO_NOT_DISTURB:
+        return TP_CONNECTION_PRESENCE_TYPE_BUSY;
+      default:
+        return TP_CONNECTION_PRESENCE_TYPE_UNSET;
+    }
+}
 
-  retval = g_slice_new0 (AccountData);
-  retval->presence = presence;
-  retval->status = status;
-  retval->is_enabled = is_enabled;
-  retval->source_id = 0;
+static void
+emp_account_connection_cb (EmpathyAccount *account,
+  GParamSpec *spec,
+  gpointer manager)
+{
+  TpConnection *connection = empathy_account_get_connection (account);
 
-  return retval;
+  DEBUG ("Signalling connection %p of account %s",
+      connection, empathy_account_get_unique_name (account));
+
+  if (connection != NULL)
+    g_signal_emit (manager, signals[NEW_CONNECTION], 0, connection);
 }
 
-static AccountData *
-account_data_new_default (MissionControl *mc,
-                          McAccount *account)
+static void
+emp_account_status_changed_cb (EmpathyAccount *account,
+  TpConnectionStatus old,
+  TpConnectionStatus new,
+  TpConnectionStatusReason reason,
+  gpointer user_data)
 {
-  McPresence actual_p;
-  TpConnectionStatus actual_c;
-  GError *err = NULL;
+  EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (user_data);
+  EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 
-  actual_p = mission_control_get_presence_actual (mc, &err);
-  if (err != NULL)
+  switch (old)
     {
-      actual_p = MC_PRESENCE_UNSET;
-      g_clear_error (&err);
+      case TP_CONNECTION_STATUS_CONNECTING:
+        priv->connecting--;
+        break;
+      case TP_CONNECTION_STATUS_CONNECTED:
+        priv->connected--;
+        break;
+      default:
+        break;
     }
 
-  actual_c = mission_control_get_connection_status (mc, account, &err);
-
-  if (err != NULL)
+  switch (new)
     {
-      actual_c = TP_CONNECTION_STATUS_DISCONNECTED;
-      g_error_free (err);
+      case TP_CONNECTION_STATUS_CONNECTING:
+        priv->connecting++;
+        break;
+      case TP_CONNECTION_STATUS_CONNECTED:
+        priv->connected++;
+        break;
+      default:
+        break;
     }
 
-  return account_data_new (actual_p, actual_c, mc_account_is_enabled (account));
+  g_signal_emit (manager, signals[ACCOUNT_CONNECTION_CHANGED], 0,
+    account, reason, new, old);
 }
 
 static void
-account_data_free (AccountData *data)
+emp_account_presence_changed_cb (EmpathyAccount *account,
+  TpConnectionPresenceType old,
+  TpConnectionPresenceType new,
+  gpointer user_data)
 {
-  if (data->source_id > 0)
-    {
-      g_source_remove (data->source_id);
-      data->source_id = 0;
-    }
-  if (data->connection != NULL)
-    {
-      g_object_unref (data->connection);
-      data->connection = NULL;
-    }
-
-  g_slice_free (AccountData, data);
+  EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (user_data);
+  g_signal_emit (manager, signals[ACCOUNT_PRESENCE_CHANGED], 0,
+    account, new, old);
 }
 
-static void
-connection_invalidated_cb (TpProxy *connection,
-                           guint    domain,
-                           gint     code,
-                           gchar   *message,
-                           EmpathyAccountManager *manager)
+static EmpathyAccount *
+create_account (EmpathyAccountManager *manager,
+  const gchar *account_name,
+  McAccount *mc_account)
 {
   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
-  McAccount *account;
-  AccountData *data;
-
-  DEBUG ("Message: %s", message);
+  EmpathyAccount *account;
+  TpConnectionStatus status;
+  TpConnectionPresenceType presence;
+  McPresence mc_presence;
+  TpConnection *connection;
+  GError *error = NULL;
 
-  account = g_hash_table_lookup (priv->connections, connection);
-  g_assert (account != NULL);
+  if ((account = g_hash_table_lookup (priv->accounts, account_name)) != NULL)
+    return account;
 
-  data = g_hash_table_lookup (priv->accounts, account);
-  g_assert (data != NULL);
+  account = _empathy_account_new (mc_account);
+  g_hash_table_insert (priv->accounts, g_strdup (account_name),
+    account);
 
-  g_object_unref (data->connection);
-  data->connection = NULL;
+  _empathy_account_set_enabled (account,
+      mc_account_is_enabled (mc_account));
 
-  g_hash_table_remove (priv->connections, connection);
-}
+  g_signal_emit (manager, signals[ACCOUNT_CREATED], 0, account);
 
-static void
-connection_ready_cb (TpConnection *connection,
-                     const GError *error,
-                     gpointer manager)
-{
-  /* Errors will be handled in invalidated callback */
-  if (error != NULL)
-    return;
+  g_signal_connect (account, "notify::connection",
+    G_CALLBACK (emp_account_connection_cb), manager);
 
-  g_signal_emit (manager, signals[NEW_CONNECTION], 0, connection);
-}
+  connection = mission_control_get_tpconnection (priv->mc,
+    mc_account, NULL);
+  _empathy_account_set_connection (account, connection);
 
-static void
-account_manager_update_connection (EmpathyAccountManager *manager,
-                                   AccountData *data,
-                                   McAccount *account)
-{
-  EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
+  status = mission_control_get_connection_status (priv->mc,
+     mc_account, &error);
 
-  if (data->connection)
-    return;
+  if (error != NULL)
+    {
+      status = TP_CONNECTION_STATUS_DISCONNECTED;
+      g_clear_error (&error);
+    }
 
-  data->connection = mission_control_get_tpconnection (priv->mc, account, NULL);
-  if (data->connection != NULL)
+  mc_presence = mission_control_get_presence_actual (priv->mc, &error);
+  if (error != NULL)
+    {
+      presence = TP_CONNECTION_PRESENCE_TYPE_UNSET;
+      g_clear_error (&error);
+    }
+  else
     {
-      g_signal_connect (data->connection, "invalidated",
-          G_CALLBACK (connection_invalidated_cb), manager);
-      g_hash_table_insert (priv->connections, g_object_ref (data->connection),
-          g_object_ref (account));
-      tp_connection_call_when_ready (data->connection, connection_ready_cb,
-          manager);
+      presence = mc_presence_to_tp_presence (mc_presence);
     }
+
+  g_signal_connect (account, "status-changed",
+    G_CALLBACK (emp_account_status_changed_cb), manager);
+
+  g_signal_connect (account, "presence-changed",
+    G_CALLBACK (emp_account_presence_changed_cb), manager);
+
+  _empathy_account_set_status (account, status,
+    TP_CONNECTION_STATUS_REASON_NONE_SPECIFIED,
+    presence);
+
+  return account;
 }
 
 static void
@@ -191,32 +216,10 @@ account_created_cb (McAccountMonitor *mon,
                     gchar *account_name,
                     EmpathyAccountManager *manager)
 {
-  McAccount *account;
-  EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
-  TpConnectionStatus initial_status;
-
-  account = mc_account_lookup (account_name);
-
-  if (account)
-    {
-      AccountData *data;
-
-      data = account_data_new_default (priv->mc, account);
-      g_hash_table_insert (priv->accounts, g_object_ref (account), data);
-
-      initial_status = mission_control_get_connection_status (priv->mc,
-							      account, NULL);
-
-      if (initial_status == TP_CONNECTION_STATUS_CONNECTED)
-	priv->connected++;
-      else if (initial_status == TP_CONNECTION_STATUS_CONNECTING)
-	priv->connecting++;
-
-      account_manager_update_connection (manager, data, account);
+  McAccount *mc_account = mc_account_lookup (account_name);
 
-      g_signal_emit (manager, signals[ACCOUNT_CREATED], 0, account);
-      g_object_unref (account);
-    }
+  if (mc_account != NULL)
+    create_account (manager, account_name, mc_account);
 }
 
 static void
@@ -224,16 +227,15 @@ account_deleted_cb (McAccountMonitor *mon,
                     gchar *account_name,
                     EmpathyAccountManager *manager)
 {
-  McAccount *account;
   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
+  EmpathyAccount *account;
 
-  account = mc_account_lookup (account_name);
+  account = g_hash_table_lookup (priv->accounts, account_name);
 
   if (account)
     {
-      g_hash_table_remove (priv->accounts, account);
       g_signal_emit (manager, signals[ACCOUNT_DELETED], 0, account);
-      g_object_unref (account);
+      g_hash_table_remove (priv->accounts, account_name);
     }
 }
 
@@ -242,15 +244,13 @@ account_changed_cb (McAccountMonitor *mon,
                     gchar *account_name,
                     EmpathyAccountManager *manager)
 {
-  McAccount *account;
+  EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
+  EmpathyAccount *account;
 
-  account = mc_account_lookup (account_name);
+  account = g_hash_table_lookup (priv->accounts, account_name);
 
-  if (account)
-    {
-      g_signal_emit (manager, signals[ACCOUNT_CHANGED], 0, account);
-      g_object_unref (account);
-    }
+  if (account != NULL)
+    g_signal_emit (manager, signals[ACCOUNT_CHANGED], 0, account);
 }
 
 static void
@@ -258,20 +258,15 @@ account_disabled_cb (McAccountMonitor *mon,
                      gchar *account_name,
                      EmpathyAccountManager *manager)
 {
-  McAccount *account;
   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
-  AccountData *data;
+  EmpathyAccount *account;
 
-  account = mc_account_lookup (account_name);
+  account = g_hash_table_lookup (priv->accounts, account_name);
 
   if (account)
     {
-      data = g_hash_table_lookup (priv->accounts, account);
-      g_assert (data);
-      data->is_enabled = FALSE;
-
+      _empathy_account_set_enabled (account, FALSE);
       g_signal_emit (manager, signals[ACCOUNT_DISABLED], 0, account);
-      g_object_unref (account);
     }
 }
 
@@ -280,135 +275,60 @@ account_enabled_cb (McAccountMonitor *mon,
                     gchar *account_name,
                     EmpathyAccountManager *manager)
 {
-  McAccount *account;
   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
-  AccountData *data;
+  EmpathyAccount *account;
 
-  account = mc_account_lookup (account_name);
+  account = g_hash_table_lookup (priv->accounts, account_name);
 
   if (account)
     {
-      data = g_hash_table_lookup (priv->accounts, account);
-      g_assert (data);
-      data->is_enabled = TRUE;
-
+      _empathy_account_set_enabled (account, TRUE);
       g_signal_emit (manager, signals[ACCOUNT_ENABLED], 0, account);
-      g_object_unref (account);
     }
 }
 
-static void
-update_connection_numbers (EmpathyAccountManager *manager,
-                           TpConnectionStatus status,
-                           TpConnectionStatus old_s)
-{
-  EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
-
-  if (status == TP_CONNECTION_STATUS_CONNECTED)
-    {
-      priv->connected++;
-      if (old_s == TP_CONNECTION_STATUS_CONNECTING)
-        priv->connecting--;
-    }
-
-  if (status == TP_CONNECTION_STATUS_CONNECTING)
-    {
-      priv->connecting++;
-      if (old_s == TP_CONNECTION_STATUS_CONNECTED)
-        priv->connected--;
-    }
-
-  if (status == TP_CONNECTION_STATUS_DISCONNECTED)
-    {
-      if (old_s == TP_CONNECTION_STATUS_CONNECTED)
-        priv->connected--;
-
-      if (old_s == TP_CONNECTION_STATUS_CONNECTING)
-        priv->connecting--;
-    }
-}
-
-static gboolean
-remove_data_timeout (gpointer _data)
-{
-  AccountData *data = _data;
-
-  data->source_id = 0;
-
-  return FALSE;
-}
-
 typedef struct {
   TpConnectionStatus status;
-  McPresence presence;
+  TpConnectionPresenceType presence;
   TpConnectionStatusReason reason;
   gchar *unique_name;
   EmpathyAccountManager *manager;
+  McAccount *mc_account;
 } ChangedSignalData;
 
 static gboolean
 account_status_changed_idle_cb (ChangedSignalData *signal_data)
 {
-  McAccount *account;
-  AccountData *data;
-  McPresence presence, old_p;
-  TpConnectionStatus status, old_s;
-  gboolean emit_presence = FALSE, emit_connection = FALSE;
+  EmpathyAccount *account;
   EmpathyAccountManager *manager = signal_data->manager;
   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 
-  presence = signal_data->presence;
-  status = signal_data->status;
-  account = mc_account_lookup (signal_data->unique_name);
+  account = g_hash_table_lookup (priv->accounts,
+    signal_data->unique_name);
 
   if (account)
     {
-      data = g_hash_table_lookup (priv->accounts, account);
-      g_assert (data);
-
-      old_p = data->presence;
-      old_s = data->status;
-
-      if (old_p != presence)
+      if (empathy_account_get_connection (account) == NULL)
         {
-          data->presence = presence;
-          emit_presence = TRUE;
-        }
+          TpConnection *connection;
 
-      if (old_s != status)
-        {
-          data->status = status;
-          update_connection_numbers (manager, status, old_s);
+          connection = mission_control_get_tpconnection (priv->mc,
+             signal_data->mc_account, NULL);
 
-          if (status == TP_CONNECTION_STATUS_CONNECTED)
+          if (connection != NULL)
             {
-                if (data->source_id > 0)
-                  {
-                    g_source_remove (data->source_id);
-                    data->source_id = 0;
-                  }
-
-                data->source_id = g_timeout_add_seconds (10,
-                                                         remove_data_timeout,
-                                                         data);
+              _empathy_account_set_connection (account, connection);
+              g_object_unref (connection);
             }
-          emit_connection = TRUE;
         }
 
-      account_manager_update_connection (manager, data, account);
-
-      if (emit_presence)
-        g_signal_emit (manager, signals[ACCOUNT_PRESENCE_CHANGED], 0,
-                       account, presence, old_p);
-
-      if (emit_connection)
-        g_signal_emit (manager, signals[ACCOUNT_CONNECTION_CHANGED], 0,
-                       account, signal_data->reason, status, old_s);
-
-      g_object_unref (account);
+      _empathy_account_set_status (account, signal_data->status,
+        signal_data->reason,
+        signal_data->presence);
     }
 
   g_object_unref (signal_data->manager);
+  g_object_unref (signal_data->mc_account);
   g_free (signal_data->unique_name);
   g_slice_free (ChangedSignalData, signal_data);
 
@@ -424,38 +344,18 @@ account_status_changed_cb (MissionControl *mc,
                            EmpathyAccountManager *manager)
 {
   ChangedSignalData *data;
-  TpConnectionPresenceType tp_presence;
 
-  switch (presence)
-    {
-      case MC_PRESENCE_OFFLINE:
-        tp_presence = TP_CONNECTION_PRESENCE_TYPE_OFFLINE;
-        break;
-      case MC_PRESENCE_AVAILABLE:
-        tp_presence = TP_CONNECTION_PRESENCE_TYPE_AVAILABLE;
-        break;
-      case MC_PRESENCE_AWAY:
-        tp_presence = TP_CONNECTION_PRESENCE_TYPE_AWAY;
-        break;
-      case MC_PRESENCE_EXTENDED_AWAY:
-        tp_presence = TP_CONNECTION_PRESENCE_TYPE_EXTENDED_AWAY;
-        break;
-      case MC_PRESENCE_HIDDEN:
-        tp_presence = TP_CONNECTION_PRESENCE_TYPE_HIDDEN;
-        break;
-      case MC_PRESENCE_DO_NOT_DISTURB:
-        tp_presence = TP_CONNECTION_PRESENCE_TYPE_BUSY;
-        break;
-      default:
-        tp_presence = TP_CONNECTION_PRESENCE_TYPE_UNSET;
-    }
+  DEBUG ("Status of account %s became "
+    "status: %d presence: %d reason: %d", unique_name, status,
+    presence, reason);
 
   data = g_slice_new0 (ChangedSignalData);
   data->status = status;
-  data->presence = tp_presence;
+  data->presence = mc_presence_to_tp_presence (presence);
   data->reason = reason;
   data->unique_name = g_strdup (unique_name);
   data->manager = g_object_ref (manager);
+  data->mc_account = mc_account_lookup (unique_name);
 
   g_idle_add ((GSourceFunc) account_status_changed_idle_cb, data);
 }
@@ -467,35 +367,33 @@ empathy_account_manager_init (EmpathyAccountManager *manager)
   GList *mc_accounts, *l;
 
   priv = G_TYPE_INSTANCE_GET_PRIVATE (manager,
-				      EMPATHY_TYPE_ACCOUNT_MANAGER, EmpathyAccountManagerPriv);
+      EMPATHY_TYPE_ACCOUNT_MANAGER, EmpathyAccountManagerPriv);
+
   manager->priv = priv;
   priv->monitor = mc_account_monitor_new ();
   priv->mc = empathy_mission_control_dup_singleton ();
   priv->connected = priv->connecting = 0;
   priv->dispose_run = FALSE;
 
-  priv->accounts = g_hash_table_new_full (empathy_account_hash,
-                                          empathy_account_equal,
-                                          g_object_unref,
-                                          (GDestroyNotify) account_data_free);
-  priv->connections = g_hash_table_new_full (g_direct_hash, g_direct_equal,
-                                             g_object_unref, g_object_unref);
+  priv->accounts = g_hash_table_new_full (g_str_hash, g_str_equal,
+      g_free, (GDestroyNotify) g_object_unref);
 
   mc_accounts = mc_accounts_list ();
 
   for (l = mc_accounts; l; l = l->next)
-    account_created_cb (priv->monitor, (char *) mc_account_get_unique_name (l->data), manager);
+    account_created_cb (priv->monitor,
+      (char *) mc_account_get_unique_name (l->data), manager);
 
   g_signal_connect (priv->monitor, "account-created",
-                    G_CALLBACK (account_created_cb), manager);
+      G_CALLBACK (account_created_cb), manager);
   g_signal_connect (priv->monitor, "account-deleted",
-                    G_CALLBACK (account_deleted_cb), manager);
+      G_CALLBACK (account_deleted_cb), manager);
   g_signal_connect (priv->monitor, "account-disabled",
-                    G_CALLBACK (account_disabled_cb), manager);
+      G_CALLBACK (account_disabled_cb), manager);
   g_signal_connect (priv->monitor, "account-enabled",
-                    G_CALLBACK (account_enabled_cb), manager);
+      G_CALLBACK (account_enabled_cb), manager);
   g_signal_connect (priv->monitor, "account-changed",
-                    G_CALLBACK (account_changed_cb), manager);
+      G_CALLBACK (account_changed_cb), manager);
 
   dbus_g_proxy_connect_signal (DBUS_G_PROXY (priv->mc), "AccountStatusChanged",
                                G_CALLBACK (account_status_changed_cb),
@@ -505,27 +403,12 @@ empathy_account_manager_init (EmpathyAccountManager *manager)
 }
 
 static void
-account_manager_disconnect_foreach (gpointer key,
-                                    gpointer value,
-                                    gpointer user_data)
-{
-  TpConnection *connection = key;
-  EmpathyAccountManager *manager = user_data;
-
-  g_signal_handlers_disconnect_by_func (connection, connection_invalidated_cb,
-    manager);
-}
-
-static void
 do_finalize (GObject *obj)
 {
   EmpathyAccountManager *manager = EMPATHY_ACCOUNT_MANAGER (obj);
   EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
 
-  g_hash_table_unref (priv->accounts);
-  g_hash_table_foreach (priv->connections, account_manager_disconnect_foreach,
-    obj);
-  g_hash_table_unref (priv->connections);
+  g_hash_table_destroy (priv->accounts);
 
   G_OBJECT_CLASS (empathy_account_manager_parent_class)->finalize (obj);
 }
@@ -610,7 +493,7 @@ empathy_account_manager_class_init (EmpathyAccountManagerClass *klass)
                   NULL, NULL,
                   g_cclosure_marshal_VOID__OBJECT,
                   G_TYPE_NONE,
-                  1, MC_TYPE_ACCOUNT);
+                  1, EMPATHY_TYPE_ACCOUNT);
 
   signals[ACCOUNT_DELETED] =
     g_signal_new ("account-deleted",
@@ -620,7 +503,7 @@ empathy_account_manager_class_init (EmpathyAccountManagerClass *klass)
                   NULL, NULL,
                   g_cclosure_marshal_VOID__OBJECT,
                   G_TYPE_NONE,
-                  1, MC_TYPE_ACCOUNT);
+                  1, EMPATHY_TYPE_ACCOUNT);
 
   signals[ACCOUNT_ENABLED] =
     g_signal_new ("account-enabled",
@@ -630,7 +513,7 @@ empathy_account_manager_class_init (EmpathyAccountManagerClass *klass)
                   NULL, NULL,
                   g_cclosure_marshal_VOID__OBJECT,
                   G_TYPE_NONE,
-                  1, MC_TYPE_ACCOUNT);
+                  1, EMPATHY_TYPE_ACCOUNT);
 
   signals[ACCOUNT_DISABLED] =
     g_signal_new ("account-disabled",
@@ -640,7 +523,7 @@ empathy_account_manager_class_init (EmpathyAccountManagerClass *klass)
                   NULL, NULL,
                   g_cclosure_marshal_VOID__OBJECT,
                   G_TYPE_NONE,
-                  1, MC_TYPE_ACCOUNT);
+                  1, EMPATHY_TYPE_ACCOUNT);
 
   signals[ACCOUNT_CHANGED] =
     g_signal_new ("account-changed",
@@ -650,7 +533,7 @@ empathy_account_manager_class_init (EmpathyAccountManagerClass *klass)
                   NULL, NULL,
                   g_cclosure_marshal_VOID__OBJECT,
                   G_TYPE_NONE,
-                  1, MC_TYPE_ACCOUNT);
+                  1, EMPATHY_TYPE_ACCOUNT);
 
   signals[ACCOUNT_CONNECTION_CHANGED] =
     g_signal_new ("account-connection-changed",
@@ -660,7 +543,7 @@ empathy_account_manager_class_init (EmpathyAccountManagerClass *klass)
                   NULL, NULL,
                   _empathy_marshal_VOID__OBJECT_INT_UINT_UINT,
                   G_TYPE_NONE,
-                  4, MC_TYPE_ACCOUNT,
+                  4, EMPATHY_TYPE_ACCOUNT,
                   G_TYPE_INT,   /* reason */
                   G_TYPE_UINT,  /* actual connection */
                   G_TYPE_UINT); /* previous connection */
@@ -673,7 +556,7 @@ empathy_account_manager_class_init (EmpathyAccountManagerClass *klass)
                   NULL, NULL,
                   _empathy_marshal_VOID__OBJECT_INT_INT,
                   G_TYPE_NONE,
-                  3, MC_TYPE_ACCOUNT,
+                  3, EMPATHY_TYPE_ACCOUNT,
                   G_TYPE_INT,  /* actual presence */
                   G_TYPE_INT); /* previous presence */
 
@@ -698,6 +581,16 @@ empathy_account_manager_dup_singleton (void)
   return g_object_new (EMPATHY_TYPE_ACCOUNT_MANAGER, NULL);
 }
 
+EmpathyAccount *
+empathy_account_manager_create (EmpathyAccountManager *manager,
+  McProfile *profile)
+{
+  McAccount *mc_account = mc_account_create (profile);
+  return g_object_ref (create_account (manager,
+      mc_account_get_unique_name (mc_account),
+      mc_account));
+}
+
 int
 empathy_account_manager_get_connected_accounts (EmpathyAccountManager *manager)
 {
@@ -722,23 +615,6 @@ empathy_account_manager_get_connecting_accounts (EmpathyAccountManager *manager)
   return priv->connecting;
 }
 
-gboolean
-empathy_account_manager_is_account_just_connected (EmpathyAccountManager *manager,
-                                                   McAccount *account)
-{
-  EmpathyAccountManagerPriv *priv;
-  AccountData *data;
-
-  g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), FALSE);
-
-  priv = GET_PRIV (manager);
-  data = g_hash_table_lookup (priv->accounts, account);
-
-  g_assert (data);
-
-  return (data->source_id > 0);
-}
-
 /**
  * empathy_account_manager_get_count:
  * @manager: a #EmpathyAccountManager
@@ -759,62 +635,59 @@ empathy_account_manager_get_count (EmpathyAccountManager *manager)
   return g_hash_table_size (priv->accounts);
 }
 
-McAccount *
+EmpathyAccount *
 empathy_account_manager_get_account (EmpathyAccountManager *manager,
                                      TpConnection          *connection)
 {
   EmpathyAccountManagerPriv *priv;
+  GHashTableIter iter;
+  gpointer value;
 
   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), 0);
 
   priv = GET_PRIV (manager);
 
-  return g_hash_table_lookup (priv->connections, connection);
+  g_hash_table_iter_init (&iter, priv->accounts);
+  while (g_hash_table_iter_next (&iter, NULL, &value))
+    {
+      EmpathyAccount *account = EMPATHY_ACCOUNT (value);
+
+      if (connection == empathy_account_get_connection (account))
+          return account;
+    }
+
+  return NULL;
 }
 
-GList *
-empathy_account_manager_dup_accounts (EmpathyAccountManager *manager)
+EmpathyAccount *
+empathy_account_manager_lookup (EmpathyAccountManager *manager,
+    const gchar *unique_name)
 {
-  EmpathyAccountManagerPriv *priv;
-  GList *ret;
-
-  g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), NULL);
+  EmpathyAccountManagerPriv *priv = GET_PRIV (manager);
+  EmpathyAccount *account;
 
-  priv = GET_PRIV (manager);
+  account = g_hash_table_lookup (priv->accounts, unique_name);
 
-  ret = g_hash_table_get_keys (priv->accounts);
-  g_list_foreach (ret, (GFunc) g_object_ref, NULL);
+  if (account != NULL)
+    g_object_ref (account);
 
-  return ret;
+  return account;
 }
 
-/**
- * empathy_account_manager_get_connection:
- * @manager: a #EmpathyAccountManager
- * @account: a #McAccount
- *
- * Get the connection of the accounts, or NULL if account is offline or the
- * connection is not yet ready. This function does not return a new ref.
- *
- * Returns: the connection of the accounts.
- **/
-TpConnection *
-empathy_account_manager_get_connection (EmpathyAccountManager *manager,
-                                        McAccount *account)
+GList *
+empathy_account_manager_dup_accounts (EmpathyAccountManager *manager)
 {
   EmpathyAccountManagerPriv *priv;
-  AccountData *data;
+  GList *ret;
 
   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), NULL);
-  g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
 
   priv = GET_PRIV (manager);
 
-  data = g_hash_table_lookup (priv->accounts, account);
-  if (data && data->connection && tp_connection_is_ready (data->connection))
-    return data->connection;
+  ret = g_hash_table_get_values (priv->accounts);
+  g_list_foreach (ret, (GFunc) g_object_ref, NULL);
 
-  return NULL;
+  return ret;
 }
 
 /**
@@ -831,18 +704,30 @@ empathy_account_manager_dup_connections (EmpathyAccountManager *manager)
 {
   EmpathyAccountManagerPriv *priv;
   GHashTableIter iter;
-  gpointer connection;
+  gpointer value;
   GList *ret = NULL;
 
   g_return_val_if_fail (EMPATHY_IS_ACCOUNT_MANAGER (manager), NULL);
 
   priv = GET_PRIV (manager);
 
-  g_hash_table_iter_init (&iter, priv->connections);
-  while (g_hash_table_iter_next (&iter, &connection, NULL))
-    if (connection != NULL && tp_connection_is_ready (connection))
-      ret = g_list_prepend (ret, g_object_ref (connection));
+  g_hash_table_iter_init (&iter, priv->accounts);
+  while (g_hash_table_iter_next (&iter, NULL, &value))
+    {
+      EmpathyAccount *account = EMPATHY_ACCOUNT (value);
+      TpConnection *connection;
+
+      connection = empathy_account_get_connection (account);
+      if (connection != NULL)
+        ret = g_list_prepend (ret, g_object_ref (connection));
+    }
 
   return ret;
 }
 
+void
+empathy_account_manager_remove (EmpathyAccountManager *manager,
+    EmpathyAccount *account)
+{
+  mc_account_delete (_empathy_account_get_mc_account (account));
+}
diff --git a/libempathy/empathy-account-manager.h b/libempathy/empathy-account-manager.h
index 11ca6aca2..b04571ff8 100644
--- a/libempathy/empathy-account-manager.h
+++ b/libempathy/empathy-account-manager.h
@@ -24,7 +24,7 @@
 
 #include <glib-object.h>
 
-#include <libmissioncontrol/mc-account.h>
+#include "empathy-account.h"
 
 G_BEGIN_DECLS
 
@@ -52,25 +52,28 @@ GType empathy_account_manager_get_type (void);
 /* public methods */
 
 EmpathyAccountManager * empathy_account_manager_dup_singleton (void);
+EmpathyAccount *        empathy_account_manager_create
+                                (EmpathyAccountManager *manager,
+                                 McProfile *profile);
 int                     empathy_account_manager_get_connected_accounts
                                 (EmpathyAccountManager *manager);
 int                     empathy_account_manager_get_connecting_accounts
                                 (EmpathyAccountManager *manager);
-gboolean                empathy_account_manager_is_account_just_connected
-                                (EmpathyAccountManager *manager,
-                                 McAccount             *account);
 int                     empathy_account_manager_get_count
                                 (EmpathyAccountManager *manager);
-McAccount *             empathy_account_manager_get_account
+EmpathyAccount *        empathy_account_manager_get_account
                                 (EmpathyAccountManager *manager,
                                  TpConnection          *connection);
+EmpathyAccount *        empathy_account_manager_lookup
+                                (EmpathyAccountManager *manager,
+                                 const gchar *unique_name);
 GList *                 empathy_account_manager_dup_accounts
                                 (EmpathyAccountManager *manager);
-TpConnection *          empathy_account_manager_get_connection
-                                (EmpathyAccountManager *manager,
-                                 McAccount             *account);
 GList *                 empathy_account_manager_dup_connections
                                 (EmpathyAccountManager *manager);
+void                    empathy_account_manager_remove (
+                                 EmpathyAccountManager *manager,
+                                 EmpathyAccount *account);
 
 G_END_DECLS
 
diff --git a/libempathy/empathy-account-priv.h b/libempathy/empathy-account-priv.h
new file mode 100644
index 000000000..8b656b4d8
--- /dev/null
+++ b/libempathy/empathy-account-priv.h
@@ -0,0 +1,44 @@
+/*
+ * empathy-account-priv.h - Private Header for EmpathyAccount
+ * Copyright (C) 2009 Collabora Ltd.
+ * @author Sjoerd Simons <sjoerd.simons@collabora.co.uk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef __EMPATHY_ACCOUNT_PRIV_H__
+#define __EMPATHY_ACCOUNT_PRIV_H__
+
+#include <glib.h>
+
+#include <libmissioncontrol/mc-account.h>
+#include "empathy-account.h"
+
+G_BEGIN_DECLS
+
+EmpathyAccount *_empathy_account_new (McAccount *account);
+void _empathy_account_set_status (EmpathyAccount *account,
+    TpConnectionStatus status,
+    TpConnectionStatusReason reason,
+    TpConnectionPresenceType presence);
+void _empathy_account_set_connection (EmpathyAccount *account,
+    TpConnection *connection);
+void _empathy_account_set_enabled (EmpathyAccount *account,
+    gboolean enabled);
+McAccount *_empathy_account_get_mc_account (EmpathyAccount *account);
+
+G_END_DECLS
+
+#endif /* #ifndef __EMPATHY_ACCOUNT_PRIV_H__*/
diff --git a/libempathy/empathy-account.c b/libempathy/empathy-account.c
new file mode 100644
index 000000000..e0a8e756b
--- /dev/null
+++ b/libempathy/empathy-account.c
@@ -0,0 +1,575 @@
+/*
+ * empathy-account.c - Source for EmpathyAccount
+ * Copyright (C) 2009 Collabora Ltd.
+ * @author Sjoerd Simons <sjoerd.simons@collabora.co.uk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <telepathy-glib/enums.h>
+
+#define DEBUG_FLAG EMPATHY_DEBUG_ACCOUNT
+#include <libempathy/empathy-debug.h>
+
+#include "empathy-account.h"
+#include "empathy-account-priv.h"
+#include "empathy-utils.h"
+#include "empathy-marshal.h"
+
+/* signals */
+enum {
+  STATUS_CHANGED,
+  PRESENCE_CHANGED,
+  LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL];
+
+/* properties */
+enum {
+  PROP_ENABLED = 1,
+  PROP_PRESENCE,
+  PROP_CONNECTION_STATUS,
+  PROP_CONNECTION_STATUS_REASON,
+  PROP_CONNECTION,
+  PROP_UNIQUE_NAME,
+  PROP_DISPLAY_NAME
+};
+
+G_DEFINE_TYPE(EmpathyAccount, empathy_account, G_TYPE_OBJECT)
+
+/* private structure */
+typedef struct _EmpathyAccountPriv EmpathyAccountPriv;
+
+struct _EmpathyAccountPriv
+{
+  gboolean dispose_has_run;
+
+  TpConnection *connection;
+  guint connection_invalidated_id;
+
+  TpConnectionStatus status;
+  TpConnectionStatusReason reason;
+  TpConnectionPresenceType presence;
+
+  gboolean enabled;
+  /* Timestamp when the connection got connected in seconds since the epoch */
+  glong connect_time;
+
+  McAccount *mc_account;
+};
+
+#define GET_PRIV(obj)  EMPATHY_GET_PRIV (obj, EmpathyAccount)
+
+static void
+empathy_account_init (EmpathyAccount *obj)
+{
+  EmpathyAccountPriv *priv;
+
+  priv =  G_TYPE_INSTANCE_GET_PRIVATE (obj,
+    EMPATHY_TYPE_ACCOUNT, EmpathyAccountPriv);
+
+  obj->priv = priv;
+
+  priv->status = TP_CONNECTION_STATUS_DISCONNECTED;
+}
+
+static void
+empathy_account_get_property (GObject *object,
+    guint prop_id,
+    GValue *value,
+    GParamSpec *pspec)
+{
+  EmpathyAccount *account = EMPATHY_ACCOUNT (object);
+  EmpathyAccountPriv *priv = GET_PRIV (account);
+
+  switch (prop_id)
+    {
+      case PROP_ENABLED:
+        g_value_set_boolean (value, priv->enabled);
+        break;
+      case PROP_PRESENCE:
+        g_value_set_uint (value, priv->presence);
+        break;
+      case PROP_CONNECTION_STATUS:
+        g_value_set_uint (value, priv->status);
+        break;
+      case PROP_CONNECTION_STATUS_REASON:
+        g_value_set_uint (value, priv->reason);
+        break;
+      case PROP_CONNECTION:
+        g_value_set_object (value,
+            empathy_account_get_connection (account));
+        break;
+      case PROP_UNIQUE_NAME:
+        g_value_set_string (value,
+            empathy_account_get_unique_name (account));
+        break;
+      case PROP_DISPLAY_NAME:
+        g_value_set_string (value,
+            empathy_account_get_display_name (account));
+        break;
+      default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+        break;
+    }
+}
+
+static void empathy_account_dispose (GObject *object);
+static void empathy_account_finalize (GObject *object);
+
+static void
+empathy_account_class_init (EmpathyAccountClass *empathy_account_class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (empathy_account_class);
+
+  g_type_class_add_private (empathy_account_class,
+    sizeof (EmpathyAccountPriv));
+
+  object_class->get_property = empathy_account_get_property;
+  object_class->dispose = empathy_account_dispose;
+  object_class->finalize = empathy_account_finalize;
+
+  g_object_class_install_property (object_class, PROP_ENABLED,
+    g_param_spec_boolean ("enabled",
+      "Enabled",
+      "Whether this account is enabled or not",
+      FALSE,
+      G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
+
+  g_object_class_install_property (object_class, PROP_PRESENCE,
+    g_param_spec_uint ("presence",
+      "Presence",
+      "The account connections presence type",
+      0,
+      NUM_TP_CONNECTION_PRESENCE_TYPES,
+      TP_CONNECTION_PRESENCE_TYPE_UNSET,
+      G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
+
+  g_object_class_install_property (object_class, PROP_CONNECTION_STATUS,
+    g_param_spec_uint ("status",
+      "ConnectionStatus",
+      "The accounts connections status type",
+      0,
+      NUM_TP_CONNECTION_STATUSES,
+      TP_CONNECTION_STATUS_DISCONNECTED,
+      G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
+
+  g_object_class_install_property (object_class, PROP_CONNECTION_STATUS_REASON,
+    g_param_spec_uint ("status-reason",
+      "ConnectionStatusReason",
+      "The account connections status reason",
+      0,
+      NUM_TP_CONNECTION_STATUS_REASONS,
+      TP_CONNECTION_STATUS_REASON_NONE_SPECIFIED,
+      G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
+
+  g_object_class_install_property (object_class, PROP_CONNECTION,
+    g_param_spec_object ("connection",
+      "Connection",
+      "The accounts connection",
+      TP_TYPE_CONNECTION,
+      G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
+
+  g_object_class_install_property (object_class, PROP_UNIQUE_NAME,
+    g_param_spec_string ("unique-name",
+      "UniqueName",
+      "The accounts unique name",
+      NULL,
+      G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
+
+  g_object_class_install_property (object_class, PROP_DISPLAY_NAME,
+    g_param_spec_string ("display-name",
+      "DisplayName",
+      "The accounts display name",
+      NULL,
+      G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
+
+  signals[STATUS_CHANGED] = g_signal_new ("status-changed",
+    G_TYPE_FROM_CLASS (object_class),
+    G_SIGNAL_RUN_LAST,
+    0, NULL, NULL,
+    _empathy_marshal_VOID__UINT_UINT_UINT,
+    G_TYPE_NONE, 3, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT);
+
+  signals[PRESENCE_CHANGED] = g_signal_new ("presence-changed",
+    G_TYPE_FROM_CLASS (object_class),
+    G_SIGNAL_RUN_LAST,
+    0, NULL, NULL,
+    _empathy_marshal_VOID__UINT_UINT,
+    G_TYPE_NONE, 2, G_TYPE_UINT, G_TYPE_UINT);
+}
+
+void
+empathy_account_dispose (GObject *object)
+{
+  EmpathyAccount *self = EMPATHY_ACCOUNT (object);
+  EmpathyAccountPriv *priv = GET_PRIV (self);
+
+  if (priv->dispose_has_run)
+    return;
+
+  priv->dispose_has_run = TRUE;
+
+  if (priv->connection_invalidated_id != 0)
+    g_signal_handler_disconnect (priv->connection,
+        priv->connection_invalidated_id);
+  priv->connection_invalidated_id = 0;
+
+  if (priv->connection != NULL)
+    g_object_unref (priv->connection);
+  priv->connection = NULL;
+
+  /* release any references held by the object here */
+  if (G_OBJECT_CLASS (empathy_account_parent_class)->dispose != NULL)
+    G_OBJECT_CLASS (empathy_account_parent_class)->dispose (object);
+}
+
+void
+empathy_account_finalize (GObject *object)
+{
+  /* free any data held directly by the object here */
+  if (G_OBJECT_CLASS (empathy_account_parent_class)->finalize != NULL)
+    G_OBJECT_CLASS (empathy_account_parent_class)->finalize (object);
+}
+
+gboolean
+empathy_account_is_just_connected (EmpathyAccount *account)
+{
+  EmpathyAccountPriv *priv = GET_PRIV (account);
+  GTimeVal val;
+
+  if (priv->status != TP_CONNECTION_STATUS_CONNECTED)
+    return FALSE;
+
+  g_get_current_time (&val);
+
+  return (val.tv_sec - priv->connect_time) < 10;
+}
+
+/**
+ * empathy_account_get_connection:
+ * @account: a #EmpathyAccount
+ *
+ * Get the connection of the account, or NULL if account is offline or the
+ * connection is not yet ready. This function does not return a new ref.
+ *
+ * Returns: the connection of the account.
+ **/
+TpConnection *
+empathy_account_get_connection (EmpathyAccount *account)
+{
+  EmpathyAccountPriv *priv = GET_PRIV (account);
+
+  if (priv->connection != NULL &&
+      tp_connection_is_ready (priv->connection))
+    return priv->connection;
+
+  return NULL;
+}
+
+/**
+ * empathy_account_get_unique_name:
+ * @account: a #EmpathyAccount
+ *
+ * Returns: the unique name of the account.
+ **/
+const gchar *
+empathy_account_get_unique_name (EmpathyAccount *account)
+{
+  EmpathyAccountPriv *priv = GET_PRIV (account);
+
+  return mc_account_get_unique_name (priv->mc_account);
+}
+
+/**
+ * empathy_account_get_display_name:
+ * @account: a #EmpathyAccount
+ *
+ * Returns: the display name of the account.
+ **/
+const gchar *
+empathy_account_get_display_name (EmpathyAccount *account)
+{
+  EmpathyAccountPriv *priv = GET_PRIV (account);
+
+  return mc_account_get_display_name (priv->mc_account);
+}
+
+gboolean
+empathy_account_is_valid (EmpathyAccount *account)
+{
+  EmpathyAccountPriv *priv = GET_PRIV (account);
+
+  return mc_account_is_complete (priv->mc_account);
+}
+
+void
+empathy_account_set_enabled (EmpathyAccount *account, gboolean enabled)
+{
+  EmpathyAccountPriv *priv = GET_PRIV (account);
+
+  mc_account_set_enabled (priv->mc_account, enabled);
+}
+
+gboolean
+empathy_account_is_enabled (EmpathyAccount *account)
+{
+  EmpathyAccountPriv *priv = GET_PRIV (account);
+
+  return priv->enabled;
+}
+
+void
+empathy_account_unset_param (EmpathyAccount *account, const gchar *param)
+{
+  EmpathyAccountPriv *priv = GET_PRIV (account);
+
+  mc_account_unset_param (priv->mc_account, param);
+}
+
+gchar *
+empathy_account_get_param_string (EmpathyAccount *account, const gchar *param)
+{
+  EmpathyAccountPriv *priv = GET_PRIV (account);
+  gchar *value = NULL;
+
+  mc_account_get_param_string (priv->mc_account, param, &value);
+  return value;
+}
+
+gint
+empathy_account_get_param_int (EmpathyAccount *account, const gchar *param)
+{
+  EmpathyAccountPriv *priv = GET_PRIV (account);
+  int value;
+
+  mc_account_get_param_int (priv->mc_account, param, &value);
+  return value;
+}
+
+gboolean
+empathy_account_get_param_boolean (EmpathyAccount *account, const gchar *param)
+{
+  EmpathyAccountPriv *priv = GET_PRIV (account);
+  gboolean value;
+
+  mc_account_get_param_boolean (priv->mc_account, param, &value);
+  return value;
+}
+
+void
+empathy_account_set_param_string (EmpathyAccount *account,
+  const gchar *param,
+  const gchar *value)
+{
+  EmpathyAccountPriv *priv = GET_PRIV (account);
+  mc_account_set_param_string (priv->mc_account, param, value);
+}
+
+void
+empathy_account_set_param_int (EmpathyAccount *account,
+  const gchar *param,
+  gint value)
+{
+  EmpathyAccountPriv *priv = GET_PRIV (account);
+  mc_account_set_param_int (priv->mc_account, param, value);
+}
+
+void
+empathy_account_set_param_boolean (EmpathyAccount *account,
+  const gchar *param,
+  gboolean value)
+{
+  EmpathyAccountPriv *priv = GET_PRIV (account);
+  mc_account_set_param_boolean (priv->mc_account, param, value);
+}
+
+void
+empathy_account_set_display_name (EmpathyAccount *account,
+    const gchar *display_name)
+{
+  EmpathyAccountPriv *priv = GET_PRIV (account);
+  mc_account_set_display_name (priv->mc_account, display_name);
+}
+
+McProfile *
+empathy_account_get_profile (EmpathyAccount *account)
+{
+  EmpathyAccountPriv *priv = GET_PRIV (account);
+  return mc_account_get_profile (priv->mc_account);
+}
+
+EmpathyAccount *
+_empathy_account_new (McAccount *mc_account)
+{
+  EmpathyAccount *account;
+  EmpathyAccountPriv *priv;
+
+  account = g_object_new (EMPATHY_TYPE_ACCOUNT, NULL);
+  priv = GET_PRIV (account);
+  priv->mc_account = mc_account;
+
+  return account;
+}
+
+void
+_empathy_account_set_status (EmpathyAccount *account,
+    TpConnectionStatus status,
+    TpConnectionStatusReason reason,
+    TpConnectionPresenceType presence)
+{
+  EmpathyAccountPriv *priv = GET_PRIV (account);
+  TpConnectionStatus old_s = priv->status;
+  TpConnectionPresenceType old_p = priv->presence;
+
+  priv->status = status;
+  priv->presence = presence;
+
+  if (priv->status != old_s)
+    {
+      if (priv->status == TP_CONNECTION_STATUS_CONNECTED)
+        {
+          GTimeVal val;
+          g_get_current_time (&val);
+
+          priv->connect_time = val.tv_sec;
+        }
+
+      priv->reason = reason;
+      g_signal_emit (account, signals[STATUS_CHANGED], 0,
+        old_s, priv->status, reason);
+
+      g_object_notify (G_OBJECT (account), "status");
+    }
+
+  if (priv->presence != old_p)
+    {
+      g_signal_emit (account, signals[PRESENCE_CHANGED], 0,
+        old_p, priv->presence);
+      g_object_notify (G_OBJECT (account), "presence");
+    }
+}
+
+static void
+empathy_account_connection_ready_cb (TpConnection *connection,
+    const GError *error,
+    gpointer user_data)
+{
+  EmpathyAccount *account = EMPATHY_ACCOUNT (user_data);
+  EmpathyAccountPriv *priv = GET_PRIV (account);
+
+  if (error != NULL)
+    {
+      DEBUG ("(%s) Connection failed to become ready: %s",
+        empathy_account_get_unique_name (account), error->message);
+      priv->connection = NULL;
+    }
+  else
+    {
+      DEBUG ("(%s) Connection ready",
+        empathy_account_get_unique_name (account));
+      g_object_notify (G_OBJECT (account), "connection");
+    }
+}
+
+static void
+_empathy_account_connection_invalidated_cb (TpProxy *self,
+  guint    domain,
+  gint     code,
+  gchar   *message,
+  gpointer user_data)
+{
+  EmpathyAccount *account = EMPATHY_ACCOUNT (user_data);
+  EmpathyAccountPriv *priv = GET_PRIV (account);
+
+  if (priv->connection == NULL)
+    return;
+
+  DEBUG ("(%s) Connection invalidated",
+    empathy_account_get_unique_name (account));
+
+  g_assert (priv->connection == TP_CONNECTION (self));
+
+  g_signal_handler_disconnect (priv->connection,
+    priv->connection_invalidated_id);
+  priv->connection_invalidated_id = 0;
+
+  g_object_unref (priv->connection);
+  priv->connection = NULL;
+
+  g_object_notify (G_OBJECT (account), "connection");
+}
+
+void
+_empathy_account_set_connection (EmpathyAccount *account,
+    TpConnection *connection)
+{
+  EmpathyAccountPriv *priv = GET_PRIV (account);
+
+  if (priv->connection == connection)
+    return;
+
+  /* Connection already set, don't set the new one */
+  if (connection != NULL && priv->connection != NULL)
+    return;
+
+  if (connection == NULL)
+    {
+      g_signal_handler_disconnect (priv->connection,
+        priv->connection_invalidated_id);
+      priv->connection_invalidated_id = 0;
+
+      g_object_unref (priv->connection);
+      priv->connection = NULL;
+      g_object_notify (G_OBJECT (account), "connection");
+    }
+  else
+    {
+      priv->connection = g_object_ref (connection);
+      priv->connection_invalidated_id = g_signal_connect (priv->connection,
+          "invalidated",
+          G_CALLBACK (_empathy_account_connection_invalidated_cb),
+          account);
+
+      /* notify a change in the connection property when it's ready */
+      tp_connection_call_when_ready (priv->connection,
+        empathy_account_connection_ready_cb, account);
+    }
+}
+
+void
+_empathy_account_set_enabled (EmpathyAccount *account,
+    gboolean enabled)
+{
+  EmpathyAccountPriv *priv = GET_PRIV (account);
+
+  if (priv->enabled == enabled)
+    return;
+
+  priv->enabled = enabled;
+  g_object_notify (G_OBJECT (account), "enabled");
+}
+
+McAccount *
+_empathy_account_get_mc_account (EmpathyAccount *account)
+{
+  EmpathyAccountPriv *priv = GET_PRIV (account);
+  return priv->mc_account;
+}
diff --git a/libempathy/empathy-account.h b/libempathy/empathy-account.h
new file mode 100644
index 000000000..75babd826
--- /dev/null
+++ b/libempathy/empathy-account.h
@@ -0,0 +1,94 @@
+/*
+ * empathy-account.h - Header for EmpathyAccount
+ * Copyright (C) 2009 Collabora Ltd.
+ * @author Sjoerd Simons <sjoerd.simons@collabora.co.uk>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef __EMPATHY_ACCOUNT_H__
+#define __EMPATHY_ACCOUNT_H__
+
+#include <glib-object.h>
+
+#include <telepathy-glib/connection.h>
+#include <libmissioncontrol/mc-profile.h>
+
+G_BEGIN_DECLS
+
+typedef struct _EmpathyAccount EmpathyAccount;
+typedef struct _EmpathyAccountClass EmpathyAccountClass;
+
+struct _EmpathyAccountClass {
+    GObjectClass parent_class;
+};
+
+struct _EmpathyAccount {
+    GObject parent;
+    gpointer priv;
+};
+
+GType empathy_account_get_type (void);
+
+/* TYPE MACROS */
+#define EMPATHY_TYPE_ACCOUNT (empathy_account_get_type ())
+#define EMPATHY_ACCOUNT(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj), EMPATHY_TYPE_ACCOUNT, EmpathyAccount))
+#define EMPATHY_ACCOUNT_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST((klass), EMPATHY_TYPE_ACCOUNT, EmpathyAccountClass))
+#define EMPATHY_IS_ACCOUNT(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE((obj), EMPATHY_TYPE_ACCOUNT))
+#define EMPATHY_IS_ACCOUNT_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE((klass), EMPATHY_TYPE_ACCOUNT))
+#define EMPATHY_ACCOUNT_GET_CLASS(obj) \
+  (G_TYPE_INSTANCE_GET_CLASS ((obj), EMPATHY_TYPE_ACCOUNT, \
+    EmpathyAccountClass))
+
+gboolean empathy_account_is_just_connected (EmpathyAccount *account);
+TpConnection *empathy_account_get_connection (EmpathyAccount *account);
+const gchar *empathy_account_get_unique_name (EmpathyAccount *account);
+const gchar *empathy_account_get_display_name (EmpathyAccount *account);
+
+void empathy_account_set_enabled (EmpathyAccount *account,
+  gboolean enabled);
+gboolean empathy_account_is_enabled (EmpathyAccount *account);
+
+void empathy_account_unset_param (EmpathyAccount *account, const gchar *param);
+gchar *empathy_account_get_param_string (EmpathyAccount *account,
+    const gchar *param);
+gint empathy_account_get_param_int (EmpathyAccount *account,
+    const gchar *param);
+gboolean empathy_account_get_param_boolean (EmpathyAccount *account,
+    const gchar *param);
+
+void empathy_account_set_param_string (EmpathyAccount *account,
+    const gchar *param, const gchar *value);
+void empathy_account_set_param_int (EmpathyAccount *account,
+    const gchar *param, gint value);
+void empathy_account_set_param_boolean (EmpathyAccount *account,
+    const gchar *param, gboolean value);
+
+gboolean empathy_account_is_valid (EmpathyAccount *account);
+
+void empathy_account_set_display_name (EmpathyAccount *account,
+    const gchar *display_name);
+
+
+/* TODO remove McProfile */
+McProfile *empathy_account_get_profile (EmpathyAccount *account);
+
+G_END_DECLS
+
+#endif /* #ifndef __EMPATHY_ACCOUNT_H__*/
diff --git a/libempathy/empathy-chatroom-manager.c b/libempathy/empathy-chatroom-manager.c
index 44416670e..08c36d926 100644
--- a/libempathy/empathy-chatroom-manager.c
+++ b/libempathy/empathy-chatroom-manager.c
@@ -100,7 +100,8 @@ chatroom_manager_file_save (EmpathyChatroomManager *manager)
 			continue;
 		}
 
-		account_id = mc_account_get_unique_name (empathy_chatroom_get_account (chatroom));
+		account_id = empathy_account_get_unique_name (
+		  empathy_chatroom_get_account (chatroom));
 
 		node = xmlNewChild (root, NULL, "chatroom", NULL);
 		xmlNewTextChild (node, NULL, "name", empathy_chatroom_get_name (chatroom));
@@ -174,7 +175,7 @@ chatroom_manager_parse_chatroom (EmpathyChatroomManager *manager,
 {
 	EmpathyChatroomManagerPriv *priv;
 	EmpathyChatroom            *chatroom;
-	McAccount                 *account;
+	EmpathyAccount             *account;
 	xmlNodePtr                 child;
 	gchar                     *str;
 	gchar                     *name;
@@ -220,7 +221,7 @@ chatroom_manager_parse_chatroom (EmpathyChatroomManager *manager,
 		xmlFree (str);
 	}
 
-	account = mc_account_lookup (account_id);
+	account = empathy_account_manager_lookup (priv->account_manager, account_id);
 	if (!account) {
 		g_free (name);
 		g_free (room);
@@ -556,21 +557,20 @@ empathy_chatroom_manager_remove (EmpathyChatroomManager *manager,
 
 EmpathyChatroom *
 empathy_chatroom_manager_find (EmpathyChatroomManager *manager,
-                               McAccount *account,
+                               EmpathyAccount *account,
                                const gchar *room)
 {
 	EmpathyChatroomManagerPriv *priv;
 	GList                     *l;
 
 	g_return_val_if_fail (EMPATHY_IS_CHATROOM_MANAGER (manager), NULL);
-	g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
 	g_return_val_if_fail (room != NULL, NULL);
 
 	priv = GET_PRIV (manager);
 
 	for (l = priv->chatrooms; l; l = l->next) {
 		EmpathyChatroom *chatroom;
-		McAccount      *this_account;
+		EmpathyAccount *this_account;
 		const gchar    *this_room;
 
 		chatroom = l->data;
@@ -589,7 +589,7 @@ empathy_chatroom_manager_find (EmpathyChatroomManager *manager,
 
 GList *
 empathy_chatroom_manager_get_chatrooms (EmpathyChatroomManager *manager,
-				       McAccount             *account)
+				       EmpathyAccount *account)
 {
 	EmpathyChatroomManagerPriv *priv;
 	GList                     *chatrooms, *l;
@@ -619,7 +619,7 @@ empathy_chatroom_manager_get_chatrooms (EmpathyChatroomManager *manager,
 
 guint
 empathy_chatroom_manager_get_count (EmpathyChatroomManager *manager,
-				   McAccount             *account)
+				   EmpathyAccount *account)
 {
 	EmpathyChatroomManagerPriv *priv;
 	GList                     *l;
@@ -686,7 +686,7 @@ chatroom_manager_observe_channel_cb (EmpathyDispatcher *dispatcher,
   const gchar *roomname;
   GQuark channel_type;
   TpHandleType handle_type;
-  McAccount *account;
+  EmpathyAccount *account;
   TpConnection *connection;
 
   channel_type = empathy_dispatch_operation_get_channel_type_id (operation);
diff --git a/libempathy/empathy-chatroom-manager.h b/libempathy/empathy-chatroom-manager.h
index 76c71d955..a6038f7fc 100644
--- a/libempathy/empathy-chatroom-manager.h
+++ b/libempathy/empathy-chatroom-manager.h
@@ -27,8 +27,7 @@
 
 #include <glib-object.h>
 
-#include <libmissioncontrol/mc-account.h>
-
+#include "empathy-account.h"
 #include "empathy-chatroom.h"
 #include "empathy-dispatcher.h"
 
@@ -60,12 +59,12 @@ gboolean               empathy_chatroom_manager_add           (EmpathyChatroomMa
 void                   empathy_chatroom_manager_remove        (EmpathyChatroomManager *manager,
 							      EmpathyChatroom        *chatroom);
 EmpathyChatroom *       empathy_chatroom_manager_find          (EmpathyChatroomManager *manager,
-							      McAccount             *account,
-							      const gchar           *room);
+							      EmpathyAccount           *account,
+							      const gchar              *room);
 GList *                empathy_chatroom_manager_get_chatrooms (EmpathyChatroomManager *manager,
-							      McAccount             *account);
+							      EmpathyAccount          *account);
 guint                  empathy_chatroom_manager_get_count     (EmpathyChatroomManager *manager,
-							      McAccount             *account);
+							      EmpathyAccount          *account);
 void                   empathy_chatroom_manager_observe       (EmpathyChatroomManager *manager,
 							      EmpathyDispatcher *dispatcher);
 
diff --git a/libempathy/empathy-chatroom.c b/libempathy/empathy-chatroom.c
index 147fca0a9..b62d6ad77 100644
--- a/libempathy/empathy-chatroom.c
+++ b/libempathy/empathy-chatroom.c
@@ -31,7 +31,7 @@
 
 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyChatroom)
 typedef struct {
-	McAccount *account;
+	EmpathyAccount *account;
 	gchar     *room;
 	gchar     *name;
 	gboolean   auto_connect;
@@ -84,7 +84,7 @@ empathy_chatroom_class_init (EmpathyChatroomClass *klass)
 					 g_param_spec_object ("account",
 							      "Chatroom Account",
 							      "The account associated with an chatroom",
-							      MC_TYPE_ACCOUNT,
+							      EMPATHY_TYPE_ACCOUNT,
 							      G_PARAM_READWRITE));
 
 	g_object_class_install_property (object_class,
@@ -312,22 +312,19 @@ chatroom_set_property (GObject      *object,
 }
 
 EmpathyChatroom *
-empathy_chatroom_new (McAccount *account)
+empathy_chatroom_new (EmpathyAccount *account)
 {
-	g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
-
 	return g_object_new (EMPATHY_TYPE_CHATROOM,
 			     "account", account,
 			     NULL);
 }
 
 EmpathyChatroom *
-empathy_chatroom_new_full (McAccount   *account,
+empathy_chatroom_new_full (EmpathyAccount *account,
 			  const gchar *room,
 			  const gchar *name,
 			  gboolean     auto_connect)
 {
-	g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
 	g_return_val_if_fail (room != NULL, NULL);
 
 	return g_object_new (EMPATHY_TYPE_CHATROOM,
@@ -338,7 +335,7 @@ empathy_chatroom_new_full (McAccount   *account,
 			     NULL);
 }
 
-McAccount *
+EmpathyAccount *
 empathy_chatroom_get_account (EmpathyChatroom *chatroom)
 {
 	EmpathyChatroomPriv *priv;
@@ -351,12 +348,11 @@ empathy_chatroom_get_account (EmpathyChatroom *chatroom)
 
 void
 empathy_chatroom_set_account (EmpathyChatroom *chatroom,
-			     McAccount      *account)
+			     EmpathyAccount *account)
 {
 	EmpathyChatroomPriv *priv;
 
 	g_return_if_fail (EMPATHY_IS_CHATROOM (chatroom));
-	g_return_if_fail (MC_IS_ACCOUNT (account));
 
 	priv = GET_PRIV (chatroom);
 
@@ -470,8 +466,8 @@ gboolean
 empathy_chatroom_equal (gconstpointer v1,
 		       gconstpointer v2)
 {
-	McAccount   *account_a;
-	McAccount   *account_b;
+	EmpathyAccount *account_a;
+	EmpathyAccount *account_b;
 	const gchar *room_a;
 	const gchar *room_b;
 
diff --git a/libempathy/empathy-chatroom.h b/libempathy/empathy-chatroom.h
index 560517d48..c18c27449 100644
--- a/libempathy/empathy-chatroom.h
+++ b/libempathy/empathy-chatroom.h
@@ -24,8 +24,7 @@
 
 #include <glib-object.h>
 
-#include <libmissioncontrol/mc-account.h>
-
+#include <libempathy/empathy-account.h>
 #include <libempathy/empathy-tp-chat.h>
 
 G_BEGIN_DECLS
@@ -52,14 +51,14 @@ struct _EmpathyChatroomClass {
 };
 
 GType            empathy_chatroom_get_type        (void) G_GNUC_CONST;
-EmpathyChatroom *empathy_chatroom_new             (McAccount       *account);
-EmpathyChatroom *empathy_chatroom_new_full        (McAccount       *account,
+EmpathyChatroom *empathy_chatroom_new             (EmpathyAccount  *account);
+EmpathyChatroom *empathy_chatroom_new_full        (EmpathyAccount  *account,
 						   const gchar     *room,
 						   const gchar     *name,
 						   gboolean         auto_connect);
-McAccount *     empathy_chatroom_get_account      (EmpathyChatroom *chatroom);
+EmpathyAccount *     empathy_chatroom_get_account      (EmpathyChatroom *chatroom);
 void            empathy_chatroom_set_account      (EmpathyChatroom *chatroom,
-						   McAccount       *account);
+						   EmpathyAccount  *account);
 const gchar *   empathy_chatroom_get_room         (EmpathyChatroom *chatroom);
 void            empathy_chatroom_set_room         (EmpathyChatroom *chatroom,
 						   const gchar     *room);
diff --git a/libempathy/empathy-contact.c b/libempathy/empathy-contact.c
index bad6ef470..d351aecbc 100644
--- a/libempathy/empathy-contact.c
+++ b/libempathy/empathy-contact.c
@@ -39,7 +39,7 @@
 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyContact)
 typedef struct {
   TpContact *tp_contact;
-  McAccount *account;
+  EmpathyAccount *account;
   gchar *id;
   gchar *name;
   EmpathyAvatar *avatar;
@@ -159,7 +159,7 @@ empathy_contact_class_init (EmpathyContactClass *class)
       g_param_spec_object ("account",
         "The account",
         "The account associated with the contact",
-        MC_TYPE_ACCOUNT,
+        EMPATHY_TYPE_ACCOUNT,
         G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 
   g_object_class_install_property (object_class,
@@ -409,12 +409,11 @@ empathy_contact_new (TpContact *tp_contact)
 }
 
 EmpathyContact *
-empathy_contact_new_for_log (McAccount *account,
+empathy_contact_new_for_log (EmpathyAccount *account,
                              const gchar *id,
                              const gchar *name,
                              gboolean is_user)
 {
-  g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
   g_return_val_if_fail (id != NULL, NULL);
 
   return g_object_new (EMPATHY_TYPE_CONTACT,
@@ -554,7 +553,7 @@ empathy_contact_set_avatar (EmpathyContact *contact,
   g_object_notify (G_OBJECT (contact), "avatar");
 }
 
-McAccount *
+EmpathyAccount *
 empathy_contact_get_account (EmpathyContact *contact)
 {
   EmpathyContactPriv *priv;
@@ -830,7 +829,7 @@ static gchar *
 contact_get_avatar_filename (EmpathyContact *contact,
                              const gchar *token)
 {
-  McAccount *account;
+  EmpathyAccount *account;
   gchar *avatar_path;
   gchar *avatar_file;
   gchar *token_escaped;
@@ -847,7 +846,7 @@ contact_get_avatar_filename (EmpathyContact *contact,
   avatar_path = g_build_filename (g_get_user_cache_dir (),
       PACKAGE_NAME,
       "avatars",
-      mc_account_get_unique_name (account),
+      empathy_account_get_unique_name (account),
       contact_escaped,
       NULL);
   g_mkdir_with_parents (avatar_path, 0700);
diff --git a/libempathy/empathy-contact.h b/libempathy/empathy-contact.h
index f88831342..d4e385924 100644
--- a/libempathy/empathy-contact.h
+++ b/libempathy/empathy-contact.h
@@ -25,7 +25,7 @@
 #include <glib-object.h>
 
 #include <telepathy-glib/contact.h>
-#include <libmissioncontrol/mc-account.h>
+#include <libempathy/empathy-account.h>
 
 G_BEGIN_DECLS
 
@@ -70,7 +70,7 @@ typedef enum {
 
 GType empathy_contact_get_type (void) G_GNUC_CONST;
 EmpathyContact * empathy_contact_new (TpContact *tp_contact);
-EmpathyContact * empathy_contact_new_for_log (McAccount *account,
+EmpathyContact * empathy_contact_new_for_log (EmpathyAccount *account,
     const gchar *id, const gchar *name, gboolean is_user);
 TpContact * empathy_contact_get_tp_contact (EmpathyContact *contact);
 const gchar * empathy_contact_get_id (EmpathyContact *contact);
@@ -80,7 +80,7 @@ void empathy_contact_set_name (EmpathyContact *contact, const gchar *name);
 EmpathyAvatar * empathy_contact_get_avatar (EmpathyContact *contact);
 void empathy_contact_set_avatar (EmpathyContact *contact,
     EmpathyAvatar *avatar);
-McAccount * empathy_contact_get_account (EmpathyContact *contact);
+EmpathyAccount * empathy_contact_get_account (EmpathyContact *contact);
 TpConnection * empathy_contact_get_connection (EmpathyContact *contact);
 TpConnectionPresenceType empathy_contact_get_presence (EmpathyContact *contact);
 void empathy_contact_set_presence (EmpathyContact *contact,
diff --git a/libempathy/empathy-dispatch-operation.c b/libempathy/empathy-dispatch-operation.c
index 7a116f870..79fe8c62d 100644
--- a/libempathy/empathy-dispatch-operation.c
+++ b/libempathy/empathy-dispatch-operation.c
@@ -22,6 +22,8 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#include <telepathy-glib/interfaces.h>
+
 #include "empathy-dispatch-operation.h"
 #include <libempathy/empathy-enum-types.h>
 #include <libempathy/empathy-tp-contact-factory.h>
@@ -215,7 +217,7 @@ empathy_dispatch_operation_constructed (GObject *object)
 
   handle = tp_channel_get_handle (priv->channel, &handle_type);
 
-  if (handle_type == TP_CONN_HANDLE_TYPE_CONTACT && priv->contact == NULL)
+  if (handle_type == TP_HANDLE_TYPE_CONTACT && priv->contact == NULL)
     {
       EmpathyTpContactFactory *factory;
 
diff --git a/libempathy/empathy-dispatch-operation.h b/libempathy/empathy-dispatch-operation.h
index 84ed36013..148adec90 100644
--- a/libempathy/empathy-dispatch-operation.h
+++ b/libempathy/empathy-dispatch-operation.h
@@ -24,6 +24,8 @@
 #include <glib-object.h>
 
 #include <libempathy/empathy-contact.h>
+#include <telepathy-glib/connection.h>
+#include <telepathy-glib/channel.h>
 
 G_BEGIN_DECLS
 
diff --git a/libempathy/empathy-log-manager.c b/libempathy/empathy-log-manager.c
index b4c1f1a92..c1e20f487 100644
--- a/libempathy/empathy-log-manager.c
+++ b/libempathy/empathy-log-manager.c
@@ -157,7 +157,7 @@ empathy_log_manager_add_message (EmpathyLogManager *manager,
 
 gboolean
 empathy_log_manager_exists (EmpathyLogManager *manager,
-                            McAccount *account,
+                            EmpathyAccount *account,
                             const gchar *chat_id,
                             gboolean chatroom)
 {
@@ -165,7 +165,6 @@ empathy_log_manager_exists (EmpathyLogManager *manager,
   EmpathyLogManagerPriv *priv;
 
   g_return_val_if_fail (EMPATHY_IS_LOG_MANAGER (manager), FALSE);
-  g_return_val_if_fail (MC_IS_ACCOUNT (account), FALSE);
   g_return_val_if_fail (chat_id != NULL, FALSE);
 
   priv = GET_PRIV (manager);
@@ -182,7 +181,7 @@ empathy_log_manager_exists (EmpathyLogManager *manager,
 
 GList *
 empathy_log_manager_get_dates (EmpathyLogManager *manager,
-                               McAccount *account,
+                               EmpathyAccount *account,
                                const gchar *chat_id,
                                gboolean chatroom)
 {
@@ -190,7 +189,6 @@ empathy_log_manager_get_dates (EmpathyLogManager *manager,
   EmpathyLogManagerPriv *priv;
 
   g_return_val_if_fail (EMPATHY_IS_LOG_MANAGER (manager), NULL);
-  g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
   g_return_val_if_fail (chat_id != NULL, NULL);
 
   priv = GET_PRIV (manager);
@@ -219,7 +217,7 @@ empathy_log_manager_get_dates (EmpathyLogManager *manager,
 
 GList *
 empathy_log_manager_get_messages_for_date (EmpathyLogManager *manager,
-                                           McAccount *account,
+                                           EmpathyAccount *account,
                                            const gchar *chat_id,
                                            gboolean chatroom,
                                            const gchar *date)
@@ -228,7 +226,6 @@ empathy_log_manager_get_messages_for_date (EmpathyLogManager *manager,
   EmpathyLogManagerPriv *priv;
 
   g_return_val_if_fail (EMPATHY_IS_LOG_MANAGER (manager), NULL);
-  g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
   g_return_val_if_fail (chat_id != NULL, NULL);
 
   priv = GET_PRIV (manager);
@@ -261,7 +258,7 @@ log_manager_message_date_cmp (gconstpointer a,
 
 GList *
 empathy_log_manager_get_filtered_messages (EmpathyLogManager *manager,
-					   McAccount *account,
+					   EmpathyAccount *account,
 					   const gchar *chat_id,
 					   gboolean chatroom,
 					   guint num_messages,
@@ -274,7 +271,6 @@ empathy_log_manager_get_filtered_messages (EmpathyLogManager *manager,
   guint i = 0;
 
   g_return_val_if_fail (EMPATHY_IS_LOG_MANAGER (manager), NULL);
-  g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
   g_return_val_if_fail (chat_id != NULL, NULL);
 
   priv = GET_PRIV (manager);
@@ -322,13 +318,12 @@ empathy_log_manager_get_filtered_messages (EmpathyLogManager *manager,
 
 GList *
 empathy_log_manager_get_chats (EmpathyLogManager *manager,
-                               McAccount *account)
+                               EmpathyAccount *account)
 {
   GList *l, *out = NULL;
   EmpathyLogManagerPriv *priv;
 
   g_return_val_if_fail (EMPATHY_IS_LOG_MANAGER (manager), NULL);
-  g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
 
   priv = GET_PRIV (manager);
 
diff --git a/libempathy/empathy-log-manager.h b/libempathy/empathy-log-manager.h
index da7be4a43..6907e2ede 100644
--- a/libempathy/empathy-log-manager.h
+++ b/libempathy/empathy-log-manager.h
@@ -65,7 +65,7 @@ struct _EmpathyLogManagerClass
 
 struct _EmpathyLogSearchHit
 {
-  McAccount *account;
+  EmpathyAccount *account;
   gchar     *chat_id;
   gboolean   is_chatroom;
   gchar     *filename;
@@ -81,17 +81,17 @@ gboolean empathy_log_manager_add_message (EmpathyLogManager *manager,
     const gchar *chat_id, gboolean chatroom, EmpathyMessage *message,
     GError **error);
 gboolean empathy_log_manager_exists (EmpathyLogManager *manager,
-    McAccount *account, const gchar *chat_id, gboolean chatroom);
+    EmpathyAccount *account, const gchar *chat_id, gboolean chatroom);
 GList *empathy_log_manager_get_dates (EmpathyLogManager *manager,
-    McAccount *account, const gchar *chat_id, gboolean chatroom);
+    EmpathyAccount *account, const gchar *chat_id, gboolean chatroom);
 GList *empathy_log_manager_get_messages_for_date (EmpathyLogManager *manager,
-    McAccount *account, const gchar *chat_id, gboolean chatroom,
+    EmpathyAccount *account, const gchar *chat_id, gboolean chatroom,
     const gchar *date);
 GList *empathy_log_manager_get_filtered_messages (EmpathyLogManager *manager,
-    McAccount *account, const gchar *chat_id, gboolean chatroom,
+    EmpathyAccount *account, const gchar *chat_id, gboolean chatroom,
     guint num_messages, EmpathyLogMessageFilter filter, gpointer user_data);
 GList *empathy_log_manager_get_chats (EmpathyLogManager *manager,
-    McAccount *account);
+    EmpathyAccount *account);
 GList *empathy_log_manager_search_new (EmpathyLogManager *manager,
     const gchar *text);
 void empathy_log_manager_search_free (GList *hits);
diff --git a/libempathy/empathy-log-store-empathy.c b/libempathy/empathy-log-store-empathy.c
index 94f4d1457..7e50cb12f 100644
--- a/libempathy/empathy-log-store-empathy.c
+++ b/libempathy/empathy-log-store-empathy.c
@@ -32,6 +32,7 @@
 #include "empathy-log-store.h"
 #include "empathy-log-store-empathy.h"
 #include "empathy-log-manager.h"
+#include "empathy-account-manager.h"
 #include "empathy-contact.h"
 #include "empathy-time.h"
 #include "empathy-utils.h"
@@ -59,6 +60,7 @@ typedef struct
 {
   gchar *basedir;
   gchar *name;
+  EmpathyAccountManager *account_manager;
 } EmpathyLogStoreEmpathyPriv;
 
 static void log_store_iface_init (gpointer g_iface,gpointer iface_data);
@@ -73,6 +75,7 @@ log_store_empathy_finalize (GObject *object)
   EmpathyLogStoreEmpathy *self = EMPATHY_LOG_STORE_EMPATHY (object);
   EmpathyLogStoreEmpathyPriv *priv = GET_PRIV (self);
 
+  g_object_unref (priv->account_manager);
   g_free (priv->basedir);
   g_free (priv->name);
 }
@@ -99,11 +102,12 @@ empathy_log_store_empathy_init (EmpathyLogStoreEmpathy *self)
       ".gnome2", PACKAGE_NAME, "logs", NULL);
 
   priv->name = g_strdup ("Empathy");
+  priv->account_manager = empathy_account_manager_dup_singleton ();
 }
 
 static gchar *
 log_store_empathy_get_dir (EmpathyLogStore *self,
-                           McAccount *account,
+                           EmpathyAccount *account,
                            const gchar *chat_id,
                            gboolean chatroom)
 {
@@ -113,7 +117,7 @@ log_store_empathy_get_dir (EmpathyLogStore *self,
 
   priv = GET_PRIV (self);
 
-  account_id = mc_account_get_unique_name (account);
+  account_id = empathy_account_get_unique_name (account);
 
   if (chatroom)
     basedir = g_build_path (G_DIR_SEPARATOR_S, priv->basedir, account_id,
@@ -154,7 +158,7 @@ log_store_empathy_get_timestamp_from_message (EmpathyMessage *message)
 
 static gchar *
 log_store_empathy_get_filename (EmpathyLogStore *self,
-                                McAccount *account,
+                                EmpathyAccount *account,
                                 const gchar *chat_id,
                                 gboolean chatroom)
 {
@@ -180,7 +184,7 @@ log_store_empathy_add_message (EmpathyLogStore *self,
                                GError **error)
 {
   FILE *file;
-  McAccount *account;
+  EmpathyAccount *account;
   EmpathyContact *sender;
   const gchar *body_str;
   const gchar *str;
@@ -267,7 +271,7 @@ log_store_empathy_add_message (EmpathyLogStore *self,
 
 static gboolean
 log_store_empathy_exists (EmpathyLogStore *self,
-                          McAccount *account,
+                          EmpathyAccount *account,
                           const gchar *chat_id,
                           gboolean chatroom)
 {
@@ -283,7 +287,7 @@ log_store_empathy_exists (EmpathyLogStore *self,
 
 static GList *
 log_store_empathy_get_dates (EmpathyLogStore *self,
-                             McAccount *account,
+                             EmpathyAccount *account,
                              const gchar *chat_id,
                              gboolean chatroom)
 {
@@ -295,7 +299,6 @@ log_store_empathy_get_dates (EmpathyLogStore *self,
   const gchar *p;
 
   g_return_val_if_fail (EMPATHY_IS_LOG_STORE (self), NULL);
-  g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
   g_return_val_if_fail (chat_id != NULL, NULL);
 
   directory = log_store_empathy_get_dir (self, account, chat_id, chatroom);
@@ -336,7 +339,7 @@ log_store_empathy_get_dates (EmpathyLogStore *self,
 
 static gchar *
 log_store_empathy_get_filename_for_date (EmpathyLogStore *self,
-                                         McAccount *account,
+                                         EmpathyAccount *account,
                                          const gchar *chat_id,
                                          gboolean chatroom,
                                          const gchar *date)
@@ -359,6 +362,7 @@ static EmpathyLogSearchHit *
 log_store_empathy_search_hit_new (EmpathyLogStore *self,
                                   const gchar *filename)
 {
+  EmpathyLogStoreEmpathyPriv *priv = GET_PRIV (self);
   EmpathyLogSearchHit *hit;
   const gchar *account_name;
   const gchar *end;
@@ -383,7 +387,8 @@ log_store_empathy_search_hit_new (EmpathyLogStore *self,
   else
     account_name = strv[len-3];
 
-  hit->account = mc_account_lookup (account_name);
+  hit->account = empathy_account_manager_lookup (priv->account_manager,
+    account_name);
   hit->filename = g_strdup (filename);
 
   g_strfreev (strv);
@@ -401,7 +406,7 @@ log_store_empathy_get_messages_for_file (EmpathyLogStore *self,
   xmlNodePtr log_node;
   xmlNodePtr node;
   EmpathyLogSearchHit *hit;
-  McAccount *account;
+  EmpathyAccount *account;
 
   g_return_val_if_fail (EMPATHY_IS_LOG_STORE (self), NULL);
   g_return_val_if_fail (filename != NULL, NULL);
@@ -666,7 +671,7 @@ log_store_empathy_get_chats_for_dir (EmpathyLogStore *self,
 
 static GList *
 log_store_empathy_get_messages_for_date (EmpathyLogStore *self,
-                                         McAccount *account,
+                                         EmpathyAccount *account,
                                          const gchar *chat_id,
                                          gboolean chatroom,
                                          const gchar *date)
@@ -675,7 +680,6 @@ log_store_empathy_get_messages_for_date (EmpathyLogStore *self,
   GList *messages;
 
   g_return_val_if_fail (EMPATHY_IS_LOG_STORE (self), NULL);
-  g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
   g_return_val_if_fail (chat_id != NULL, NULL);
 
   filename = log_store_empathy_get_filename_for_date (self, account,
@@ -688,7 +692,7 @@ log_store_empathy_get_messages_for_date (EmpathyLogStore *self,
 
 static GList *
 log_store_empathy_get_chats (EmpathyLogStore *self,
-                              McAccount *account)
+                              EmpathyAccount *account)
 {
   gchar *dir;
   GList *hits;
@@ -697,7 +701,7 @@ log_store_empathy_get_chats (EmpathyLogStore *self,
   priv = GET_PRIV (self);
 
   dir = g_build_filename (priv->basedir,
-      mc_account_get_unique_name (account), NULL);
+      empathy_account_get_unique_name (account), NULL);
 
   hits = log_store_empathy_get_chats_for_dir (self, dir, FALSE);
 
@@ -716,7 +720,7 @@ log_store_empathy_get_name (EmpathyLogStore *self)
 
 static GList *
 log_store_empathy_get_filtered_messages (EmpathyLogStore *self,
-                                         McAccount *account,
+                                         EmpathyAccount *account,
                                          const gchar *chat_id,
                                          gboolean chatroom,
                                          guint num_messages,
diff --git a/libempathy/empathy-log-store.c b/libempathy/empathy-log-store.c
index 21a881559..f136f7910 100644
--- a/libempathy/empathy-log-store.c
+++ b/libempathy/empathy-log-store.c
@@ -55,7 +55,7 @@ empathy_log_store_get_name (EmpathyLogStore *self)
 
 gboolean
 empathy_log_store_exists (EmpathyLogStore *self,
-                          McAccount *account,
+                          EmpathyAccount *account,
                           const gchar *chat_id,
                           gboolean chatroom)
 {
@@ -84,7 +84,7 @@ empathy_log_store_add_message (EmpathyLogStore *self,
 
 GList *
 empathy_log_store_get_dates (EmpathyLogStore *self,
-                             McAccount *account,
+                             EmpathyAccount *account,
                              const gchar *chat_id,
                              gboolean chatroom)
 {
@@ -97,7 +97,7 @@ empathy_log_store_get_dates (EmpathyLogStore *self,
 
 GList *
 empathy_log_store_get_messages_for_date (EmpathyLogStore *self,
-                                         McAccount *account,
+                                         EmpathyAccount *account,
                                          const gchar *chat_id,
                                          gboolean chatroom,
                                          const gchar *date)
@@ -111,7 +111,7 @@ empathy_log_store_get_messages_for_date (EmpathyLogStore *self,
 
 GList *
 empathy_log_store_get_last_messages (EmpathyLogStore *self,
-                                     McAccount *account,
+                                     EmpathyAccount *account,
                                      const gchar *chat_id,
                                      gboolean chatroom)
 {
@@ -124,7 +124,7 @@ empathy_log_store_get_last_messages (EmpathyLogStore *self,
 
 GList *
 empathy_log_store_get_chats (EmpathyLogStore *self,
-                             McAccount *account)
+                             EmpathyAccount *account)
 {
   if (!EMPATHY_LOG_STORE_GET_INTERFACE (self)->get_chats)
     return NULL;
@@ -157,7 +157,7 @@ empathy_log_store_ack_message (EmpathyLogStore *self,
 
 GList *
 empathy_log_store_get_filtered_messages (EmpathyLogStore *self,
-                                         McAccount *account,
+                                         EmpathyAccount *account,
                                          const gchar *chat_id,
                                          gboolean chatroom,
                                          guint num_messages,
diff --git a/libempathy/empathy-log-store.h b/libempathy/empathy-log-store.h
index db698c4b0..5b6a87875 100644
--- a/libempathy/empathy-log-store.h
+++ b/libempathy/empathy-log-store.h
@@ -25,7 +25,7 @@
 
 #include <glib-object.h>
 
-#include <libmissioncontrol/mc-account.h>
+#include <libempathy/empathy-account.h>
 
 #include "empathy-message.h"
 #include "empathy-log-manager.h"
@@ -50,23 +50,23 @@ struct _EmpathyLogStoreInterface
   GTypeInterface parent;
 
   const gchar * (*get_name) (EmpathyLogStore *self);
-  gboolean (*exists) (EmpathyLogStore *self, McAccount *account,
+  gboolean (*exists) (EmpathyLogStore *self, EmpathyAccount *account,
       const gchar *chat_id, gboolean chatroom);
   gboolean (*add_message) (EmpathyLogStore *self, const gchar *chat_id,
       gboolean chatroom, EmpathyMessage *message, GError **error);
-  GList * (*get_dates) (EmpathyLogStore *self, McAccount *account,
+  GList * (*get_dates) (EmpathyLogStore *self, EmpathyAccount *account,
       const gchar *chat_id, gboolean chatroom);
   GList * (*get_messages_for_date) (EmpathyLogStore *self,
-      McAccount *account, const gchar *chat_id, gboolean chatroom,
+      EmpathyAccount *account, const gchar *chat_id, gboolean chatroom,
       const gchar *date);
-  GList * (*get_last_messages) (EmpathyLogStore *self, McAccount *account,
+  GList * (*get_last_messages) (EmpathyLogStore *self, EmpathyAccount *account,
       const gchar *chat_id, gboolean chatroom);
   GList * (*get_chats) (EmpathyLogStore *self,
-            McAccount         *account);
+            EmpathyAccount    *account);
   GList * (*search_new) (EmpathyLogStore *self, const gchar *text);
   void (*ack_message) (EmpathyLogStore *self, const gchar *chat_id,
       gboolean chatroom, EmpathyMessage *message);
-  GList * (*get_filtered_messages) (EmpathyLogStore *self, McAccount *account,
+  GList * (*get_filtered_messages) (EmpathyLogStore *self, EmpathyAccount *account,
       const gchar *chat_id, gboolean chatroom, guint num_messages,
       EmpathyLogMessageFilter filter, gpointer user_data);
 };
@@ -75,25 +75,25 @@ GType empathy_log_store_get_type (void) G_GNUC_CONST;
 
 const gchar *empathy_log_store_get_name (EmpathyLogStore *self);
 gboolean empathy_log_store_exists (EmpathyLogStore *self,
-    McAccount *account, const gchar *chat_id, gboolean chatroom);
+    EmpathyAccount *account, const gchar *chat_id, gboolean chatroom);
 gboolean empathy_log_store_add_message (EmpathyLogStore *self,
     const gchar *chat_id, gboolean chatroom, EmpathyMessage *message,
     GError **error);
 GList *empathy_log_store_get_dates (EmpathyLogStore *self,
-    McAccount *account, const gchar *chat_id, gboolean chatroom);
+    EmpathyAccount *account, const gchar *chat_id, gboolean chatroom);
 GList *empathy_log_store_get_messages_for_date (EmpathyLogStore *self,
-    McAccount *account, const gchar *chat_id, gboolean chatroom,
+    EmpathyAccount *account, const gchar *chat_id, gboolean chatroom,
     const gchar *date);
 GList *empathy_log_store_get_last_messages (EmpathyLogStore *self,
-    McAccount *account, const gchar *chat_id, gboolean chatroom);
+    EmpathyAccount *account, const gchar *chat_id, gboolean chatroom);
 GList *empathy_log_store_get_chats (EmpathyLogStore *self,
-    McAccount *account);
+    EmpathyAccount *account);
 GList *empathy_log_store_search_new (EmpathyLogStore *self,
     const gchar *text);
 void empathy_log_store_ack_message (EmpathyLogStore *self,
     const gchar *chat_id, gboolean chatroom, EmpathyMessage *message);
 GList *empathy_log_store_get_filtered_messages (EmpathyLogStore *self,
-    McAccount *account, const gchar *chat_id, gboolean chatroom,
+    EmpathyAccount *account, const gchar *chat_id, gboolean chatroom,
     guint num_messages, EmpathyLogMessageFilter filter, gpointer user_data);
 
 G_END_DECLS
diff --git a/libempathy/empathy-tp-roomlist.c b/libempathy/empathy-tp-roomlist.c
index 1b2e393d1..b3d955ee4 100644
--- a/libempathy/empathy-tp-roomlist.c
+++ b/libempathy/empathy-tp-roomlist.c
@@ -27,7 +27,7 @@
 #include <telepathy-glib/dbus.h>
 #include <telepathy-glib/util.h>
 
-#include <libmissioncontrol/mission-control.h>
+#include "empathy-account.h"
 
 #include "empathy-tp-roomlist.h"
 #include "empathy-chatroom.h"
@@ -40,7 +40,7 @@
 typedef struct {
 	TpConnection *connection;
 	TpChannel    *channel;
-	McAccount    *account;
+	EmpathyAccount    *account;
 	gboolean      is_listing;
 	gboolean      start_requested;
 } EmpathyTpRoomlistPriv;
@@ -54,7 +54,7 @@ enum {
 
 enum {
 	PROP_0,
-	PROP_CONNECTION,
+	PROP_ACCOUNT,
 	PROP_IS_LISTING,
 };
 
@@ -352,13 +352,9 @@ static void
 tp_roomlist_constructed (GObject *list)
 {
 	EmpathyTpRoomlistPriv *priv = GET_PRIV (list);
-	MissionControl        *mc;
 
-	mc = empathy_mission_control_dup_singleton ();
-	priv->account = mission_control_get_account_for_tpconnection (mc,
-								      priv->connection,
-								      NULL);
-	g_object_unref (mc);
+	priv->connection = empathy_account_get_connection (priv->account);
+	g_object_ref (priv->connection);
 
 	tp_cli_connection_call_request_channel (priv->connection, -1,
 						TP_IFACE_CHANNEL_TYPE_ROOM_LIST,
@@ -379,8 +375,8 @@ tp_roomlist_get_property (GObject    *object,
 	EmpathyTpRoomlistPriv *priv = GET_PRIV (object);
 
 	switch (param_id) {
-	case PROP_CONNECTION:
-		g_value_set_object (value, priv->connection);
+	case PROP_ACCOUNT:
+		g_value_set_object (value, priv->account);
 		break;
 	case PROP_IS_LISTING:
 		g_value_set_boolean (value, priv->is_listing);
@@ -400,8 +396,8 @@ tp_roomlist_set_property (GObject      *object,
 	EmpathyTpRoomlistPriv *priv = GET_PRIV (object);
 
 	switch (param_id) {
-	case PROP_CONNECTION:
-		priv->connection = g_object_ref (g_value_get_object (value));
+	case PROP_ACCOUNT:
+		priv->account = g_value_dup_object (value);
 		break;
 	default:
 		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
@@ -420,11 +416,11 @@ empathy_tp_roomlist_class_init (EmpathyTpRoomlistClass *klass)
 	object_class->set_property = tp_roomlist_set_property;
 
 	g_object_class_install_property (object_class,
-					 PROP_CONNECTION,
-					 g_param_spec_object ("connection",
-							      "The Connection",
-							      "The connection on which it lists rooms",
-							      TP_TYPE_CONNECTION,
+					 PROP_ACCOUNT,
+					 g_param_spec_object ("account",
+							      "The Account",
+							      "The account on which it lists rooms",
+							      EMPATHY_TYPE_ACCOUNT,
 							      G_PARAM_READWRITE |
 							      G_PARAM_CONSTRUCT_ONLY));
 	g_object_class_install_property (object_class,
@@ -480,24 +476,14 @@ empathy_tp_roomlist_init (EmpathyTpRoomlist *list)
 }
 
 EmpathyTpRoomlist *
-empathy_tp_roomlist_new (McAccount *account)
+empathy_tp_roomlist_new (EmpathyAccount *account)
 {
 	EmpathyTpRoomlist *list;
-	MissionControl    *mc;
-	TpConnection      *connection;
-
-	g_return_val_if_fail (MC_IS_ACCOUNT (account), NULL);
-
-	mc = empathy_mission_control_dup_singleton ();
-	connection = mission_control_get_tpconnection (mc, account, NULL);
 
 	list = g_object_new (EMPATHY_TYPE_TP_ROOMLIST,
-			     "connection", connection,
+			     "account", account,
 			     NULL);
 
-	g_object_unref (mc);
-	g_object_unref (connection);
-
 	return list;
 }
 
diff --git a/libempathy/empathy-tp-roomlist.h b/libempathy/empathy-tp-roomlist.h
index 9f45b7f5c..801e5c69f 100644
--- a/libempathy/empathy-tp-roomlist.h
+++ b/libempathy/empathy-tp-roomlist.h
@@ -25,7 +25,7 @@
 #include <glib.h>
 
 #include <telepathy-glib/connection.h>
-#include <libmissioncontrol/mc-account.h>
+#include <libempathy/empathy-account.h>
 
 G_BEGIN_DECLS
 
@@ -49,7 +49,7 @@ struct _EmpathyTpRoomlistClass {
 };
 
 GType              empathy_tp_roomlist_get_type   (void) G_GNUC_CONST;
-EmpathyTpRoomlist *empathy_tp_roomlist_new        (McAccount *account);
+EmpathyTpRoomlist *empathy_tp_roomlist_new        (EmpathyAccount *account);
 gboolean           empathy_tp_roomlist_is_listing (EmpathyTpRoomlist *list);
 void               empathy_tp_roomlist_start      (EmpathyTpRoomlist *list);
 void               empathy_tp_roomlist_stop       (EmpathyTpRoomlist *list);
diff --git a/libempathy/empathy-utils.c b/libempathy/empathy-utils.c
index fca7fcb5f..fd54c9a98 100644
--- a/libempathy/empathy-utils.c
+++ b/libempathy/empathy-utils.c
@@ -230,25 +230,16 @@ empathy_xml_node_find_child_prop_value (xmlNodePtr   node,
 guint
 empathy_account_hash (gconstpointer key)
 {
-	g_return_val_if_fail (MC_IS_ACCOUNT (key), 0);
+	g_return_val_if_fail (EMPATHY_IS_ACCOUNT (key), 0);
 
-	return g_str_hash (mc_account_get_unique_name (MC_ACCOUNT (key)));
+	return g_str_hash (empathy_account_get_unique_name (EMPATHY_ACCOUNT (key)));
 }
 
 gboolean
 empathy_account_equal (gconstpointer a,
 		       gconstpointer b)
 {
-	const gchar *name_a;
-	const gchar *name_b;
-
-	g_return_val_if_fail (MC_IS_ACCOUNT (a), FALSE);
-	g_return_val_if_fail (MC_IS_ACCOUNT (b), FALSE);
-
-	name_a = mc_account_get_unique_name (MC_ACCOUNT (a));
-	name_b = mc_account_get_unique_name (MC_ACCOUNT (b));
-
-	return g_str_equal (name_a, name_b);
+  return a == b;
 }
 
 MissionControl *
diff --git a/libempathy/empathy-utils.h b/libempathy/empathy-utils.h
index de1437b9d..42acbc8e3 100644
--- a/libempathy/empathy-utils.h
+++ b/libempathy/empathy-utils.h
@@ -32,7 +32,6 @@
 #include <libxml/parser.h>
 #include <libxml/tree.h>
 
-#include <libmissioncontrol/mc-account.h>
 #include <libmissioncontrol/mission-control.h>
 
 #include "empathy-contact.h"