diff --git a/server/common-graphics-channel.cpp b/server/common-graphics-channel.cpp
index 0812bd9d..c7cac7e9 100644
--- a/server/common-graphics-channel.cpp
+++ b/server/common-graphics-channel.cpp
@@ -51,7 +51,7 @@ bool CommonGraphicsChannelClient::config_socket()
     gboolean is_low_bandwidth;
 
     // TODO - this should be dynamic, not one time at channel creation
-    is_low_bandwidth = main_channel_client_is_low_bandwidth(mcc);
+    is_low_bandwidth = mcc->is_low_bandwidth();
     if (!red_stream_set_auto_flush(stream, false)) {
         /* FIXME: Using Nagle's Algorithm can lead to apparent delays, depending
          * on the delayed ack timeout on the other side.
diff --git a/server/dcc.cpp b/server/dcc.cpp
index d5f3ae61..021d7a94 100644
--- a/server/dcc.cpp
+++ b/server/dcc.cpp
@@ -1262,7 +1262,7 @@ bool DisplayChannelClient::config_socket()
     RedClient *client = get_client();
     MainChannelClient *mcc = client->get_main();
 
-    is_low_bandwidth = main_channel_client_is_low_bandwidth(mcc);
+    is_low_bandwidth = mcc->is_low_bandwidth();
 
     return CommonGraphicsChannelClient::config_socket();
 }
diff --git a/server/inputs-channel.cpp b/server/inputs-channel.cpp
index a5fc715c..748b0e5e 100644
--- a/server/inputs-channel.cpp
+++ b/server/inputs-channel.cpp
@@ -446,8 +446,7 @@ void InputsChannel::on_connect(RedClient *client, RedStream *stream, int migrati
                                RedChannelCapabilities *caps)
 {
     if (!red_stream_is_ssl(stream) && !client->during_migrate_at_target()) {
-        main_channel_client_push_notify(client->get_main(),
-                                        "keyboard channel is insecure");
+        client->get_main()->push_notify("keyboard channel is insecure");
     }
 
     inputs_channel_client_create(this, client, stream, caps);
diff --git a/server/main-channel-client.cpp b/server/main-channel-client.cpp
index 86f381e5..b9645e2d 100644
--- a/server/main-channel-client.cpp
+++ b/server/main-channel-client.cpp
@@ -218,11 +218,11 @@ static RedPipeItem *main_agent_tokens_item_new(uint32_t num_tokens)
 }
 
 
-void main_channel_client_push_agent_tokens(MainChannelClient *mcc, uint32_t num_tokens)
+void MainChannelClient::push_agent_tokens(uint32_t num_tokens)
 {
     RedPipeItem *item = main_agent_tokens_item_new(num_tokens);
 
-    mcc->pipe_add_push(item);
+    pipe_add_push(item);
 }
 
 static void main_agent_data_item_free(RedPipeItem *base)
@@ -247,13 +247,14 @@ static RedPipeItem *main_agent_data_item_new(uint8_t* data, size_t len,
     return &item->base;
 }
 
-void main_channel_client_push_agent_data(MainChannelClient *mcc, uint8_t* data, size_t len,
-           spice_marshaller_item_free_func free_data, void *opaque)
+void MainChannelClient::push_agent_data(uint8_t *data, size_t len,
+                                        spice_marshaller_item_free_func free_data,
+                                        void *opaque)
 {
     RedPipeItem *item;
 
     item = main_agent_data_item_new(data, len, free_data, opaque);
-    mcc->pipe_add_push(item);
+    pipe_add_push(item);
 }
 
 static RedPipeItem *main_init_item_new(int connection_id,
@@ -275,19 +276,17 @@ static RedPipeItem *main_init_item_new(int connection_id,
     return &item->base;
 }
 
-void main_channel_client_push_init(MainChannelClient *mcc,
-                                   int display_channels_hint,
-                                   SpiceMouseMode current_mouse_mode,
-                                   int is_client_mouse_allowed,
-                                   int multi_media_time,
-                                   int ram_hint)
+void MainChannelClient::push_init(int display_channels_hint,
+                                  SpiceMouseMode current_mouse_mode,
+                                  int is_client_mouse_allowed,
+                                  int multi_media_time, int ram_hint)
 {
     RedPipeItem *item;
 
-    item = main_init_item_new(mcc->priv->connection_id, display_channels_hint,
+    item = main_init_item_new(priv->connection_id, display_channels_hint,
                               current_mouse_mode, is_client_mouse_allowed,
                               multi_media_time, ram_hint);
-    mcc->pipe_add_push(item);
+    pipe_add_push(item);
 }
 
 static RedPipeItem *main_name_item_new(const char *name)
@@ -301,15 +300,15 @@ static RedPipeItem *main_name_item_new(const char *name)
     return &item->base;
 }
 
-void main_channel_client_push_name(MainChannelClient *mcc, const char *name)
+void MainChannelClient::push_name(const char *name)
 {
     RedPipeItem *item;
 
-    if (!mcc->test_remote_cap(SPICE_MAIN_CAP_NAME_AND_UUID))
+    if (!test_remote_cap(SPICE_MAIN_CAP_NAME_AND_UUID))
         return;
 
     item = main_name_item_new(name);
-    mcc->pipe_add_push(item);
+    pipe_add_push(item);
 }
 
 static RedPipeItem *main_uuid_item_new(const uint8_t uuid[16])
@@ -322,21 +321,21 @@ static RedPipeItem *main_uuid_item_new(const uint8_t uuid[16])
     return &item->base;
 }
 
-void main_channel_client_push_uuid(MainChannelClient *mcc, const uint8_t uuid[16])
+void MainChannelClient::push_uuid(const uint8_t uuid[16])
 {
     RedPipeItem *item;
 
-    if (!mcc->test_remote_cap(SPICE_MAIN_CAP_NAME_AND_UUID))
+    if (!test_remote_cap(SPICE_MAIN_CAP_NAME_AND_UUID))
         return;
 
     item = main_uuid_item_new(uuid);
-    mcc->pipe_add_push(item);
+    pipe_add_push(item);
 }
 
-void main_channel_client_push_notify(MainChannelClient *mcc, const char *msg)
+void MainChannelClient::push_notify(const char *msg)
 {
     RedPipeItem *item = main_notify_item_new(msg, 1);
-    mcc->pipe_add_push(item);
+    pipe_add_push(item);
 }
 
 RedPipeItem *main_mouse_mode_item_new(SpiceMouseMode current_mode, int is_client_mouse_allowed)
@@ -371,32 +370,29 @@ RedPipeItem *registered_channel_item_new(RedChannel *channel)
     return &item->base;
 }
 
-void main_channel_client_handle_migrate_connected(MainChannelClient *mcc,
-                                                  int success,
-                                                  int seamless)
+void MainChannelClient::handle_migrate_connected(int success, int seamless)
 {
-    if (mcc->priv->mig_wait_connect) {
-        MainChannel *channel = mcc->get_channel();
+    if (priv->mig_wait_connect) {
+        MainChannel *channel = get_channel();
 
-        mcc->priv->mig_wait_connect = FALSE;
-        mcc->priv->mig_connect_ok = success;
+        priv->mig_wait_connect = FALSE;
+        priv->mig_connect_ok = success;
         channel->on_migrate_connected(success, seamless);
     } else {
         if (success) {
-            mcc->pipe_add_empty_msg(SPICE_MSG_MAIN_MIGRATE_CANCEL);
+            pipe_add_empty_msg(SPICE_MSG_MAIN_MIGRATE_CANCEL);
         }
     }
 }
 
-void main_channel_client_handle_migrate_dst_do_seamless(MainChannelClient *mcc,
-                                                        uint32_t src_version)
+void MainChannelClient::handle_migrate_dst_do_seamless(uint32_t src_version)
 {
-    RedChannel *channel = mcc->get_channel();
-    if (reds_on_migrate_dst_set_seamless(channel->get_server(), mcc, src_version)) {
-        mcc->priv->seamless_mig_dst = TRUE;
-        mcc->pipe_add_empty_msg(SPICE_MSG_MAIN_MIGRATE_DST_SEAMLESS_ACK);
+    RedChannel *channel = get_channel();
+    if (reds_on_migrate_dst_set_seamless(channel->get_server(), this, src_version)) {
+        priv->seamless_mig_dst = TRUE;
+        pipe_add_empty_msg(SPICE_MSG_MAIN_MIGRATE_DST_SEAMLESS_ACK);
     } else {
-        mcc->pipe_add_empty_msg(SPICE_MSG_MAIN_MIGRATE_DST_SEAMLESS_NACK);
+        pipe_add_empty_msg(SPICE_MSG_MAIN_MIGRATE_DST_SEAMLESS_NACK);
     }
 }
 
@@ -446,7 +442,7 @@ void MainChannelClient::handle_pong(SpiceMsgPing *ping, uint32_t size)
                           (double)priv->latency / 1000,
                           priv->bitrate_per_sec,
                           (double)priv->bitrate_per_sec / 1024 / 1024,
-                          main_channel_client_is_low_bandwidth(this) ? " LOW BANDWIDTH" : "");
+                          this->is_low_bandwidth() ? " LOW BANDWIDTH" : "");
         start_connectivity_monitoring(CLIENT_CONNECTIVITY_TIMEOUT);
         break;
     default:
@@ -459,16 +455,16 @@ void MainChannelClient::handle_pong(SpiceMsgPing *ping, uint32_t size)
     }
 }
 
-void main_channel_client_handle_migrate_end(MainChannelClient *mcc)
+void MainChannelClient::handle_migrate_end()
 {
-    RedClient *client = mcc->get_client();
+    RedClient *client = get_client();
     if (!client->during_migrate_at_target()) {
-        red_channel_warning(mcc->get_channel(),
+        red_channel_warning(get_channel(),
                             "unexpected SPICE_MSGC_MIGRATE_END");
         return;
     }
-    if (!mcc->test_remote_cap(SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE)) {
-        red_channel_warning(mcc->get_channel(),
+    if (!test_remote_cap(SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE)) {
+        red_channel_warning(get_channel(),
                             "unexpected SPICE_MSGC_MIGRATE_END, "
                             "client does not support semi-seamless migration");
         return;
@@ -476,49 +472,48 @@ void main_channel_client_handle_migrate_end(MainChannelClient *mcc)
     client->semi_seamless_migrate_complete();
 }
 
-void main_channel_client_migrate_cancel_wait(MainChannelClient *mcc)
+void MainChannelClient::migrate_cancel_wait()
 {
-    if (mcc->priv->mig_wait_connect) {
-        mcc->priv->mig_wait_connect = FALSE;
-        mcc->priv->mig_connect_ok = FALSE;
+    if (priv->mig_wait_connect) {
+        priv->mig_wait_connect = FALSE;
+        priv->mig_connect_ok = FALSE;
     }
-    mcc->priv->mig_wait_prev_complete = FALSE;
+    priv->mig_wait_prev_complete = FALSE;
 }
 
-void main_channel_client_migrate_dst_complete(MainChannelClient *mcc)
+void MainChannelClient::migrate_dst_complete()
 {
-    if (mcc->priv->mig_wait_prev_complete) {
-        if (mcc->priv->mig_wait_prev_try_seamless) {
-            RedChannel *channel = mcc->get_channel();
+    if (priv->mig_wait_prev_complete) {
+        if (priv->mig_wait_prev_try_seamless) {
+            RedChannel *channel = get_channel();
             spice_assert(channel->get_n_clients() == 1);
-            mcc->pipe_add_type(RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
+            pipe_add_type(RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
         } else {
-            mcc->pipe_add_type(RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN);
+            pipe_add_type(RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN);
         }
-        mcc->priv->mig_wait_connect = TRUE;
-        mcc->priv->mig_wait_prev_complete = FALSE;
+        priv->mig_wait_connect = TRUE;
+        priv->mig_wait_prev_complete = FALSE;
     }
 }
 
-gboolean main_channel_client_migrate_src_complete(MainChannelClient *mcc,
-                                                  gboolean success)
+gboolean MainChannelClient::migrate_src_complete(gboolean success)
 {
     gboolean ret = FALSE;
-    bool semi_seamless_support = mcc->test_remote_cap(SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE);
-    if (semi_seamless_support && mcc->priv->mig_connect_ok) {
+    bool semi_seamless_support = test_remote_cap(SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE);
+    if (semi_seamless_support && priv->mig_connect_ok) {
         if (success) {
-            mcc->pipe_add_empty_msg(SPICE_MSG_MAIN_MIGRATE_END);
+            pipe_add_empty_msg(SPICE_MSG_MAIN_MIGRATE_END);
             ret = TRUE;
         } else {
-            mcc->pipe_add_empty_msg(SPICE_MSG_MAIN_MIGRATE_CANCEL);
+            pipe_add_empty_msg(SPICE_MSG_MAIN_MIGRATE_CANCEL);
         }
     } else {
         if (success) {
-            mcc->pipe_add_type(RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST);
+            pipe_add_type(RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST);
         }
     }
-    mcc->priv->mig_connect_ok = FALSE;
-    mcc->priv->mig_wait_connect = FALSE;
+    priv->mig_connect_ok = FALSE;
+    priv->mig_wait_connect = FALSE;
 
     return ret;
 }
@@ -546,25 +541,25 @@ MainChannelClient *main_channel_client_create(MainChannel *main_chan, RedClient
     return mcc;
 }
 
-int main_channel_client_is_network_info_initialized(MainChannelClient *mcc)
+int MainChannelClient::is_network_info_initialized()
 {
-    return mcc->priv->net_test_stage == NET_TEST_STAGE_COMPLETE;
+    return priv->net_test_stage == NET_TEST_STAGE_COMPLETE;
 }
 
-int main_channel_client_is_low_bandwidth(MainChannelClient *mcc)
+int MainChannelClient::is_low_bandwidth()
 {
     // TODO: configurable?
-    return mcc->priv->bitrate_per_sec < 10 * 1024 * 1024;
+    return priv->bitrate_per_sec < 10 * 1024 * 1024;
 }
 
-uint64_t main_channel_client_get_bitrate_per_sec(MainChannelClient *mcc)
+uint64_t MainChannelClient::get_bitrate_per_sec()
 {
-    return mcc->priv->bitrate_per_sec;
+    return priv->bitrate_per_sec;
 }
 
-uint64_t main_channel_client_get_roundtrip_ms(MainChannelClient *mcc)
+uint64_t MainChannelClient::get_roundtrip_ms()
 {
-    return mcc->priv->latency / 1000;
+    return priv->latency / 1000;
 }
 
 void MainChannelClient::migrate()
@@ -574,40 +569,40 @@ void MainChannelClient::migrate()
     RedChannelClient::migrate();
 }
 
-gboolean main_channel_client_connect_semi_seamless(MainChannelClient *mcc)
+gboolean MainChannelClient::connect_semi_seamless()
 {
-    if (mcc->test_remote_cap(SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE)) {
-        RedClient *client = mcc->get_client();
+    if (test_remote_cap(SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE)) {
+        RedClient *client = get_client();
         if (client->during_migrate_at_target()) {
-            mcc->priv->mig_wait_prev_complete = TRUE;
-            mcc->priv->mig_wait_prev_try_seamless = FALSE;
+            priv->mig_wait_prev_complete = TRUE;
+            priv->mig_wait_prev_try_seamless = FALSE;
         } else {
-            mcc->pipe_add_type(RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN);
-            mcc->priv->mig_wait_connect = TRUE;
+            pipe_add_type(RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN);
+            priv->mig_wait_connect = TRUE;
         }
-        mcc->priv->mig_connect_ok = FALSE;
+        priv->mig_connect_ok = FALSE;
         return TRUE;
     }
     return FALSE;
 }
 
-void main_channel_client_connect_seamless(MainChannelClient *mcc)
+void MainChannelClient::connect_seamless()
 {
-    RedClient *client = mcc->get_client();
-    spice_assert(mcc->test_remote_cap(SPICE_MAIN_CAP_SEAMLESS_MIGRATE));
+    RedClient *client = get_client();
+    spice_assert(test_remote_cap(SPICE_MAIN_CAP_SEAMLESS_MIGRATE));
     if (client->during_migrate_at_target()) {
-        mcc->priv->mig_wait_prev_complete = TRUE;
-        mcc->priv->mig_wait_prev_try_seamless = TRUE;
+        priv->mig_wait_prev_complete = TRUE;
+        priv->mig_wait_prev_try_seamless = TRUE;
     } else {
-        mcc->pipe_add_type(RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
-        mcc->priv->mig_wait_connect = TRUE;
+        pipe_add_type(RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
+        priv->mig_wait_connect = TRUE;
     }
-    mcc->priv->mig_connect_ok = FALSE;
+    priv->mig_connect_ok = FALSE;
 }
 
-uint32_t main_channel_client_get_connection_id(MainChannelClient *mcc)
+uint32_t MainChannelClient::get_connection_id()
 {
-    return mcc->priv->connection_id;
+    return priv->connection_id;
 }
 
 static uint32_t main_channel_client_next_ping_id(MainChannelClient *mcc)
diff --git a/server/main-channel-client.h b/server/main-channel-client.h
index 2cbba403..4f040166 100644
--- a/server/main-channel-client.h
+++ b/server/main-channel-client.h
@@ -26,11 +26,48 @@
 
 #include "push-visibility.h"
 
-struct MainChannelClientPrivate;
+class MainChannelClientPrivate;
+
+MainChannelClient *main_channel_client_create(MainChannel *main_chan, RedClient *client,
+                                              RedStream *stream, uint32_t connection_id,
+                                              RedChannelCapabilities *caps);
+
 
 class MainChannelClient final: public RedChannelClient
 {
 public:
+    void push_agent_tokens(uint32_t num_tokens);
+    void push_agent_data(uint8_t *data, size_t len,
+                         spice_marshaller_item_free_func free_data, void *opaque);
+    // TODO: huge. Consider making a reds_* interface for these functions
+    // and calling from main.
+    void push_init(int display_channels_hint, SpiceMouseMode current_mouse_mode,
+                   int is_client_mouse_allowed, int multi_media_time,
+                   int ram_hint);
+    void push_notify(const char *msg);
+    gboolean connect_semi_seamless();
+    void connect_seamless();
+    void handle_migrate_connected(int success, int seamless);
+    void handle_migrate_dst_do_seamless(uint32_t src_version);
+    void handle_migrate_end();
+    void migrate_cancel_wait();
+    void migrate_dst_complete();
+    gboolean migrate_src_complete(gboolean success);
+
+    /*
+     * return TRUE if network test had been completed successfully.
+     * If FALSE, bitrate_per_sec is set to MAX_UINT64 and the roundtrip is set to 0
+     */
+    int is_network_info_initialized();
+    int is_low_bandwidth();
+    uint64_t get_bitrate_per_sec();
+    uint64_t get_roundtrip_ms();
+
+    void push_name(const char *name);
+    void push_uuid(const uint8_t uuid[16]);
+
+    uint32_t get_connection_id();
+
     MainChannelClient(MainChannel *channel,
                       RedClient *client,
                       RedStream *stream,
@@ -58,49 +95,6 @@ public:
     red::unique_link<MainChannelClientPrivate> priv;
 };
 
-MainChannelClient *main_channel_client_create(MainChannel *main_chan, RedClient *client,
-                                              RedStream *stream, uint32_t connection_id,
-                                              RedChannelCapabilities *caps);
-
-void main_channel_client_push_agent_tokens(MainChannelClient *mcc, uint32_t num_tokens);
-void main_channel_client_push_agent_data(MainChannelClient *mcc, uint8_t* data, size_t len,
-                                         spice_marshaller_item_free_func free_data, void *opaque);
-// TODO: huge. Consider making a reds_* interface for these functions
-// and calling from main.
-void main_channel_client_push_init(MainChannelClient *mcc,
-                                   int display_channels_hint,
-                                   SpiceMouseMode current_mouse_mode,
-                                   int is_client_mouse_allowed,
-                                   int multi_media_time,
-                                   int ram_hint);
-void main_channel_client_push_notify(MainChannelClient *mcc, const char *msg);
-gboolean main_channel_client_connect_semi_seamless(MainChannelClient *mcc);
-void main_channel_client_connect_seamless(MainChannelClient *mcc);
-void main_channel_client_handle_migrate_connected(MainChannelClient *mcc,
-                                                  int success,
-                                                  int seamless);
-void main_channel_client_handle_migrate_dst_do_seamless(MainChannelClient *mcc,
-                                                        uint32_t src_version);
-void main_channel_client_handle_migrate_end(MainChannelClient *mcc);
-void main_channel_client_migrate_cancel_wait(MainChannelClient *mcc);
-void main_channel_client_migrate_dst_complete(MainChannelClient *mcc);
-gboolean main_channel_client_migrate_src_complete(MainChannelClient *mcc,
-                                                  gboolean success);
-
-/*
- * return TRUE if network test had been completed successfully.
- * If FALSE, bitrate_per_sec is set to MAX_UINT64 and the roundtrip is set to 0
- */
-int main_channel_client_is_network_info_initialized(MainChannelClient *mcc);
-int main_channel_client_is_low_bandwidth(MainChannelClient *mcc);
-uint64_t main_channel_client_get_bitrate_per_sec(MainChannelClient *mcc);
-uint64_t main_channel_client_get_roundtrip_ms(MainChannelClient *mcc);
-
-void main_channel_client_push_name(MainChannelClient *mcc, const char *name);
-void main_channel_client_push_uuid(MainChannelClient *mcc, const uint8_t uuid[16]);
-
-uint32_t main_channel_client_get_connection_id(MainChannelClient *mcc);
-
 enum {
     RED_PIPE_ITEM_TYPE_MAIN_CHANNELS_LIST = RED_PIPE_ITEM_TYPE_CHANNEL_BASE,
     RED_PIPE_ITEM_TYPE_MAIN_PING,
diff --git a/server/main-channel.cpp b/server/main-channel.cpp
index e7ed8ff9..714a3f4a 100644
--- a/server/main-channel.cpp
+++ b/server/main-channel.cpp
@@ -34,7 +34,7 @@ RedClient *MainChannel::get_client_by_link_id(uint32_t connection_id)
 
     FOREACH_CLIENT(this, rcc) {
         MainChannelClient *mcc = MAIN_CHANNEL_CLIENT(rcc);
-        if (main_channel_client_get_connection_id(mcc) == connection_id) {
+        if (mcc->get_connection_id() == connection_id) {
             return rcc->get_client();
         }
     }
@@ -163,24 +163,19 @@ bool MainChannelClient::handle_message(uint16_t type, uint32_t size, void *messa
         main_channel_push_channels(this);
         break;
     case SPICE_MSGC_MAIN_MIGRATE_CONNECTED:
-        main_channel_client_handle_migrate_connected(this,
-                                                     TRUE /* success */,
-                                                     FALSE /* seamless */);
+        this->handle_migrate_connected(TRUE, FALSE);
         break;
     case SPICE_MSGC_MAIN_MIGRATE_CONNECTED_SEAMLESS:
-        main_channel_client_handle_migrate_connected(this,
-                                                     TRUE /* success */,
-                                                     TRUE /* seamless */);
+        this->handle_migrate_connected(TRUE, TRUE);
         break;
     case SPICE_MSGC_MAIN_MIGRATE_CONNECT_ERROR:
-        main_channel_client_handle_migrate_connected(this, FALSE, FALSE);
+        this->handle_migrate_connected(FALSE, FALSE);
         break;
     case SPICE_MSGC_MAIN_MIGRATE_DST_DO_SEAMLESS:
-        main_channel_client_handle_migrate_dst_do_seamless(this,
-            ((SpiceMsgcMainMigrateDstDoSeamless *)message)->src_version);
+        this->handle_migrate_dst_do_seamless(((SpiceMsgcMainMigrateDstDoSeamless *)message)->src_version);
         break;
     case SPICE_MSGC_MAIN_MIGRATE_END:
-        main_channel_client_handle_migrate_end(this);
+        this->handle_migrate_end();
         break;
     case SPICE_MSGC_MAIN_MOUSE_MODE_REQUEST:
         reds_on_main_mouse_mode_request(reds, message, size);
@@ -234,7 +229,7 @@ static int main_channel_connect_semi_seamless(MainChannel *main_channel)
 
     FOREACH_CLIENT(main_channel, rcc) {
         MainChannelClient *mcc = MAIN_CHANNEL_CLIENT(rcc);
-        if (main_channel_client_connect_semi_seamless(mcc))
+        if (mcc->connect_semi_seamless())
             main_channel->num_clients_mig_wait++;
     }
     return main_channel->num_clients_mig_wait;
@@ -248,7 +243,7 @@ static int main_channel_connect_seamless(MainChannel *main_channel)
 
     FOREACH_CLIENT(main_channel, rcc) {
         MainChannelClient *mcc = MAIN_CHANNEL_CLIENT(rcc);
-        main_channel_client_connect_seamless(mcc);
+        mcc->connect_seamless();
         main_channel->num_clients_mig_wait++;
     }
     return main_channel->num_clients_mig_wait;
@@ -287,7 +282,7 @@ void MainChannel::migrate_cancel_wait()
 
     FOREACH_CLIENT(this, rcc) {
         MainChannelClient *mcc = MAIN_CHANNEL_CLIENT(rcc);
-        main_channel_client_migrate_cancel_wait(mcc);
+        mcc->migrate_cancel_wait();
     }
     num_clients_mig_wait = 0;
 }
@@ -304,7 +299,7 @@ int MainChannel::migrate_src_complete(int success)
 
     FOREACH_CLIENT(this, rcc) {
         MainChannelClient *mcc = MAIN_CHANNEL_CLIENT(rcc);
-        if (main_channel_client_migrate_src_complete(mcc, success))
+        if (mcc->migrate_src_complete(success))
             semi_seamless_count++;
    }
    return semi_seamless_count;
diff --git a/server/reds.cpp b/server/reds.cpp
index 709a224f..e651d8e7 100644
--- a/server/reds.cpp
+++ b/server/reds.cpp
@@ -944,8 +944,7 @@ static void vdi_port_send_msg_to_client(RedCharDevice *self,
     RedVDIReadBuf *agent_data_buf = (RedVDIReadBuf *)msg;
 
     red_pipe_item_ref(msg);
-    main_channel_client_push_agent_data(client->get_main(),
-                                        agent_data_buf->data,
+    client->get_main()->push_agent_data(agent_data_buf->data,
                                         agent_data_buf->len,
                                         vdi_port_read_buf_release,
                                         agent_data_buf);
@@ -955,8 +954,7 @@ static void vdi_port_send_tokens_to_client(RedCharDevice *self,
                                            RedClient *client,
                                            uint32_t tokens)
 {
-    main_channel_client_push_agent_tokens(client->get_main(),
-                                          tokens);
+    client->get_main()->push_agent_tokens(tokens);
 }
 
 static void vdi_port_on_free_self_token(RedCharDevice *self)
@@ -1313,11 +1311,8 @@ void reds_on_main_channel_migrate(RedsState *reds, MainChannelClient *mcc)
         switch (vdi_port_read_buf_process(agent_dev, read_buf)) {
         case AGENT_MSG_FILTER_OK:
             reds_adjust_agent_capabilities(reds, (VDAgentMessage *)read_buf->data);
-            main_channel_client_push_agent_data(mcc,
-                                                read_buf->data,
-                                                read_buf->len,
-                                                vdi_port_read_buf_release,
-                                                read_buf);
+            mcc->push_agent_data(read_buf->data, read_buf->len,
+                                 vdi_port_read_buf_release, read_buf);
             break;
         case AGENT_MSG_FILTER_PROTO_ERROR:
             reds_agent_remove(reds);
@@ -1891,14 +1886,14 @@ static void reds_handle_main_link(RedsState *reds, RedLinkInfo *link)
     }
 
     if (!mig_target) {
-        main_channel_client_push_init(mcc, g_list_length(reds->qxl_instances),
-            reds->mouse_mode, reds->is_client_mouse_allowed,
-            reds_get_mm_time() - MM_TIME_DELTA,
-            reds_qxl_ram_size(reds));
+        mcc->push_init(g_list_length(reds->qxl_instances), reds->mouse_mode,
+                       reds->is_client_mouse_allowed,
+                       reds_get_mm_time() - MM_TIME_DELTA,
+                       reds_qxl_ram_size(reds));
         if (reds->config->spice_name)
-            main_channel_client_push_name(mcc, reds->config->spice_name);
+            mcc->push_name(reds->config->spice_name);
         if (reds->config->spice_uuid_is_set)
-            main_channel_client_push_uuid(mcc, reds->config->spice_uuid);
+            mcc->push_uuid(reds->config->spice_uuid);
     } else {
         reds_mig_target_client_add(reds, client);
     }
@@ -2012,7 +2007,7 @@ void reds_on_client_seamless_migrate_complete(RedsState *reds, RedClient *client
         spice_debug("client no longer exists");
         return;
     }
-    main_channel_client_migrate_dst_complete(client->get_main());
+    client->get_main()->migrate_dst_complete();
 }
 
 void reds_on_client_semi_seamless_migrate_complete(RedsState *reds, RedClient *client)
@@ -2023,13 +2018,12 @@ void reds_on_client_semi_seamless_migrate_complete(RedsState *reds, RedClient *c
     mcc = client->get_main();
 
     // TODO: not doing net test. consider doing it on client_migrate_info
-    main_channel_client_push_init(mcc, g_list_length(reds->qxl_instances),
-                                  reds->mouse_mode,
-                                  reds->is_client_mouse_allowed,
-                                  reds_get_mm_time() - MM_TIME_DELTA,
-                                  reds_qxl_ram_size(reds));
+    mcc->push_init(g_list_length(reds->qxl_instances), reds->mouse_mode,
+                   reds->is_client_mouse_allowed,
+                   reds_get_mm_time() - MM_TIME_DELTA,
+                   reds_qxl_ram_size(reds));
     reds_link_mig_target_channels(reds, client);
-    main_channel_client_migrate_dst_complete(mcc);
+    mcc->migrate_dst_complete();
 }
 
 static void reds_handle_other_links(RedsState *reds, RedLinkInfo *link)
diff --git a/server/sound.cpp b/server/sound.cpp
index ae783df4..758b3f30 100644
--- a/server/sound.cpp
+++ b/server/sound.cpp
@@ -758,7 +758,7 @@ bool SndChannelClient::config_socket()
     }
 #endif
 
-    red_stream_set_no_delay(stream, !main_channel_client_is_low_bandwidth(mcc));
+    red_stream_set_no_delay(stream, !mcc->is_low_bandwidth());
 
     return true;
 }
diff --git a/server/video-stream.cpp b/server/video-stream.cpp
index b4c91924..5608519c 100644
--- a/server/video-stream.cpp
+++ b/server/video-stream.cpp
@@ -641,8 +641,8 @@ static uint64_t get_initial_bit_rate(DisplayChannelClient *dcc, VideoStream *str
         uint64_t net_test_bit_rate;
 
         mcc = dcc->get_client()->get_main();
-        net_test_bit_rate = main_channel_client_is_network_info_initialized(mcc) ?
-                                main_channel_client_get_bitrate_per_sec(mcc) :
+        net_test_bit_rate = mcc->is_network_info_initialized() ?
+                                mcc->get_bitrate_per_sec() :
                                 0;
         bit_rate = MAX(dcc_get_max_stream_bit_rate(dcc), net_test_bit_rate);
         if (bit_rate == 0) {
@@ -680,7 +680,7 @@ static uint32_t get_roundtrip_ms(void *opaque)
          * calculated (e.g., after migration). In such case,
          * main_channel_client_get_roundtrip_ms returns 0.
          */
-        roundtrip = main_channel_client_get_roundtrip_ms(mcc);
+        roundtrip = mcc->get_roundtrip_ms();
     }
 
     return roundtrip;