Re: [PATCH 14/14] Convert RedChannel heirarchy to GObject

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



A patch of this size cannot be accepted, no matter how good it is.
We need to find a way to split it.

Any proposal would be good.

Frediano

> 
> When using private structs with GObject, there's a maximum size of (I
> think) 64k, which was exceeded by the DisplayChannel object. To make
> this work, I had to make several of the arrays here dynamically
> allocated rather than statically allocated.
> ---
>  server/Makefile.am                      |   5 +
>  server/common-graphics-channel-client.c |   3 +-
>  server/common-graphics-channel-client.h |   3 +-
>  server/common-graphics-channel.c        | 181 ++++++++
>  server/common-graphics-channel.h        |  98 +++++
>  server/cursor-channel.c                 | 126 +++---
>  server/cursor-channel.h                 |  37 +-
>  server/dcc-send.c                       |  44 +-
>  server/dcc.c                            |  61 +--
>  server/dcc.h                            |   4 +-
>  server/display-channel-private.h        |  81 ++++
>  server/display-channel.c                | 726
>  ++++++++++++++++++++------------
>  server/display-channel.h                | 158 +++----
>  server/dummy-channel-client.c           |  17 +-
>  server/dummy-channel.c                  |  58 +++
>  server/dummy-channel.h                  |  61 +++
>  server/inputs-channel.c                 | 262 +++++++-----
>  server/inputs-channel.h                 |  30 ++
>  server/main-channel-client.c            |  47 +--
>  server/main-channel-client.h            |   4 +-
>  server/main-channel.c                   | 241 ++++++-----
>  server/main-channel.h                   |  44 +-
>  server/red-channel-client-private.h     |  19 +
>  server/red-channel-client.c             | 197 +++++----
>  server/red-channel-client.h             |   6 +-
>  server/red-channel.c                    | 684 ++++++++++++++++++++----------
>  server/red-channel.h                    | 190 ++++-----
>  server/red-parse-qxl.h                  |   2 +
>  server/red-qxl.c                        |  21 +-
>  server/red-replay-qxl.c                 |   2 +-
>  server/red-worker.c                     | 197 ++-------
>  server/red-worker.h                     |  64 ---
>  server/reds-private.h                   |   3 +-
>  server/reds.c                           |  67 +--
>  server/smartcard.c                      | 131 ++++--
>  server/sound.c                          |  43 +-
>  server/spicevmc.c                       | 339 ++++++++++-----
>  server/stream.c                         |  67 +--
>  server/stream.h                         |   3 -
>  39 files changed, 2753 insertions(+), 1573 deletions(-)
>  create mode 100644 server/common-graphics-channel.c
>  create mode 100644 server/common-graphics-channel.h
>  create mode 100644 server/display-channel-private.h
>  create mode 100644 server/dummy-channel.c
>  create mode 100644 server/dummy-channel.h
> 
> diff --git a/server/Makefile.am b/server/Makefile.am
> index b1de055..2679082 100644
> --- a/server/Makefile.am
> +++ b/server/Makefile.am
> @@ -73,6 +73,8 @@ libserver_la_SOURCES =				\
>  	cache-item.h				\
>  	char-device.c				\
>  	char-device.h				\
> +	common-graphics-channel.c			\
> +	common-graphics-channel.h			\
>  	common-graphics-channel-client.c		\
>  	common-graphics-channel-client.h		\
>  	common-graphics-channel-client-private.h	\
> @@ -102,6 +104,8 @@ libserver_la_SOURCES =				\
>  	red-channel-client.c			\
>  	red-channel-client.h			\
>  	red-channel-client-private.h		\
> +	dummy-channel.c				\
> +	dummy-channel.h				\
>  	dummy-channel-client.c			\
>  	dummy-channel-client.h			\
>  	red-common.h				\
> @@ -124,6 +128,7 @@ libserver_la_SOURCES =				\
>  	red-worker.h				\
>  	display-channel.c			\
>  	display-channel.h			\
> +	display-channel-private.h		\
>  	cursor-channel-client.c		\
>  	cursor-channel-client.h		\
>  	cursor-channel.c			\
> diff --git a/server/common-graphics-channel-client.c
> b/server/common-graphics-channel-client.c
> index e83855b..6277d0b 100644
> --- a/server/common-graphics-channel-client.c
> +++ b/server/common-graphics-channel-client.c
> @@ -19,6 +19,7 @@
>  #endif
>  
>  #include "common-graphics-channel-client-private.h"
> +#include "common-graphics-channel.h"
>  #include "dcc.h"
>  #include "red-channel-client.h"
>  
> @@ -89,7 +90,7 @@ static void
> common_graphics_channel_client_constructed(GObject *object)
>                                               self->priv->is_low_bandwidth ?
>                                               WIDE_CLIENT_ACK_WINDOW :
>                                               NARROW_CLIENT_ACK_WINDOW);
>  
> -    channel->during_target_migrate = self->priv->migration_target;
> +    common_graphics_channel_set_during_target_migrate(channel,
> self->priv->migration_target);
>  }
>  
>  static void
>  common_graphics_channel_client_class_init(CommonGraphicsChannelClientClass
>  *klass)
> diff --git a/server/common-graphics-channel-client.h
> b/server/common-graphics-channel-client.h
> index dc1173a..7acb3a2 100644
> --- a/server/common-graphics-channel-client.h
> +++ b/server/common-graphics-channel-client.h
> @@ -21,6 +21,8 @@
>  #include "red-common.h"
>  #include "red-channel-client.h"
>  
> +#define COMMON_CLIENT_TIMEOUT (NSEC_PER_SEC * 30)
> +
>  G_BEGIN_DECLS
>  
>  #define TYPE_COMMON_GRAPHICS_CHANNEL_CLIENT
>  common_graphics_channel_client_get_type()
> @@ -49,7 +51,6 @@ struct CommonGraphicsChannelClientClass
>  
>  GType common_graphics_channel_client_get_type(void) G_GNUC_CONST;
>  
> -typedef struct CommonGraphicsChannel CommonGraphicsChannel;
>  typedef struct RedClient RedClient;
>  typedef struct RedsStream RedsStream;
>  
> diff --git a/server/common-graphics-channel.c
> b/server/common-graphics-channel.c
> new file mode 100644
> index 0000000..fe211aa
> --- /dev/null
> +++ b/server/common-graphics-channel.c
> @@ -0,0 +1,181 @@
> +/* common-graphics-channel.c */
> +#ifdef HAVE_CONFIG_H
> +#include <config.h>
> +#endif
> +
> +#include <fcntl.h>
> +#include <sys/socket.h>
> +#include <netinet/in.h>
> +#include <netinet/tcp.h>
> +
> +#include "common-graphics-channel.h"
> +#include "common-graphics-channel-client.h"
> +
> +#define CHANNEL_RECEIVE_BUF_SIZE 1024
> +
> +G_DEFINE_ABSTRACT_TYPE(CommonGraphicsChannel, common_graphics_channel,
> RED_TYPE_CHANNEL)
> +
> +#define GRAPHICS_CHANNEL_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o),
> TYPE_COMMON_GRAPHICS_CHANNEL, CommonGraphicsChannelPrivate))
> +
> +struct CommonGraphicsChannelPrivate
> +{
> +    QXLInstance *qxl;
> +    uint8_t recv_buf[CHANNEL_RECEIVE_BUF_SIZE];
> +    uint32_t id_alloc; // bitfield. TODO - use this instead of shift scheme.
> +    int during_target_migrate; /* TRUE when the client that is associated
> with the channel
> +                                  is during migration. Turned off when the
> vm is started.
> +                                  The flag is used to avoid sending messages
> that are artifacts
> +                                  of the transition from stopped vm to
> loaded vm (e.g., recreation
> +                                  of the primary surface) */
> +};
> +
> +enum {
> +    PROP0,
> +    PROP_QXL
> +};
> +
> +static void
> +common_graphics_channel_get_property(GObject *object,
> +                                   guint property_id,
> +                                   GValue *value,
> +                                   GParamSpec *pspec)
> +{
> +    CommonGraphicsChannel *self = COMMON_GRAPHICS_CHANNEL(object);
> +
> +    switch (property_id)
> +    {
> +        case PROP_QXL:
> +            g_value_set_pointer(value, self->priv->qxl);
> +            break;
> +        default:
> +            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
> +    }
> +}
> +
> +static void
> +common_graphics_channel_set_property(GObject *object,
> +                                   guint property_id,
> +                                   const GValue *value,
> +                                   GParamSpec *pspec)
> +{
> +    CommonGraphicsChannel *self = COMMON_GRAPHICS_CHANNEL(object);
> +
> +    switch (property_id)
> +    {
> +        case PROP_QXL:
> +            self->priv->qxl = g_value_get_pointer(value);
> +            break;
> +        default:
> +            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
> +    }
> +}
> +
> +static int common_channel_config_socket(RedChannelClient *rcc)
> +{
> +    RedClient *client = red_channel_client_get_client(rcc);
> +    MainChannelClient *mcc = red_client_get_main(client);
> +    RedsStream *stream = red_channel_client_get_stream(rcc);
> +    CommonGraphicsChannelClient *ccc = COMMON_GRAPHICS_CHANNEL_CLIENT(rcc);
> +    int flags;
> +    int delay_val;
> +    gboolean low_bw;
> +
> +    if ((flags = fcntl(stream->socket, F_GETFL)) == -1) {
> +        spice_warning("accept failed, %s", strerror(errno));
> +        return FALSE;
> +    }
> +
> +    if (fcntl(stream->socket, F_SETFL, flags | O_NONBLOCK) == -1) {
> +        spice_warning("accept failed, %s", strerror(errno));
> +        return FALSE;
> +    }
> +
> +    // TODO - this should be dynamic, not one time at channel creation
> +    low_bw = main_channel_client_is_low_bandwidth(mcc);
> +    common_graphics_channel_client_set_low_bandwidth(ccc, low_bw);
> +    delay_val = low_bw ? 0 : 1;
> +    /* FIXME: Using Nagle's Algorithm can lead to apparent delays, depending
> +     * on the delayed ack timeout on the other side.
> +     * Instead of using Nagle's, we need to implement message buffering on
> +     * the application level.
> +     * see: http://www.stuartcheshire.org/papers/NagleDelayedAck/
> +     */
> +    if (setsockopt(stream->socket, IPPROTO_TCP, TCP_NODELAY, &delay_val,
> +                   sizeof(delay_val)) == -1) {
> +        if (errno != ENOTSUP) {
> +            spice_warning("setsockopt failed, %s", strerror(errno));
> +        }
> +    }
> +    return TRUE;
> +}
> +
> +static uint8_t *common_alloc_recv_buf(RedChannelClient *rcc, uint16_t type,
> uint32_t size)
> +{
> +    RedChannel *channel = red_channel_client_get_channel(rcc);
> +    CommonGraphicsChannel *common = COMMON_GRAPHICS_CHANNEL(channel);
> +
> +    /* SPICE_MSGC_MIGRATE_DATA is the only client message whose size is
> dynamic */
> +    if (type == SPICE_MSGC_MIGRATE_DATA) {
> +        return spice_malloc(size);
> +    }
> +
> +    if (size > CHANNEL_RECEIVE_BUF_SIZE) {
> +        spice_critical("unexpected message size %u (max is %d)", size,
> CHANNEL_RECEIVE_BUF_SIZE);
> +        return NULL;
> +    }
> +    return common->priv->recv_buf;
> +}
> +
> +static void common_release_recv_buf(RedChannelClient *rcc, uint16_t type,
> uint32_t size,
> +                                    uint8_t* msg)
> +{
> +    if (type == SPICE_MSGC_MIGRATE_DATA) {
> +        free(msg);
> +    }
> +}
> +
> +static void
> +common_graphics_channel_class_init(CommonGraphicsChannelClass *klass)
> +{
> +    GObjectClass *object_class = G_OBJECT_CLASS(klass);
> +    RedChannelClass *channel_class = RED_CHANNEL_CLASS(klass);
> +
> +    g_type_class_add_private(klass, sizeof(CommonGraphicsChannelPrivate));
> +
> +    object_class->get_property = common_graphics_channel_get_property;
> +    object_class->set_property = common_graphics_channel_set_property;
> +
> +    channel_class->config_socket = common_channel_config_socket;
> +    channel_class->alloc_recv_buf = common_alloc_recv_buf;
> +    channel_class->release_recv_buf = common_release_recv_buf;
> +
> +    g_object_class_install_property(object_class,
> +                                    PROP_QXL,
> +                                    g_param_spec_pointer("qxl",
> +                                                         "qxl",
> +                                                         "QXLInstance for
> this channel",
> +                                                         G_PARAM_READWRITE |
> +
> G_PARAM_CONSTRUCT_ONLY
> |
> +
> G_PARAM_STATIC_STRINGS));
> +}
> +
> +static void
> +common_graphics_channel_init(CommonGraphicsChannel *self)
> +{
> +    self->priv = GRAPHICS_CHANNEL_PRIVATE(self);
> +}
> +
> +void common_graphics_channel_set_during_target_migrate(CommonGraphicsChannel
> *self, gboolean value)
> +{
> +    self->priv->during_target_migrate = value;
> +}
> +
> +gboolean
> common_graphics_channel_get_during_target_migrate(CommonGraphicsChannel
> *self)
> +{
> +    return self->priv->during_target_migrate;
> +}
> +
> +QXLInstance* common_graphics_channel_get_qxl(CommonGraphicsChannel *self)
> +{
> +    return self->priv->qxl;
> +}
> diff --git a/server/common-graphics-channel.h
> b/server/common-graphics-channel.h
> new file mode 100644
> index 0000000..949470e
> --- /dev/null
> +++ b/server/common-graphics-channel.h
> @@ -0,0 +1,98 @@
> +/* common-graphics-channel.h */
> +/*
> +   Copyright (C) 2009 Red Hat, Inc.
> +
> +   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, see
> <http://www.gnu.org/licenses/>.
> +   */
> +
> +#ifndef __COMMON_GRAPHICS_CHANNEL_H__
> +#define __COMMON_GRAPHICS_CHANNEL_H__
> +
> +#include <glib-object.h>
> +
> +#include "red-channel.h"
> +
> +G_BEGIN_DECLS
> +
> +#define TYPE_COMMON_GRAPHICS_CHANNEL common_graphics_channel_get_type()
> +
> +#define COMMON_GRAPHICS_CHANNEL(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),
> TYPE_COMMON_GRAPHICS_CHANNEL, CommonGraphicsChannel))
> +#define COMMON_GRAPHICS_CHANNEL_CLASS(klass)
> (G_TYPE_CHECK_CLASS_CAST((klass), TYPE_COMMON_GRAPHICS_CHANNEL,
> CommonGraphicsChannelClass))
> +#define COMMON_IS_GRAPHICS_CHANNEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),
> TYPE_COMMON_GRAPHICS_CHANNEL))
> +#define COMMON_IS_GRAPHICS_CHANNEL_CLASS(klass)
> (G_TYPE_CHECK_CLASS_TYPE((klass), TYPE_COMMON_GRAPHICS_CHANNEL))
> +#define COMMON_GRAPHICS_CHANNEL_GET_CLASS(obj)
> (G_TYPE_INSTANCE_GET_CLASS((obj), TYPE_COMMON_GRAPHICS_CHANNEL,
> CommonGraphicsChannelClass))
> +
> +typedef struct CommonGraphicsChannel CommonGraphicsChannel;
> +typedef struct CommonGraphicsChannelClass CommonGraphicsChannelClass;
> +typedef struct CommonGraphicsChannelPrivate CommonGraphicsChannelPrivate;
> +
> +struct CommonGraphicsChannel
> +{
> +    RedChannel parent;
> +
> +    CommonGraphicsChannelPrivate *priv;
> +};
> +
> +struct CommonGraphicsChannelClass
> +{
> +    RedChannelClass parent_class;
> +};
> +
> +GType common_graphics_channel_get_type(void) G_GNUC_CONST;
> +
> +void common_graphics_channel_set_during_target_migrate(CommonGraphicsChannel
> *self, gboolean value);
> +gboolean
> common_graphics_channel_get_during_target_migrate(CommonGraphicsChannel
> *self);
> +QXLInstance* common_graphics_channel_get_qxl(CommonGraphicsChannel *self);
> +
> +enum {
> +    RED_PIPE_ITEM_TYPE_VERB = RED_PIPE_ITEM_TYPE_CHANNEL_BASE,
> +    RED_PIPE_ITEM_TYPE_INVAL_ONE,
> +
> +    RED_PIPE_ITEM_TYPE_COMMON_LAST
> +};
> +
> +typedef struct RedVerbItem {
> +    RedPipeItem base;
> +    uint16_t verb;
> +} RedVerbItem;
> +
> +static inline void red_marshall_verb(RedChannelClient *rcc, RedVerbItem
> *item)
> +{
> +    red_channel_client_init_send_data(rcc, item->verb, NULL);
> +}
> +
> +static inline void red_pipe_add_verb(RedChannelClient* rcc, uint16_t verb)
> +{
> +    RedVerbItem *item = spice_new(RedVerbItem, 1);
> +
> +    red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_VERB);
> +    item->verb = verb;
> +    red_channel_client_pipe_add(rcc, &item->base);
> +}
> +
> +static inline void red_pipe_add_verb_proxy(RedChannelClient *rcc, gpointer
> data)
> +{
> +    uint16_t verb = GPOINTER_TO_UINT(data);
> +    red_pipe_add_verb(rcc, verb);
> +}
> +
> +static inline void red_pipes_add_verb(RedChannel *channel, uint16_t verb)
> +{
> +    red_channel_apply_clients_data(channel, red_pipe_add_verb_proxy,
> GUINT_TO_POINTER(verb));
> +}
> +
> +
> +G_END_DECLS
> +
> +#endif /* __COMMON_GRAPHICS_CHANNEL_H__ */
> diff --git a/server/cursor-channel.c b/server/cursor-channel.c
> index 032a1e1..26c72d8 100644
> --- a/server/cursor-channel.c
> +++ b/server/cursor-channel.c
> @@ -24,6 +24,7 @@
>  #include "common-graphics-channel-client-private.h"
>  #include "cursor-channel.h"
>  #include "reds.h"
> +#include "red-qxl.h"
>  
>  enum {
>      RED_PIPE_ITEM_TYPE_CURSOR = RED_PIPE_ITEM_TYPE_COMMON_LAST,
> @@ -45,9 +46,12 @@ typedef struct RedCursorPipeItem {
>      int refs;
>  } RedCursorPipeItem;
>  
> -struct CursorChannel {
> -    CommonGraphicsChannel common; // Must be the first thing
> +G_DEFINE_TYPE(CursorChannel, cursor_channel, TYPE_COMMON_GRAPHICS_CHANNEL)
>  
> +#define CURSOR_CHANNEL_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o),
> TYPE_CURSOR_CHANNEL, CursorChannelPrivate))
> +
> +struct CursorChannelPrivate
> +{
>      CursorItem *item;
>      int cursor_visible;
>      SpicePoint16 cursor_position;
> @@ -104,10 +108,10 @@ static void cursor_item_unref(CursorItem *item)
>  
>  static void cursor_set_item(CursorChannel *cursor, CursorItem *item)
>  {
> -    if (cursor->item)
> -        cursor_item_unref(cursor->item);
> +    if (cursor->priv->item)
> +        cursor_item_unref(cursor->priv->item);
>  
> -    cursor->item = item ? cursor_item_ref(item) : NULL;
> +    cursor->priv->item = item ? cursor_item_ref(item) : NULL;
>  }
>  
>  static RedPipeItem *new_cursor_pipe_item(RedChannelClient *rcc, void *data,
>  int num)
> @@ -237,12 +241,12 @@ static void red_marshall_cursor_init(RedChannelClient
> *rcc, SpiceMarshaller *bas
>      cursor_channel = (CursorChannel*)red_channel_client_get_channel(rcc);
>  
>      red_channel_client_init_send_data(rcc, SPICE_MSG_CURSOR_INIT, NULL);
> -    msg.visible = cursor_channel->cursor_visible;
> -    msg.position = cursor_channel->cursor_position;
> -    msg.trail_length = cursor_channel->cursor_trail_length;
> -    msg.trail_frequency = cursor_channel->cursor_trail_frequency;
> +    msg.visible = cursor_channel->priv->cursor_visible;
> +    msg.position = cursor_channel->priv->cursor_position;
> +    msg.trail_length = cursor_channel->priv->cursor_trail_length;
> +    msg.trail_frequency = cursor_channel->priv->cursor_trail_frequency;
>  
> -    cursor_fill(ccc, &msg.cursor, cursor_channel->item, &info);
> +    cursor_fill(ccc, &msg.cursor, cursor_channel->priv->item, &info);
>      spice_marshall_msg_cursor_init(base_marshaller, &msg);
>      add_buf_from_info(base_marshaller, &info);
>  }
> @@ -251,8 +255,7 @@ static void cursor_marshall(RedChannelClient *rcc,
>                              SpiceMarshaller *m,
>                              RedCursorPipeItem *cursor_pipe_item)
>  {
> -    CursorChannel *cursor_channel =
> SPICE_CONTAINEROF(red_channel_client_get_channel(rcc),
> -                                                      CursorChannel,
> common.base);
> +    CursorChannel *cursor_channel =
> CURSOR_CHANNEL(red_channel_client_get_channel(rcc));
>      CursorChannelClient *ccc = CURSOR_CHANNEL_CLIENT(rcc);
>      CursorItem *item = cursor_pipe_item->cursor_item;
>      RedPipeItem *pipe_item = &cursor_pipe_item->base;
> @@ -277,7 +280,7 @@ static void cursor_marshall(RedChannelClient *rcc,
>  
>              red_channel_client_init_send_data(rcc, SPICE_MSG_CURSOR_SET,
>              pipe_item);
>              cursor_set.position = cmd->u.set.position;
> -            cursor_set.visible = cursor_channel->cursor_visible;
> +            cursor_set.visible = cursor_channel->priv->cursor_visible;
>  
>              cursor_fill(ccc, &cursor_set.cursor, item, &info);
>              spice_marshall_msg_cursor_set(m, &cursor_set);
> @@ -378,27 +381,17 @@ static void
> cursor_channel_release_item(RedChannelClient *rcc, RedPipeItem *item
>      }
>  }
>  
> -CursorChannel* cursor_channel_new(RedWorker *worker)
> +CursorChannel* cursor_channel_new(SpiceServer *reds, QXLInstance *qxl,
> +                                  const SpiceCoreInterfaceInternal *core)
>  {
> -    CursorChannel *cursor_channel;
> -    CommonGraphicsChannel *channel = NULL;
> -    ChannelCbs cbs = {
> -        .on_disconnect =  cursor_channel_client_on_disconnect,
> -        .send_item = cursor_channel_send_item,
> -        .hold_item = cursor_channel_hold_pipe_item,
> -        .release_item = cursor_channel_release_item
> -    };
> -
>      spice_info("create cursor channel");
> -    channel = red_worker_new_channel(worker, sizeof(CursorChannel),
> "cursor_channel",
> -                                     SPICE_CHANNEL_CURSOR, 0,
> -                                     &cbs,
> red_channel_client_handle_message);
> -
> -    cursor_channel = (CursorChannel *)channel;
> -    cursor_channel->cursor_visible = TRUE;
> -    cursor_channel->mouse_mode = SPICE_MOUSE_MODE_SERVER;
> -
> -    return cursor_channel;
> +    return g_object_new(TYPE_CURSOR_CHANNEL,
> +                        "spice-server", reds,
> +                        "core-interface", core,
> +                        "channel-type", SPICE_CHANNEL_CURSOR,
> +                        "migration-flags", 0,
> +                        "qxl", qxl,
> +                        NULL);
>  }
>  
>  void cursor_channel_process_cmd(CursorChannel *cursor, RedCursorCmd
>  *cursor_cmd)
> @@ -409,35 +402,36 @@ void cursor_channel_process_cmd(CursorChannel *cursor,
> RedCursorCmd *cursor_cmd)
>      spice_return_if_fail(cursor);
>      spice_return_if_fail(cursor_cmd);
>  
> -    cursor_item = cursor_item_new(cursor->common.qxl, cursor_cmd);
> +    cursor_item =
> cursor_item_new(common_graphics_channel_get_qxl(COMMON_GRAPHICS_CHANNEL(cursor)),
> +                                  cursor_cmd);
>  
>      switch (cursor_cmd->type) {
>      case QXL_CURSOR_SET:
> -        cursor->cursor_visible = cursor_cmd->u.set.visible;
> +        cursor->priv->cursor_visible = cursor_cmd->u.set.visible;
>          cursor_set_item(cursor, cursor_item);
>          break;
>      case QXL_CURSOR_MOVE:
> -        cursor_show = !cursor->cursor_visible;
> -        cursor->cursor_visible = TRUE;
> -        cursor->cursor_position = cursor_cmd->u.position;
> +        cursor_show = !cursor->priv->cursor_visible;
> +        cursor->priv->cursor_visible = TRUE;
> +        cursor->priv->cursor_position = cursor_cmd->u.position;
>          break;
>      case QXL_CURSOR_HIDE:
> -        cursor->cursor_visible = FALSE;
> +        cursor->priv->cursor_visible = FALSE;
>          break;
>      case QXL_CURSOR_TRAIL:
> -        cursor->cursor_trail_length = cursor_cmd->u.trail.length;
> -        cursor->cursor_trail_frequency = cursor_cmd->u.trail.frequency;
> +        cursor->priv->cursor_trail_length = cursor_cmd->u.trail.length;
> +        cursor->priv->cursor_trail_frequency =
> cursor_cmd->u.trail.frequency;
>          break;
>      default:
>          spice_warning("invalid cursor command %u", cursor_cmd->type);
>          return;
>      }
>  
> -    if (red_channel_is_connected(&cursor->common.base) &&
> -        (cursor->mouse_mode == SPICE_MOUSE_MODE_SERVER
> +    if (red_channel_is_connected(RED_CHANNEL(cursor)) &&
> +        (cursor->priv->mouse_mode == SPICE_MOUSE_MODE_SERVER
>           || cursor_cmd->type != QXL_CURSOR_MOVE
>           || cursor_show)) {
> -        red_channel_pipes_new_add(&cursor->common.base,
> +        red_channel_pipes_new_add(RED_CHANNEL(cursor),
>                                    new_cursor_pipe_item, cursor_item);
>      }
>  
> @@ -446,34 +440,34 @@ void cursor_channel_process_cmd(CursorChannel *cursor,
> RedCursorCmd *cursor_cmd)
>  
>  void cursor_channel_reset(CursorChannel *cursor)
>  {
> -    RedChannel *channel = &cursor->common.base;
> +    RedChannel *channel = RED_CHANNEL(cursor);
>  
>      spice_return_if_fail(cursor);
>  
>      cursor_set_item(cursor, NULL);
> -    cursor->cursor_visible = TRUE;
> -    cursor->cursor_position.x = cursor->cursor_position.y = 0;
> -    cursor->cursor_trail_length = cursor->cursor_trail_frequency = 0;
> +    cursor->priv->cursor_visible = TRUE;
> +    cursor->priv->cursor_position.x = cursor->priv->cursor_position.y = 0;
> +    cursor->priv->cursor_trail_length = cursor->priv->cursor_trail_frequency
> = 0;
>  
>      if (red_channel_is_connected(channel)) {
>          red_channel_pipes_add_type(channel,
>          RED_PIPE_ITEM_TYPE_INVAL_CURSOR_CACHE);
> -        if (!cursor->common.during_target_migrate) {
> +        if
> (!common_graphics_channel_get_during_target_migrate(COMMON_GRAPHICS_CHANNEL(cursor)))
> {
>              red_pipes_add_verb(channel, SPICE_MSG_CURSOR_RESET);
>          }
> -        if (!red_channel_wait_all_sent(&cursor->common.base,
> +        if (!red_channel_wait_all_sent(RED_CHANNEL(cursor),
>                                         COMMON_CLIENT_TIMEOUT)) {
> -            red_channel_apply_clients(channel,
> +            red_channel_apply_clients(RED_CHANNEL(cursor),
>                                        red_channel_client_disconnect_if_pending_send);
>          }
>      }
>  }
>  
> -void cursor_channel_init(CursorChannel *cursor, CursorChannelClient *client)
> +void cursor_channel_do_init(CursorChannel *cursor, CursorChannelClient
> *client)
>  {
>      spice_return_if_fail(cursor);
>  
> -    if (!red_channel_is_connected(&cursor->common.base)
> -        || COMMON_GRAPHICS_CHANNEL(cursor)->during_target_migrate) {
> +    if (!red_channel_is_connected(RED_CHANNEL(cursor))
> +        ||
> common_graphics_channel_get_during_target_migrate(COMMON_GRAPHICS_CHANNEL(cursor)))
> {
>          spice_debug("during_target_migrate: skip init");
>          return;
>      }
> @@ -489,5 +483,29 @@ void cursor_channel_set_mouse_mode(CursorChannel
> *cursor, uint32_t mode)
>  {
>      spice_return_if_fail(cursor);
>  
> -    cursor->mouse_mode = mode;
> +    cursor->priv->mouse_mode = mode;
> +}
> +
> +static void
> +cursor_channel_class_init(CursorChannelClass *klass)
> +{
> +    RedChannelClass *channel_class = RED_CHANNEL_CLASS(klass);
> +
> +    g_type_class_add_private(klass, sizeof(CursorChannelPrivate));
> +
> +    channel_class->parser =
> spice_get_client_channel_parser(SPICE_CHANNEL_CURSOR, NULL);
> +    channel_class->handle_parsed = red_channel_client_handle_message;
> +
> +    channel_class->on_disconnect =  cursor_channel_client_on_disconnect;
> +    channel_class->send_item = cursor_channel_send_item;
> +    channel_class->hold_item = cursor_channel_hold_pipe_item;
> +    channel_class->release_item = cursor_channel_release_item;
> +}
> +
> +static void
> +cursor_channel_init(CursorChannel *self)
> +{
> +    self->priv = CURSOR_CHANNEL_PRIVATE(self);
> +    self->priv->cursor_visible = TRUE;
> +    self->priv->mouse_mode = SPICE_MOUSE_MODE_SERVER;
>  }
> diff --git a/server/cursor-channel.h b/server/cursor-channel.h
> index 2b09b21..81ad96f 100644
> --- a/server/cursor-channel.h
> +++ b/server/cursor-channel.h
> @@ -19,16 +19,47 @@
>  # define CURSOR_CHANNEL_H_
>  
>  #include "cursor-channel-client.h"
> -#include "red-worker.h"
> +#include "common-graphics-channel.h"
> +#include "red-parse-qxl.h"
> +
> +G_BEGIN_DECLS
> +
> +#define TYPE_CURSOR_CHANNEL cursor_channel_get_type()
> +
> +#define CURSOR_CHANNEL(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),
> TYPE_CURSOR_CHANNEL, CursorChannel))
> +#define CURSOR_CHANNEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),
> TYPE_CURSOR_CHANNEL, CursorChannelClass))
> +#define IS_CURSOR_CHANNEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),
> TYPE_CURSOR_CHANNEL))
> +#define IS_CURSOR_CHANNEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),
> TYPE_CURSOR_CHANNEL))
> +#define CURSOR_CHANNEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj),
> TYPE_CURSOR_CHANNEL, CursorChannelClass))
>  
>  typedef struct CursorChannel CursorChannel;
> +typedef struct CursorChannelClass CursorChannelClass;
> +typedef struct CursorChannelPrivate CursorChannelPrivate;
> +
> +struct CursorChannel
> +{
> +    CommonGraphicsChannel parent;
> +
> +    CursorChannelPrivate *priv;
> +};
> +
> +struct CursorChannelClass
> +{
> +    CommonGraphicsChannelClass parent_class;
> +};
> +
> +GType cursor_channel_get_type(void) G_GNUC_CONST;
> +
>  typedef struct CursorItem CursorItem;
>  
> -CursorChannel*       cursor_channel_new         (RedWorker *worker);
> +CursorChannel*       cursor_channel_new         (SpiceServer *reds,
> QXLInstance *qxl,
> +                                                 const
> SpiceCoreInterfaceInternal *core);
>  void                 cursor_channel_disconnect  (CursorChannel
>  *cursor_channel);
>  void                 cursor_channel_reset       (CursorChannel *cursor);
> -void                 cursor_channel_init        (CursorChannel *cursor,
> CursorChannelClient* client);
> +void                 cursor_channel_do_init     (CursorChannel *cursor,
> CursorChannelClient* client);
>  void                 cursor_channel_process_cmd (CursorChannel *cursor,
>  RedCursorCmd *cursor_cmd);
>  void                 cursor_channel_set_mouse_mode(CursorChannel *cursor,
>  uint32_t mode);
>  
> +G_END_DECLS
> +
>  #endif /* CURSOR_CHANNEL_H_ */
> diff --git a/server/dcc-send.c b/server/dcc-send.c
> index 2525753..9b9af93 100644
> --- a/server/dcc-send.c
> +++ b/server/dcc-send.c
> @@ -21,6 +21,7 @@
>  
>  #include "dcc-private.h"
>  #include "display-channel.h"
> +#include "display-channel-private.h"
>  
>  #include "common/marshaller.h"
>  #include "common/generated_server_marshallers.h"
> @@ -94,9 +95,9 @@ static int is_surface_area_lossy(DisplayChannelClient *dcc,
> uint32_t surface_id,
>      QRegion lossy_region;
>      DisplayChannel *display = DCC_TO_DC(dcc);
>  
> -    spice_return_val_if_fail(validate_surface(display, surface_id), FALSE);
> +    spice_return_val_if_fail(display_channel_validate_surface(display,
> surface_id), FALSE);
>  
> -    surface = &display->surfaces[surface_id];
> +    surface = &display->priv->surfaces[surface_id];
>      surface_lossy_region =
>      &dcc->priv->surface_client_lossy_region[surface_id];
>  
>      if (!area) {
> @@ -197,8 +198,7 @@ static void
> red_display_add_image_to_pixmap_cache(RedChannelClient *rcc,
>                                                    int is_lossy)
>  {
>      DisplayChannel *display_channel =
> -        SPICE_CONTAINEROF(red_channel_client_get_channel(rcc),
> DisplayChannel,
> -                          common.base);
> +        DISPLAY_CHANNEL(red_channel_client_get_channel(rcc));
>      DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc);
>  
>      if ((image->descriptor.flags & SPICE_IMAGE_FLAGS_CACHE_ME)) {
> @@ -210,13 +210,13 @@ static void
> red_display_add_image_to_pixmap_cache(RedChannelClient *rcc,
>                  io_image->descriptor.flags |= SPICE_IMAGE_FLAGS_CACHE_ME;
>                  dcc->priv->send_data.pixmap_cache_items[dcc->priv->send_data.num_pixmap_cache_items++]
>                  =
>                      image->descriptor.id;
> -                stat_inc_counter(reds,
> display_channel->add_to_cache_counter, 1);
> +                stat_inc_counter(reds,
> display_channel->priv->add_to_cache_counter, 1);
>              }
>          }
>      }
>  
>      if (!(io_image->descriptor.flags & SPICE_IMAGE_FLAGS_CACHE_ME)) {
> -        stat_inc_counter(reds, display_channel->non_cache_counter, 1);
> +        stat_inc_counter(reds, display_channel->priv->non_cache_counter, 1);
>      }
>  }
>  
> @@ -367,7 +367,7 @@ static FillBitsType fill_bits(DisplayChannelClient *dcc,
> SpiceMarshaller *m,
>              dcc->priv->send_data.pixmap_cache_items[dcc->priv->send_data.num_pixmap_cache_items++]
>              =
>                                                                                 image.descriptor.id;
>              if (can_lossy || !lossy_cache_item) {
> -                if (!display->enable_jpeg || lossy_cache_item) {
> +                if (!display->priv->enable_jpeg || lossy_cache_item) {
>                      image.descriptor.type = SPICE_IMAGE_TYPE_FROM_CACHE;
>                  } else {
>                      // making sure, in multiple monitor scenario, that lossy
>                      items that
> @@ -379,7 +379,7 @@ static FillBitsType fill_bits(DisplayChannelClient *dcc,
> SpiceMarshaller *m,
>                                       &bitmap_palette_out,
>                                       &lzplt_palette_out);
>                  spice_assert(bitmap_palette_out == NULL);
>                  spice_assert(lzplt_palette_out == NULL);
> -                stat_inc_counter(reds, display->cache_hits_counter, 1);
> +                stat_inc_counter(reds, display->priv->cache_hits_counter,
> 1);
>                  pthread_mutex_unlock(&dcc->priv->pixmap_cache->lock);
>                  return FILL_BITS_TYPE_CACHE;
>              } else {
> @@ -396,13 +396,13 @@ static FillBitsType fill_bits(DisplayChannelClient
> *dcc, SpiceMarshaller *m,
>          RedSurface *surface;
>  
>          surface_id = simage->u.surface.surface_id;
> -        if (!validate_surface(display, surface_id)) {
> +        if (!display_channel_validate_surface(display, surface_id)) {
>              spice_warning("Invalid surface in SPICE_IMAGE_TYPE_SURFACE");
>              pthread_mutex_unlock(&dcc->priv->pixmap_cache->lock);
>              return FILL_BITS_TYPE_SURFACE;
>          }
>  
> -        surface = &display->surfaces[surface_id];
> +        surface = &display->priv->surfaces[surface_id];
>          image.descriptor.type = SPICE_IMAGE_TYPE_SURFACE;
>          image.descriptor.flags = 0;
>          image.descriptor.width = surface->context.width;
> @@ -1692,7 +1692,7 @@ static int red_marshall_stream_data(RedChannelClient
> *rcc,
>          height = stream->height;
>      }
>  
> -    StreamAgent *agent = &dcc->priv->stream_agents[get_stream_id(display,
> stream)];
> +    StreamAgent *agent =
> &dcc->priv->stream_agents[display_channel_get_stream_id(display, stream)];
>      uint64_t time_now = spice_get_monotonic_time_ns();
>      size_t outbuf_size;
>  
> @@ -1739,7 +1739,7 @@ static int red_marshall_stream_data(RedChannelClient
> *rcc,
>  
>          red_channel_client_init_send_data(rcc,
>          SPICE_MSG_DISPLAY_STREAM_DATA, NULL);
>  
> -        stream_data.base.id = get_stream_id(display, stream);
> +        stream_data.base.id = display_channel_get_stream_id(display,
> stream);
>          stream_data.base.multi_media_time = frame_mm_time;
>          stream_data.data_size = n;
>  
> @@ -1749,7 +1749,7 @@ static int red_marshall_stream_data(RedChannelClient
> *rcc,
>  
>          red_channel_client_init_send_data(rcc,
>          SPICE_MSG_DISPLAY_STREAM_DATA_SIZED, NULL);
>  
> -        stream_data.base.id = get_stream_id(display, stream);
> +        stream_data.base.id = display_channel_get_stream_id(display,
> stream);
>          stream_data.base.multi_media_time = frame_mm_time;
>          stream_data.data_size = n;
>          stream_data.width = width;
> @@ -1822,8 +1822,7 @@ static void
> display_channel_marshall_migrate_data(RedChannelClient *rcc,
>      DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc);
>      SpiceMigrateDataDisplay display_data = {0,};
>  
> -    display_channel = SPICE_CONTAINEROF(red_channel_client_get_channel(rcc),
> -                                        DisplayChannel, common.base);
> +    display_channel = DISPLAY_CHANNEL(red_channel_client_get_channel(rcc));
>  
>      red_channel_client_init_send_data(rcc, SPICE_MSG_MIGRATE_DATA, NULL);
>      spice_marshaller_add_uint32(base_marshaller,
>      SPICE_MIGRATE_DATA_DISPLAY_MAGIC);
> @@ -1853,7 +1852,7 @@ static void
> display_channel_marshall_migrate_data(RedChannelClient *rcc,
>      spice_marshaller_add(base_marshaller,
>                           (uint8_t *)&display_data, sizeof(display_data) -
>                           sizeof(uint32_t));
>      display_channel_marshall_migrate_data_surfaces(dcc, base_marshaller,
> -
> display_channel->enable_jpeg);
> +
> display_channel->priv->enable_jpeg);
>  }
>  
>  static void display_channel_marshall_pixmap_sync(RedChannelClient *rcc,
> @@ -2132,8 +2131,7 @@ static void marshall_qxl_drawable(RedChannelClient
> *rcc,
>  
>      Drawable *item = dpi->drawable;
>      DisplayChannel *display =
> -        SPICE_CONTAINEROF(red_channel_client_get_channel(rcc),
> DisplayChannel,
> -                          common.base);
> +        DISPLAY_CHANNEL(red_channel_client_get_channel(rcc));
>  
>      spice_return_if_fail(display);
>      /* allow sized frames to be streamed, even if they where replaced by
>      another frame, since
> @@ -2141,7 +2139,7 @@ static void marshall_qxl_drawable(RedChannelClient
> *rcc,
>      if ((item->stream || item->sized_stream) &&
>      red_marshall_stream_data(rcc, m, item)) {
>          return;
>      }
> -    if (display->enable_jpeg)
> +    if (display->priv->enable_jpeg)
>          marshall_lossy_qxl_drawable(rcc, m, dpi);
>      else
>          marshall_lossless_qxl_drawable(rcc, m, dpi);
> @@ -2160,7 +2158,7 @@ static void marshall_stream_start(RedChannelClient
> *rcc,
>      SpiceClipRects clip_rects;
>  
>      stream_create.surface_id = 0;
> -    stream_create.id = get_stream_id(DCC_TO_DC(dcc), stream);
> +    stream_create.id = display_channel_get_stream_id(DCC_TO_DC(dcc),
> stream);
>      stream_create.flags = stream->top_down ? SPICE_STREAM_FLAGS_TOP_DOWN :
>      0;
>      stream_create.codec_type = SPICE_VIDEO_CODEC_TYPE_MJPEG;
>  
> @@ -2196,7 +2194,7 @@ static void marshall_stream_clip(RedChannelClient *rcc,
>      red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_STREAM_CLIP,
>      &item->base);
>      SpiceMsgDisplayStreamClip stream_clip;
>  
> -    stream_clip.id = get_stream_id(DCC_TO_DC(dcc), agent->stream);
> +    stream_clip.id = display_channel_get_stream_id(DCC_TO_DC(dcc),
> agent->stream);
>      stream_clip.clip.type = item->clip_type;
>      stream_clip.clip.rects = item->rects;
>  
> @@ -2210,7 +2208,7 @@ static void marshall_stream_end(RedChannelClient *rcc,
>      SpiceMsgDisplayStreamDestroy destroy;
>  
>      red_channel_client_init_send_data(rcc, SPICE_MSG_DISPLAY_STREAM_DESTROY,
>      NULL);
> -    destroy.id = get_stream_id(DCC_TO_DC(dcc), agent->stream);
> +    destroy.id = display_channel_get_stream_id(DCC_TO_DC(dcc),
> agent->stream);
>      stream_agent_stop(agent);
>      spice_marshall_msg_display_stream_destroy(base_marshaller, &destroy);
>  }
> @@ -2319,7 +2317,7 @@ static void marshall_gl_scanout(RedChannelClient *rcc,
>  {
>      DisplayChannelClient *dcc = DISPLAY_CHANNEL_CLIENT(rcc);
>      DisplayChannel *display_channel = DCC_TO_DC(dcc);
> -    QXLInstance* qxl = display_channel->common.qxl;
> +    QXLInstance* qxl =
> common_graphics_channel_get_qxl(COMMON_GRAPHICS_CHANNEL(display_channel));
>  
>      SpiceMsgDisplayGlScanoutUnix *scanout = red_qxl_get_gl_scanout(qxl);
>      if (scanout != NULL) {
> diff --git a/server/dcc.c b/server/dcc.c
> index 6b5517e..d3c77f4 100644
> --- a/server/dcc.c
> +++ b/server/dcc.c
> @@ -22,6 +22,7 @@
>  #include "dcc-private.h"
>  #include "dcc.h"
>  #include "display-channel.h"
> +#include "display-channel-private.h"
>  #include "red-channel-client-private.h"
>  #include "spice-server-enums.h"
>  
> @@ -305,12 +306,12 @@ void dcc_create_surface(DisplayChannelClient *dcc, int
> surface_id)
>      flags = is_primary_surface(DCC_TO_DC(dcc), surface_id) ?
>      SPICE_SURFACE_FLAGS_PRIMARY : 0;
>  
>      /* don't send redundant create surface commands to client */
> -    if (!dcc || display->common.during_target_migrate ||
> +    if (!dcc ||
> common_graphics_channel_get_during_target_migrate(COMMON_GRAPHICS_CHANNEL(display))
> ||
>          dcc->priv->surface_client_created[surface_id]) {
>          return;
>      }
>      channel = red_channel_client_get_channel(RED_CHANNEL_CLIENT(dcc));
> -    surface = &display->surfaces[surface_id];
> +    surface = &display->priv->surfaces[surface_id];
>      create = red_surface_create_item_new(channel,
>                                           surface_id, surface->context.width,
>                                           surface->context.height,
> @@ -327,7 +328,7 @@ RedImageItem
> *dcc_add_surface_area_image(DisplayChannelClient *dcc,
>                                           int can_lossy)
>  {
>      DisplayChannel *display = DCC_TO_DC(dcc);
> -    RedSurface *surface = &display->surfaces[surface_id];
> +    RedSurface *surface = &display->priv->surfaces[surface_id];
>      SpiceCanvas *canvas = surface->context.canvas;
>      RedImageItem *item;
>      int stride;
> @@ -393,7 +394,7 @@ void dcc_push_surface_image(DisplayChannelClient *dcc,
> int surface_id)
>      }
>  
>      display = DCC_TO_DC(dcc);
> -    surface = &display->surfaces[surface_id];
> +    surface = &display->priv->surfaces[surface_id];
>      if (!surface->context.canvas) {
>          return;
>      }
> @@ -495,7 +496,7 @@ static void dcc_init_stream_agents(DisplayChannelClient
> *dcc)
>      dcc->priv->stream_agents = g_new0(StreamAgent, NUM_STREAMS);
>      for (i = 0; i < NUM_STREAMS; i++) {
>          StreamAgent *agent = &dcc->priv->stream_agents[i];
> -        agent->stream = &display->streams_buf[i];
> +        agent->stream = &display->priv->streams_buf[i];
>          region_init(&agent->vis_region);
>          region_init(&agent->clip);
>          red_pipe_item_init(&agent->create_item,
>          RED_PIPE_ITEM_TYPE_STREAM_CREATE);
> @@ -552,7 +553,7 @@ DisplayChannelClient *dcc_new(DisplayChannel *display,
>  
>  static void dcc_create_all_streams(DisplayChannelClient *dcc)
>  {
> -    Ring *ring = &DCC_TO_DC(dcc)->streams;
> +    Ring *ring = &DCC_TO_DC(dcc)->priv->streams;
>      RingItem *item = ring;
>  
>      while ((item = ring_next(ring, item))) {
> @@ -606,7 +607,7 @@ void dcc_start(DisplayChannelClient *dcc)
>          return;
>  
>      red_channel_client_ack_zero_messages_window(RED_CHANNEL_CLIENT(dcc));
> -    if (display->surfaces[0].context.canvas) {
> +    if (display->priv->surfaces[0].context.canvas) {
>          display_channel_current_flush(display, 0);
>          red_channel_client_pipe_add_type(rcc,
>          RED_PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE);
>          dcc_create_surface(dcc, 0);
> @@ -693,7 +694,7 @@ static RedMonitorsConfigItem
> *red_monitors_config_item_new(RedChannel* channel,
>  void dcc_push_monitors_config(DisplayChannelClient *dcc)
>  {
>      DisplayChannel *dc = DCC_TO_DC(dcc);
> -    MonitorsConfig *monitors_config = dc->monitors_config;
> +    MonitorsConfig *monitors_config = dc->priv->monitors_config;
>      RedMonitorsConfigItem *mci;
>      RedChannel *channel;
>  
> @@ -709,7 +710,7 @@ void dcc_push_monitors_config(DisplayChannelClient *dcc)
>  
>      channel = red_channel_client_get_channel(RED_CHANNEL_CLIENT(dcc));
>      mci = red_monitors_config_item_new(channel,
> -
> monitors_config_ref(dc->monitors_config));
> +
> monitors_config_ref(dc->priv->monitors_config));
>      red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), &mci->pipe_item);
>      red_channel_client_push(RED_CHANNEL_CLIENT(dcc));
>  }
> @@ -777,7 +778,7 @@ void dcc_destroy_surface(DisplayChannelClient *dcc,
> uint32_t surface_id)
>      display = DCC_TO_DC(dcc);
>      channel = RED_CHANNEL(display);
>  
> -    if (COMMON_GRAPHICS_CHANNEL(display)->during_target_migrate ||
> +    if
> (common_graphics_channel_get_during_target_migrate(COMMON_GRAPHICS_CHANNEL(display))
> ||
>          !dcc->priv->surface_client_created[surface_id]) {
>          return;
>      }
> @@ -859,7 +860,7 @@ static int dcc_compress_image_glz(DisplayChannelClient
> *dcc,
>  {
>      DisplayChannel *display_channel = DCC_TO_DC(dcc);
>      stat_start_time_t start_time;
> -    stat_start_time_init(&start_time, &display_channel->zlib_glz_stat);
> +    stat_start_time_init(&start_time,
> &display_channel->priv->zlib_glz_stat);
>      spice_assert(bitmap_fmt_is_rgb(src->format));
>      GlzData *glz_data = &dcc->priv->glz_data;
>      ZlibData *zlib_data;
> @@ -890,12 +891,12 @@ static int dcc_compress_image_glz(DisplayChannelClient
> *dcc,
>                            glz_drawable_instance,
>                            &glz_drawable_instance->context);
>  
> -    stat_compress_add(&display_channel->glz_stat, start_time, src->stride *
> src->y, glz_size);
> +    stat_compress_add(&display_channel->priv->glz_stat, start_time,
> src->stride * src->y, glz_size);
>  
> -    if (!display_channel->enable_zlib_glz_wrap || (glz_size <
> MIN_GLZ_SIZE_FOR_ZLIB)) {
> +    if (!display_channel->priv->enable_zlib_glz_wrap || (glz_size <
> MIN_GLZ_SIZE_FOR_ZLIB)) {
>          goto glz;
>      }
> -    stat_start_time_init(&start_time, &display_channel->zlib_glz_stat);
> +    stat_start_time_init(&start_time,
> &display_channel->priv->zlib_glz_stat);
>      zlib_data = &dcc->priv->zlib_data;
>  
>      encoder_data_init(&zlib_data->data, dcc);
> @@ -922,7 +923,7 @@ static int dcc_compress_image_glz(DisplayChannelClient
> *dcc,
>      o_comp_data->comp_buf = zlib_data->data.bufs_head;
>      o_comp_data->comp_buf_size = zlib_size;
>  
> -    stat_compress_add(&display_channel->zlib_glz_stat, start_time, glz_size,
> zlib_size);
> +    stat_compress_add(&display_channel->priv->zlib_glz_stat, start_time,
> glz_size, zlib_size);
>      return TRUE;
>  glz:
>      dest->descriptor.type = SPICE_IMAGE_TYPE_GLZ_RGB;
> @@ -944,7 +945,7 @@ static int dcc_compress_image_lz(DisplayChannelClient
> *dcc,
>      int size;            // size of the compressed data
>  
>      stat_start_time_t start_time;
> -    stat_start_time_init(&start_time, &DCC_TO_DC(dcc)->lz_stat);
> +    stat_start_time_init(&start_time, &DCC_TO_DC(dcc)->priv->lz_stat);
>  
>  #ifdef COMPRESS_DEBUG
>      spice_info("LZ LOCAL compress");
> @@ -995,7 +996,7 @@ static int dcc_compress_image_lz(DisplayChannelClient
> *dcc,
>          o_comp_data->lzplt_palette = dest->u.lz_plt.palette;
>      }
>  
> -    stat_compress_add(&DCC_TO_DC(dcc)->lz_stat, start_time, src->stride *
> src->y,
> +    stat_compress_add(&DCC_TO_DC(dcc)->priv->lz_stat, start_time,
> src->stride * src->y,
>                        o_comp_data->comp_buf_size);
>      return TRUE;
>  }
> @@ -1016,7 +1017,7 @@ static int dcc_compress_image_jpeg(DisplayChannelClient
> *dcc, SpiceImage *dest,
>      int stride;
>      uint8_t *lz_out_start_byte;
>      stat_start_time_t start_time;
> -    stat_start_time_init(&start_time, &DCC_TO_DC(dcc)->jpeg_alpha_stat);
> +    stat_start_time_init(&start_time,
> &DCC_TO_DC(dcc)->priv->jpeg_alpha_stat);
>  
>  #ifdef COMPRESS_DEBUG
>      spice_info("JPEG compress");
> @@ -1080,7 +1081,7 @@ static int dcc_compress_image_jpeg(DisplayChannelClient
> *dcc, SpiceImage *dest,
>          o_comp_data->comp_buf_size = jpeg_size;
>          o_comp_data->is_lossy = TRUE;
>  
> -        stat_compress_add(&DCC_TO_DC(dcc)->jpeg_stat, start_time,
> src->stride * src->y,
> +        stat_compress_add(&DCC_TO_DC(dcc)->priv->jpeg_stat, start_time,
> src->stride * src->y,
>                            o_comp_data->comp_buf_size);
>          return TRUE;
>      }
> @@ -1122,7 +1123,7 @@ static int dcc_compress_image_jpeg(DisplayChannelClient
> *dcc, SpiceImage *dest,
>      o_comp_data->comp_buf = jpeg_data->data.bufs_head;
>      o_comp_data->comp_buf_size = jpeg_size + alpha_lz_size;
>      o_comp_data->is_lossy = TRUE;
> -    stat_compress_add(&DCC_TO_DC(dcc)->jpeg_alpha_stat, start_time,
> src->stride * src->y,
> +    stat_compress_add(&DCC_TO_DC(dcc)->priv->jpeg_alpha_stat, start_time,
> src->stride * src->y,
>                        o_comp_data->comp_buf_size);
>      return TRUE;
>  }
> @@ -1135,7 +1136,7 @@ static int dcc_compress_image_lz4(DisplayChannelClient
> *dcc, SpiceImage *dest,
>      Lz4EncoderContext *lz4 = dcc->priv->lz4;
>      int lz4_size = 0;
>      stat_start_time_t start_time;
> -    stat_start_time_init(&start_time, &DCC_TO_DC(dcc)->lz4_stat);
> +    stat_start_time_init(&start_time, &DCC_TO_DC(dcc)->priv->lz4_stat);
>  
>  #ifdef COMPRESS_DEBUG
>      spice_info("LZ4 compress");
> @@ -1172,7 +1173,7 @@ static int dcc_compress_image_lz4(DisplayChannelClient
> *dcc, SpiceImage *dest,
>      o_comp_data->comp_buf = lz4_data->data.bufs_head;
>      o_comp_data->comp_buf_size = lz4_size;
>  
> -    stat_compress_add(&DCC_TO_DC(dcc)->lz4_stat, start_time, src->stride *
> src->y,
> +    stat_compress_add(&DCC_TO_DC(dcc)->priv->lz4_stat, start_time,
> src->stride * src->y,
>                        o_comp_data->comp_buf_size);
>      return TRUE;
>  }
> @@ -1186,7 +1187,7 @@ static int dcc_compress_image_quic(DisplayChannelClient
> *dcc, SpiceImage *dest,
>      volatile QuicImageType type;
>      int size, stride;
>      stat_start_time_t start_time;
> -    stat_start_time_init(&start_time, &DCC_TO_DC(dcc)->quic_stat);
> +    stat_start_time_init(&start_time, &DCC_TO_DC(dcc)->priv->quic_stat);
>  
>  #ifdef COMPRESS_DEBUG
>      spice_info("QUIC compress");
> @@ -1246,7 +1247,7 @@ static int dcc_compress_image_quic(DisplayChannelClient
> *dcc, SpiceImage *dest,
>      o_comp_data->comp_buf = quic_data->data.bufs_head;
>      o_comp_data->comp_buf_size = size << 2;
>  
> -    stat_compress_add(&DCC_TO_DC(dcc)->quic_stat, start_time, src->stride *
> src->y,
> +    stat_compress_add(&DCC_TO_DC(dcc)->priv->quic_stat, start_time,
> src->stride * src->y,
>                        o_comp_data->comp_buf_size);
>      return TRUE;
>  }
> @@ -1345,14 +1346,14 @@ int dcc_compress_image(DisplayChannelClient *dcc,
>      stat_start_time_t start_time;
>      int success = FALSE;
>  
> -    stat_start_time_init(&start_time, &display_channel->off_stat);
> +    stat_start_time_init(&start_time, &display_channel->priv->off_stat);
>  
>      image_compression = get_compression_for_bitmap(src,
>      dcc->priv->image_compression, drawable);
>      switch (image_compression) {
>      case SPICE_IMAGE_COMPRESSION_OFF:
>          break;
>      case SPICE_IMAGE_COMPRESSION_QUIC:
> -        if (can_lossy && display_channel->enable_jpeg &&
> +        if (can_lossy && display_channel->priv->enable_jpeg &&
>              (src->format != SPICE_BITMAP_FMT_RGBA ||
>              !bitmap_has_extra_stride(src))) {
>              success = dcc_compress_image_jpeg(dcc, dest, src, o_comp_data);
>              break;
> @@ -1392,7 +1393,7 @@ lz_compress:
>  
>      if (!success) {
>          uint64_t image_size = src->stride * src->y;
> -        stat_compress_add(&display_channel->off_stat, start_time,
> image_size, image_size);
> +        stat_compress_add(&display_channel->priv->off_stat, start_time,
> image_size, image_size);
>      }
>  
>      return success;
> @@ -1739,15 +1740,15 @@ int dcc_handle_migrate_data(DisplayChannelClient
> *dcc, uint32_t size, void *mess
>      if (migrate_data->low_bandwidth_setting) {
>          red_channel_client_ack_set_client_window(RED_CHANNEL_CLIENT(dcc),
>          WIDE_CLIENT_ACK_WINDOW);
>          if (dcc->priv->jpeg_state == SPICE_WAN_COMPRESSION_AUTO) {
> -            display->enable_jpeg = TRUE;
> +            display->priv->enable_jpeg = TRUE;
>          }
>          if (dcc->priv->zlib_glz_state == SPICE_WAN_COMPRESSION_AUTO) {
> -            display->enable_zlib_glz_wrap = TRUE;
> +            display->priv->enable_zlib_glz_wrap = TRUE;
>          }
>      }
>  
>      surfaces = (uint8_t *)message + migrate_data->surfaces_at_client_ptr;
> -    surfaces_restored = display->enable_jpeg ?
> +    surfaces_restored = display->priv->enable_jpeg ?
>          restore_surfaces_lossy(dcc, (MigrateDisplaySurfacesAtClientLossy
>          *)surfaces) :
>          restore_surfaces_lossless(dcc,
>          (MigrateDisplaySurfacesAtClientLossless*)surfaces);
>  
> diff --git a/server/dcc.h b/server/dcc.h
> index 9567afd..ab51047 100644
> --- a/server/dcc.h
> +++ b/server/dcc.h
> @@ -21,7 +21,7 @@
>  #include <glib-object.h>
>  #include "image-cache.h"
>  #include "pixmap-cache.h"
> -#include "red-worker.h"
> +#include "common-graphics-channel-client.h"
>  #include "display-limits.h"
>  
>  G_BEGIN_DECLS
> @@ -69,7 +69,6 @@ GType display_channel_client_get_type(void) G_GNUC_CONST;
>  
>  #define MAX_PIPE_SIZE 50
>  
> -/* FIXME: remove */
>  typedef struct DisplayChannel DisplayChannel;
>  typedef struct Stream Stream;
>  typedef struct StreamAgent StreamAgent;
> @@ -87,7 +86,6 @@ typedef struct FreeList {
>      WaitForChannels wait;
>  } FreeList;
>  
> -#define DCC_TO_WORKER(dcc)
> ((RedWorker*)((CommonGraphicsChannel*)(red_channel_client_get_channel((RedChannelClient*)dcc)))->worker)
>  #define DCC_TO_DC(dcc)
>  ((DisplayChannel*)red_channel_client_get_channel((RedChannelClient*)dcc))
>  
>  typedef struct RedSurfaceCreateItem {
> diff --git a/server/display-channel-private.h
> b/server/display-channel-private.h
> new file mode 100644
> index 0000000..039a93d
> --- /dev/null
> +++ b/server/display-channel-private.h
> @@ -0,0 +1,81 @@
> +/*
> +   Copyright (C) 2009-2015 Red Hat, Inc.
> +
> +   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, see
> <http://www.gnu.org/licenses/>.
> +*/
> +
> +#ifndef DISPLAY_CHANNEL_PRIVATE_H_
> +#define DISPLAY_CHANNEL_PRIVATE_H_
> +
> +struct DisplayChannelPrivate
> +{
> +    DisplayChannel *pub;
> +
> +    uint32_t bits_unique;
> +
> +    MonitorsConfig *monitors_config;
> +
> +    uint32_t renderer;
> +    int enable_jpeg;
> +    int enable_zlib_glz_wrap;
> +
> +    Ring current_list; // of TreeItem
> +    uint32_t current_size;
> +
> +    uint32_t drawable_count;
> +    _Drawable *drawables;
> +    _Drawable *free_drawables;
> +
> +    int stream_video;
> +    uint32_t stream_count;
> +    Stream *streams_buf;
> +    Stream *free_streams;
> +    Ring streams;
> +    ItemTrace *items_trace;
> +    uint32_t next_item_trace;
> +    uint64_t streams_size_total;
> +
> +    RedSurface *surfaces;
> +    uint32_t n_surfaces;
> +    SpiceImageSurfaces image_surfaces;
> +
> +    ImageCache *image_cache;
> +    RedCompressBuf *free_compress_bufs;
> +
> +    int gl_draw_async_count;
> +
> +/* TODO: some day unify this, make it more runtime.. */
> +    stat_info_t add_stat;
> +    stat_info_t exclude_stat;
> +    stat_info_t __exclude_stat;
> +#ifdef RED_WORKER_STAT
> +    uint32_t add_count;
> +    uint32_t add_with_shadow_count;
> +#endif
> +#ifdef RED_STATISTICS
> +    uint64_t *cache_hits_counter;
> +    uint64_t *add_to_cache_counter;
> +    uint64_t *non_cache_counter;
> +#endif
> +    stat_info_t off_stat;
> +    stat_info_t lz_stat;
> +    stat_info_t glz_stat;
> +    stat_info_t quic_stat;
> +    stat_info_t jpeg_stat;
> +    stat_info_t zlib_glz_stat;
> +    stat_info_t jpeg_alpha_stat;
> +    stat_info_t lz4_stat;
> +};
> +
> +#endif /* DISPLAY_CHANNEL_PRIVATE_H_ */
> diff --git a/server/display-channel.c b/server/display-channel.c
> index 352058a..91b4255 100644
> --- a/server/display-channel.c
> +++ b/server/display-channel.c
> @@ -19,6 +19,138 @@
>  #endif
>  
>  #include "display-channel.h"
> +#include "display-channel-private.h"
> +
> +G_DEFINE_TYPE(DisplayChannel, display_channel, TYPE_COMMON_GRAPHICS_CHANNEL)
> +
> +#define DISPLAY_CHANNEL_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o),
> TYPE_DISPLAY_CHANNEL, DisplayChannelPrivate))
> +
> +enum {
> +    PROP0,
> +    PROP_N_SURFACES
> +};
> +
> +static void
> +display_channel_get_property(GObject *object,
> +                             guint property_id,
> +                             GValue *value,
> +                             GParamSpec *pspec)
> +{
> +    DisplayChannel *self = DISPLAY_CHANNEL(object);
> +
> +    switch (property_id)
> +    {
> +        case PROP_N_SURFACES:
> +            g_value_set_uint(value, self->priv->n_surfaces);
> +            break;
> +        default:
> +            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
> +    }
> +}
> +
> +static void
> +display_channel_set_property(GObject *object,
> +                             guint property_id,
> +                             const GValue *value,
> +                             GParamSpec *pspec)
> +{
> +    DisplayChannel *self = DISPLAY_CHANNEL(object);
> +
> +    switch (property_id)
> +    {
> +        case PROP_N_SURFACES:
> +            self->priv->n_surfaces = g_value_get_uint(value);
> +            if (self->priv->surfaces == NULL)
> +                self->priv->surfaces = g_new0(RedSurface,
> self->priv->n_surfaces);
> +            else
> +                self->priv->surfaces = g_renew(RedSurface,
> self->priv->surfaces, self->priv->n_surfaces);
> +            break;
> +        default:
> +            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
> +    }
> +}
> +
> +static void
> +display_channel_finalize(GObject *object)
> +{
> +    DisplayChannel *self = DISPLAY_CHANNEL(object);
> +
> +    G_OBJECT_CLASS(display_channel_parent_class)->finalize(object);
> +
> +    g_free(self->priv->drawables);
> +    g_free(self->priv->surfaces);
> +    g_free(self->priv->streams_buf);
> +    g_free(self->priv->items_trace);
> +    g_free(self->priv->image_cache);
> +}
> +
> +static void
> +display_channel_constructed(GObject *object)
> +{
> +    DisplayChannel *self = DISPLAY_CHANNEL(object);
> +
> +    G_OBJECT_CLASS(display_channel_parent_class)->constructed(object);
> +
> +    self->priv->renderer = RED_RENDERER_INVALID;
> +
> +    stat_init(&self->priv->add_stat, "add", CLOCK_THREAD_CPUTIME_ID);
> +    stat_init(&self->priv->exclude_stat, "exclude",
> CLOCK_THREAD_CPUTIME_ID);
> +    stat_init(&self->priv->__exclude_stat, "__exclude",
> CLOCK_THREAD_CPUTIME_ID);
> +#ifdef RED_STATISTICS
> +    QXLInstance *qxl = common_graphics_channel_get_qxl(&self->parent);
> +    RedsState *reds = red_qxl_get_server(qxl->st);
> +    RedChannel *channel = RED_CHANNEL(self);
> +    self->priv->cache_hits_counter =
> +        stat_add_counter(reds, red_channel_get_stat_node(channel),
> +                         "cache_hits", TRUE);
> +    self->priv->add_to_cache_counter =
> +        stat_add_counter(reds, red_channel_get_stat_node(channel),
> +                         "add_to_cache", TRUE);
> +    self->priv->non_cache_counter =
> +        stat_add_counter(reds, red_channel_get_stat_node(channel),
> +                         "non_cache", TRUE);
> +#endif
> +    image_cache_init(self->priv->image_cache);
> +    self->priv->stream_video = SPICE_STREAM_VIDEO_OFF;
> +    display_channel_init_streams(self);
> +}
> +
> +static SpiceCanvas *image_surfaces_get(SpiceImageSurfaces *surfaces,
> uint32_t surface_id)
> +{
> +    DisplayChannelPrivate *p = SPICE_CONTAINEROF(surfaces,
> DisplayChannelPrivate, image_surfaces);
> +    DisplayChannel *display = p->pub;
> +
> +    spice_return_val_if_fail(display_channel_validate_surface(display,
> surface_id), NULL);
> +
> +    return p->surfaces[surface_id].context.canvas;
> +}
> +
> +static void drawables_init(DisplayChannel *display);
> +static void
> +display_channel_init(DisplayChannel *self)
> +{
> +    static SpiceImageSurfacesOps image_surfaces_ops = {
> +        image_surfaces_get,
> +    };
> +
> +    self->priv = DISPLAY_CHANNEL_PRIVATE(self);
> +    self->priv->pub = self;
> +
> +    stat_compress_init(&self->priv->lz_stat, "lz", CLOCK_THREAD_CPUTIME_ID);
> +    stat_compress_init(&self->priv->glz_stat, "glz",
> CLOCK_THREAD_CPUTIME_ID);
> +    stat_compress_init(&self->priv->quic_stat, "quic",
> CLOCK_THREAD_CPUTIME_ID);
> +    stat_compress_init(&self->priv->jpeg_stat, "jpeg",
> CLOCK_THREAD_CPUTIME_ID);
> +    stat_compress_init(&self->priv->zlib_glz_stat, "zlib",
> CLOCK_THREAD_CPUTIME_ID);
> +    stat_compress_init(&self->priv->jpeg_alpha_stat, "jpeg_alpha",
> CLOCK_THREAD_CPUTIME_ID);
> +    stat_compress_init(&self->priv->lz4_stat, "lz4",
> CLOCK_THREAD_CPUTIME_ID);
> +
> +    ring_init(&self->priv->current_list);
> +    drawables_init(self);
> +    self->priv->image_surfaces.ops = &image_surfaces_ops;
> +    self->priv->streams_buf = g_new0(Stream, NUM_STREAMS);
> +    self->priv->items_trace = g_new0(ItemTrace, NUM_TRACE_ITEMS);
> +    self->priv->image_cache = g_new0(ImageCache, 1);
> +}
>  
>  static void drawable_draw(DisplayChannel *display, Drawable *drawable);
>  
> @@ -26,7 +158,7 @@ uint32_t display_channel_generate_uid(DisplayChannel
> *display)
>  {
>      spice_return_val_if_fail(display != NULL, 0);
>  
> -    return ++display->bits_unique;
> +    return ++display->priv->bits_unique;
>  }
>  
>  #define stat_start(stat, var)                                        \
> @@ -36,107 +168,111 @@ void
> display_channel_compress_stats_reset(DisplayChannel *display)
>  {
>      spice_return_if_fail(display);
>  
> -    stat_reset(&display->off_stat);
> -    stat_reset(&display->quic_stat);
> -    stat_reset(&display->lz_stat);
> -    stat_reset(&display->glz_stat);
> -    stat_reset(&display->jpeg_stat);
> -    stat_reset(&display->zlib_glz_stat);
> -    stat_reset(&display->jpeg_alpha_stat);
> -    stat_reset(&display->lz4_stat);
> +    stat_reset(&display->priv->off_stat);
> +    stat_reset(&display->priv->quic_stat);
> +    stat_reset(&display->priv->lz_stat);
> +    stat_reset(&display->priv->glz_stat);
> +    stat_reset(&display->priv->jpeg_stat);
> +    stat_reset(&display->priv->zlib_glz_stat);
> +    stat_reset(&display->priv->jpeg_alpha_stat);
> +    stat_reset(&display->priv->lz4_stat);
>  }
>  
> -void display_channel_compress_stats_print(const DisplayChannel
> *display_channel)
> +void display_channel_compress_stats_print(DisplayChannel *display_channel)
>  {
>      spice_return_if_fail(display_channel);
>  
>  #ifdef COMPRESS_STAT
> +    DisplayChannelPrivate *priv = display_channel->priv;
>      uint64_t glz_enc_size;
> +    uint32_t id;
> +
> +    glz_enc_size = priv->enable_zlib_glz_wrap ?
> +                       priv->zlib_glz_stat.comp_size :
> +                       priv->glz_stat.comp_size;
>  
> -    glz_enc_size = display_channel->enable_zlib_glz_wrap ?
> -                       display_channel->zlib_glz_stat.comp_size :
> -                       display_channel->glz_stat.comp_size;
> +    g_object_get(display_channel, "id", &id, NULL);
>  
> -    spice_info("==> Compression stats for display %u",
> display_channel->common.base.id);
> +    spice_info("==> Compression stats for display %u", id);
>      spice_info("Method   \t  count
>      \torig_size(MB)\tenc_size(MB)\tenc_time(s)");
>      spice_info("OFF     \t%8d\t%13.2f\t%12.2f\t%12.2f",
> -               display_channel->off_stat.count,
> -               stat_byte_to_mega(display_channel->off_stat.orig_size),
> -               stat_byte_to_mega(display_channel->off_stat.comp_size),
> -               stat_cpu_time_to_sec(display_channel->off_stat.total)
> +               priv->off_stat.count,
> +               stat_byte_to_mega(priv->off_stat.orig_size),
> +               stat_byte_to_mega(priv->off_stat.comp_size),
> +               stat_cpu_time_to_sec(priv->off_stat.total)
>                 );
>      spice_info("QUIC     \t%8d\t%13.2f\t%12.2f\t%12.2f",
> -               display_channel->quic_stat.count,
> -               stat_byte_to_mega(display_channel->quic_stat.orig_size),
> -               stat_byte_to_mega(display_channel->quic_stat.comp_size),
> -               stat_cpu_time_to_sec(display_channel->quic_stat.total)
> +               priv->quic_stat.count,
> +               stat_byte_to_mega(priv->quic_stat.orig_size),
> +               stat_byte_to_mega(priv->quic_stat.comp_size),
> +               stat_cpu_time_to_sec(priv->quic_stat.total)
>                 );
>      spice_info("GLZ      \t%8d\t%13.2f\t%12.2f\t%12.2f",
> -               display_channel->glz_stat.count,
> -               stat_byte_to_mega(display_channel->glz_stat.orig_size),
> -               stat_byte_to_mega(display_channel->glz_stat.comp_size),
> -               stat_cpu_time_to_sec(display_channel->glz_stat.total)
> +               priv->glz_stat.count,
> +               stat_byte_to_mega(priv->glz_stat.orig_size),
> +               stat_byte_to_mega(priv->glz_stat.comp_size),
> +               stat_cpu_time_to_sec(priv->glz_stat.total)
>                 );
>      spice_info("ZLIB GLZ \t%8d\t%13.2f\t%12.2f\t%12.2f",
> -               display_channel->zlib_glz_stat.count,
> -               stat_byte_to_mega(display_channel->zlib_glz_stat.orig_size),
> -               stat_byte_to_mega(display_channel->zlib_glz_stat.comp_size),
> -               stat_cpu_time_to_sec(display_channel->zlib_glz_stat.total)
> +               priv->zlib_glz_stat.count,
> +               stat_byte_to_mega(priv->zlib_glz_stat.orig_size),
> +               stat_byte_to_mega(priv->zlib_glz_stat.comp_size),
> +               stat_cpu_time_to_sec(priv->zlib_glz_stat.total)
>                 );
>      spice_info("LZ       \t%8d\t%13.2f\t%12.2f\t%12.2f",
> -               display_channel->lz_stat.count,
> -               stat_byte_to_mega(display_channel->lz_stat.orig_size),
> -               stat_byte_to_mega(display_channel->lz_stat.comp_size),
> -               stat_cpu_time_to_sec(display_channel->lz_stat.total)
> +               priv->lz_stat.count,
> +               stat_byte_to_mega(priv->lz_stat.orig_size),
> +               stat_byte_to_mega(priv->lz_stat.comp_size),
> +               stat_cpu_time_to_sec(priv->lz_stat.total)
>                 );
>      spice_info("JPEG     \t%8d\t%13.2f\t%12.2f\t%12.2f",
> -               display_channel->jpeg_stat.count,
> -               stat_byte_to_mega(display_channel->jpeg_stat.orig_size),
> -               stat_byte_to_mega(display_channel->jpeg_stat.comp_size),
> -               stat_cpu_time_to_sec(display_channel->jpeg_stat.total)
> +               priv->jpeg_stat.count,
> +               stat_byte_to_mega(priv->jpeg_stat.orig_size),
> +               stat_byte_to_mega(priv->jpeg_stat.comp_size),
> +               stat_cpu_time_to_sec(priv->jpeg_stat.total)
>                 );
>      spice_info("JPEG-RGBA\t%8d\t%13.2f\t%12.2f\t%12.2f",
> -               display_channel->jpeg_alpha_stat.count,
> -
> stat_byte_to_mega(display_channel->jpeg_alpha_stat.orig_size),
> -
> stat_byte_to_mega(display_channel->jpeg_alpha_stat.comp_size),
> -               stat_cpu_time_to_sec(display_channel->jpeg_alpha_stat.total)
> +               priv->jpeg_alpha_stat.count,
> +               stat_byte_to_mega(priv->jpeg_alpha_stat.orig_size),
> +               stat_byte_to_mega(priv->jpeg_alpha_stat.comp_size),
> +               stat_cpu_time_to_sec(priv->jpeg_alpha_stat.total)
>                 );
>      spice_info("LZ4      \t%8d\t%13.2f\t%12.2f\t%12.2f",
> -               display_channel->lz4_stat.count,
> -               stat_byte_to_mega(display_channel->lz4_stat.orig_size),
> -               stat_byte_to_mega(display_channel->lz4_stat.comp_size),
> -               stat_cpu_time_to_sec(display_channel->lz4_stat.total)
> +               priv->lz4_stat.count,
> +               stat_byte_to_mega(priv->lz4_stat.orig_size),
> +               stat_byte_to_mega(priv->lz4_stat.comp_size),
> +               stat_cpu_time_to_sec(priv->lz4_stat.total)
>                 );
>      spice_info("-------------------------------------------------------------------");
>      spice_info("Total    \t%8d\t%13.2f\t%12.2f\t%12.2f",
> -               display_channel->lz_stat.count +
> display_channel->glz_stat.count +
> -
> display_channel->off_stat.count
> +
> -
> display_channel->quic_stat.count
> +
> -
> display_channel->jpeg_stat.count
> +
> -
> display_channel->lz4_stat.count
> +
> -
> display_channel->jpeg_alpha_stat.count,
> -               stat_byte_to_mega(display_channel->lz_stat.orig_size +
> -                                 display_channel->glz_stat.orig_size +
> -                                 display_channel->off_stat.orig_size +
> -                                 display_channel->quic_stat.orig_size +
> -                                 display_channel->jpeg_stat.orig_size +
> -                                 display_channel->lz4_stat.orig_size +
> -
> display_channel->jpeg_alpha_stat.orig_size),
> -               stat_byte_to_mega(display_channel->lz_stat.comp_size +
> +               display_channel->priv->lz_stat.count +
> display_channel->priv->glz_stat.count +
> +                                                priv->off_stat.count +
> +                                                priv->quic_stat.count +
> +                                                priv->jpeg_stat.count +
> +                                                priv->lz4_stat.count +
> +                                                priv->jpeg_alpha_stat.count,
> +               stat_byte_to_mega(priv->lz_stat.orig_size +
> +                                 priv->glz_stat.orig_size +
> +                                 priv->off_stat.orig_size +
> +                                 priv->quic_stat.orig_size +
> +                                 priv->jpeg_stat.orig_size +
> +                                 priv->lz4_stat.orig_size +
> +                                 priv->jpeg_alpha_stat.orig_size),
> +               stat_byte_to_mega(priv->lz_stat.comp_size +
>                                   glz_enc_size +
> -                                 display_channel->off_stat.comp_size +
> -                                 display_channel->quic_stat.comp_size +
> -                                 display_channel->jpeg_stat.comp_size +
> -                                 display_channel->lz4_stat.comp_size +
> -
> display_channel->jpeg_alpha_stat.comp_size),
> -               stat_cpu_time_to_sec(display_channel->lz_stat.total +
> -                                    display_channel->glz_stat.total +
> -                                    display_channel->zlib_glz_stat.total +
> -                                    display_channel->off_stat.total +
> -                                    display_channel->quic_stat.total +
> -                                    display_channel->jpeg_stat.total +
> -                                    display_channel->lz4_stat.total +
> -                                    display_channel->jpeg_alpha_stat.total)
> +                                 priv->off_stat.comp_size +
> +                                 priv->quic_stat.comp_size +
> +                                 priv->jpeg_stat.comp_size +
> +                                 priv->lz4_stat.comp_size +
> +                                 priv->jpeg_alpha_stat.comp_size),
> +               stat_cpu_time_to_sec(priv->lz_stat.total +
> +                                    priv->glz_stat.total +
> +                                    priv->zlib_glz_stat.total +
> +                                    priv->off_stat.total +
> +                                    priv->quic_stat.total +
> +                                    priv->jpeg_stat.total +
> +                                    priv->lz4_stat.total +
> +                                    priv->jpeg_alpha_stat.total)
>                 );
>  #endif
>  }
> @@ -189,7 +325,7 @@ MonitorsConfig* monitors_config_new(QXLHead *heads,
> ssize_t nheads, ssize_t max)
>  int display_channel_get_streams_timeout(DisplayChannel *display)
>  {
>      int timeout = INT_MAX;
> -    Ring *ring = &display->streams;
> +    Ring *ring = &display->priv->streams;
>      RingItem *item = ring;
>  
>      red_time_t now = spice_get_monotonic_time_ns();
> @@ -227,12 +363,18 @@ void display_channel_set_stream_video(DisplayChannel
> *display, int stream_video)
>          return;
>      }
>  
> -    display->stream_video = stream_video;
> +    display->priv->stream_video = stream_video;
> +}
> +
> +int display_channel_get_stream_video(DisplayChannel *display)
> +{
> +    return display->priv->stream_video;
>  }
>  
> +
>  static void stop_streams(DisplayChannel *display)
>  {
> -    Ring *ring = &display->streams;
> +    Ring *ring = &display->priv->streams;
>      RingItem *item = ring_get_head(ring);
>  
>      while (item) {
> @@ -245,14 +387,14 @@ static void stop_streams(DisplayChannel *display)
>          }
>      }
>  
> -    display->next_item_trace = 0;
> -    memset(display->items_trace, 0, sizeof(display->items_trace));
> +    display->priv->next_item_trace = 0;
> +    memset(display->priv->items_trace, 0, NUM_TRACE_ITEMS *
> sizeof(*display->priv->items_trace));
>  }
>  
>  void display_channel_surface_unref(DisplayChannel *display, uint32_t
>  surface_id)
>  {
> -    RedSurface *surface = &display->surfaces[surface_id];
> -    QXLInstance *qxl = display->common.qxl;
> +    RedSurface *surface = &display->priv->surfaces[surface_id];
> +    QXLInstance *qxl = common_graphics_channel_get_qxl(&display->parent);
>      DisplayChannelClient *dcc;
>      GList *link, *next;
>  
> @@ -283,6 +425,13 @@ void display_channel_surface_unref(DisplayChannel
> *display, uint32_t surface_id)
>      spice_warn_if_fail(ring_is_empty(&surface->depend_on_me));
>  }
>  
> +/* TODO: perhaps rename to "ready" or "realized" ? */
> +bool display_channel_surface_has_canvas(DisplayChannel *display,
> +                                        uint32_t surface_id)
> +{
> +    return display->priv->surfaces[surface_id].context.canvas != NULL;
> +}
> +
>  static void streams_update_visible_region(DisplayChannel *display, Drawable
>  *drawable)
>  {
>      Ring *ring;
> @@ -298,7 +447,7 @@ static void streams_update_visible_region(DisplayChannel
> *display, Drawable *dra
>          return;
>      }
>  
> -    ring = &display->streams;
> +    ring = &display->priv->streams;
>      item = ring_get_head(ring);
>  
>      while (item) {
> @@ -312,7 +461,7 @@ static void streams_update_visible_region(DisplayChannel
> *display, Drawable *dra
>          }
>  
>          FOREACH_DCC(display, link, next, dcc) {
> -            agent = dcc_get_stream_agent(dcc, get_stream_id(display,
> stream));
> +            agent = dcc_get_stream_agent(dcc,
> display_channel_get_stream_id(display, stream));
>  
>              if (region_intersects(&agent->vis_region,
>              &drawable->tree_item.base.rgn)) {
>                  region_exclude(&agent->vis_region,
>                  &drawable->tree_item.base.rgn);
> @@ -350,7 +499,7 @@ static void pipes_add_drawable_after(DisplayChannel
> *display,
>          pipes_add_drawable(display, drawable);
>          return;
>      }
> -    if (num_other_linked != display->common.base.clients_num) {
> +    if (num_other_linked != red_channel_get_n_clients(RED_CHANNEL(display)))
> {
>          GList *link, *next;
>          spice_debug("TODO: not O(n^2)");
>          FOREACH_DCC(display, link, next, dcc) {
> @@ -374,11 +523,11 @@ static void current_add_drawable(DisplayChannel
> *display,
>      RedSurface *surface;
>      uint32_t surface_id = drawable->surface_id;
>  
> -    surface = &display->surfaces[surface_id];
> +    surface = &display->priv->surfaces[surface_id];
>      ring_add_after(&drawable->tree_item.base.siblings_link, pos);
> -    ring_add(&display->current_list, &drawable->list_link);
> +    ring_add(&display->priv->current_list, &drawable->list_link);
>      ring_add(&surface->current_list, &drawable->surface_list_link);
> -    display->current_size++;
> +    display->priv->current_size++;
>      drawable->refs++;
>  }
>  
> @@ -391,7 +540,7 @@ static void current_remove_drawable(DisplayChannel
> *display, Drawable *item)
>      ring_remove(&item->list_link);
>      ring_remove(&item->surface_list_link);
>      drawable_unref(item);
> -    display->current_size--;
> +    display->priv->current_size--;
>  }
>  
>  static void drawable_remove_from_pipes(Drawable *drawable)
> @@ -448,7 +597,7 @@ static void current_remove(DisplayChannel *display,
> TreeItem *item)
>  
>  static void current_remove_all(DisplayChannel *display, int surface_id)
>  {
> -    Ring *ring = &display->surfaces[surface_id].current;
> +    Ring *ring = &display->priv->surfaces[surface_id].current;
>      RingItem *ring_item;
>  
>      while ((ring_item = ring_get_head(ring))) {
> @@ -506,7 +655,7 @@ static int current_add_equal(DisplayChannel *display,
> DrawItem *item, TreeItem *
>  
>              /* sending the drawable to clients that already received
>               * (or will receive) other_drawable */
> -            link = RED_CHANNEL(display)->clients;
> +            link = red_channel_get_clients(RED_CHANNEL(display));
>              dpi_ring_item = ring_get_head(&other_drawable->pipes);
>              /* dpi contains a sublist of dcc's, ordered the same */
>              while (link) {
> @@ -555,7 +704,7 @@ static void __exclude_region(DisplayChannel *display,
> Ring *ring, TreeItem *item
>                               Ring **top_ring, Drawable *frame_candidate)
>  {
>      QRegion and_rgn;
> -    stat_start(&display->__exclude_stat, start_time);
> +    stat_start(&display->priv->__exclude_stat, start_time);
>  
>      region_clone(&and_rgn, rgn);
>      region_and(&and_rgn, &item->rgn);
> @@ -617,14 +766,14 @@ static void __exclude_region(DisplayChannel *display,
> Ring *ring, TreeItem *item
>          }
>      }
>      region_destroy(&and_rgn);
> -    stat_add(&display->__exclude_stat, start_time);
> +    stat_add(&display->priv->__exclude_stat, start_time);
>  }
>  
>  static void exclude_region(DisplayChannel *display, Ring *ring, RingItem
>  *ring_item,
>                             QRegion *rgn, TreeItem **last, Drawable
>                             *frame_candidate)
>  {
>      Ring *top_ring;
> -    stat_start(&display->exclude_stat, start_time);
> +    stat_start(&display->priv->exclude_stat, start_time);
>  
>      if (!ring_item) {
>          return;
> @@ -659,7 +808,7 @@ static void exclude_region(DisplayChannel *display, Ring
> *ring, RingItem *ring_i
>              }
>  
>              if (region_is_empty(rgn)) {
> -                stat_add(&display->exclude_stat, start_time);
> +                stat_add(&display->priv->exclude_stat, start_time);
>                  return;
>              }
>          }
> @@ -667,7 +816,7 @@ static void exclude_region(DisplayChannel *display, Ring
> *ring, RingItem *ring_i
>          while ((last && *last == (TreeItem *)ring_item) ||
>                 !(ring_item = ring_next(ring, ring_item))) {
>              if (ring == top_ring) {
> -                stat_add(&display->exclude_stat, start_time);
> +                stat_add(&display->priv->exclude_stat, start_time);
>                  return;
>              }
>              ring_item = &container->base.siblings_link;
> @@ -679,9 +828,9 @@ static void exclude_region(DisplayChannel *display, Ring
> *ring, RingItem *ring_i
>  
>  static int current_add_with_shadow(DisplayChannel *display, Ring *ring,
>  Drawable *item)
>  {
> -    stat_start(&display->add_stat, start_time);
> +    stat_start(&display->priv->add_stat, start_time);
>  #ifdef RED_WORKER_STAT
> -    ++display->add_with_shadow_count;
> +    ++display->priv->add_with_shadow_count;
>  #endif
>  
>      RedDrawable *red_drawable = item->red_drawable;
> @@ -692,7 +841,7 @@ static int current_add_with_shadow(DisplayChannel
> *display, Ring *ring, Drawable
>  
>      Shadow *shadow = shadow_new(&item->tree_item, &delta);
>      if (!shadow) {
> -        stat_add(&display->add_stat, start_time);
> +        stat_add(&display->priv->add_stat, start_time);
>          return FALSE;
>      }
>      // item and his shadow must initially be placed in the same container.
> @@ -716,7 +865,7 @@ static int current_add_with_shadow(DisplayChannel
> *display, Ring *ring, Drawable
>              stream_detach_behind(display, &item->tree_item.base.rgn, item);
>          }
>      }
> -    stat_add(&display->add_stat, start_time);
> +    stat_add(&display->priv->add_stat, start_time);
>      return TRUE;
>  }
>  
> @@ -726,7 +875,7 @@ static int current_add(DisplayChannel *display, Ring
> *ring, Drawable *drawable)
>      RingItem *now;
>      QRegion exclude_rgn;
>      RingItem *exclude_base = NULL;
> -    stat_start(&display->add_stat, start_time);
> +    stat_start(&display->priv->add_stat, start_time);
>  
>      spice_assert(!region_is_empty(&item->base.rgn));
>      region_init(&exclude_rgn);
> @@ -748,7 +897,7 @@ static int current_add(DisplayChannel *display, Ring
> *ring, Drawable *drawable)
>              if (!(test_res & REGION_TEST_RIGHT_EXCLUSIVE) &&
>                                                     !(test_res &
>                                                     REGION_TEST_LEFT_EXCLUSIVE)
>                                                     &&
>                                                     current_add_equal(display,
>                                                     item, sibling)) {
> -                stat_add(&display->add_stat, start_time);
> +                stat_add(&display->priv->add_stat, start_time);
>                  return FALSE;
>              }
>  
> @@ -834,7 +983,7 @@ static int current_add(DisplayChannel *display, Ring
> *ring, Drawable *drawable)
>          }
>      }
>      region_destroy(&exclude_rgn);
> -    stat_add(&display->add_stat, start_time);
> +    stat_add(&display->priv->add_stat, start_time);
>      return TRUE;
>  }
>  
> @@ -843,7 +992,7 @@ static bool drawable_can_stream(DisplayChannel *display,
> Drawable *drawable)
>      RedDrawable *red_drawable = drawable->red_drawable;
>      SpiceImage *image;
>  
> -    if (display->stream_video == SPICE_STREAM_VIDEO_OFF) {
> +    if (display->priv->stream_video == SPICE_STREAM_VIDEO_OFF) {
>          return FALSE;
>      }
>  
> @@ -863,7 +1012,7 @@ static bool drawable_can_stream(DisplayChannel *display,
> Drawable *drawable)
>          return FALSE;
>      }
>  
> -    if (display->stream_video == SPICE_STREAM_VIDEO_FILTER) {
> +    if (display->priv->stream_video == SPICE_STREAM_VIDEO_FILTER) {
>          SpiceRect* rect;
>          int size;
>  
> @@ -880,26 +1029,26 @@ static bool drawable_can_stream(DisplayChannel
> *display, Drawable *drawable)
>  void display_channel_print_stats(DisplayChannel *display)
>  {
>  #ifdef RED_WORKER_STAT
> -    stat_time_t total = display->add_stat.total;
> +    stat_time_t total = display->priv->add_stat.total;
>      spice_info("add with shadow count %u",
> -               display->add_with_shadow_count);
> -    display->add_with_shadow_count = 0;
> +               display->priv->add_with_shadow_count);
> +    display->priv->add_with_shadow_count = 0;
>      spice_info("add[%u] %f exclude[%u] %f __exclude[%u] %f",
> -               display->add_stat.count,
> +               display->priv->add_stat.count,
>                 stat_cpu_time_to_sec(total),
> -               display->exclude_stat.count,
> -               stat_cpu_time_to_sec(display->exclude_stat.total),
> -               display->__exclude_stat.count,
> -               stat_cpu_time_to_sec(display->__exclude_stat.total));
> +               display->priv->exclude_stat.count,
> +               stat_cpu_time_to_sec(display->priv->exclude_stat.total),
> +               display->priv->__exclude_stat.count,
> +               stat_cpu_time_to_sec(display->priv->__exclude_stat.total));
>      spice_info("add %f%% exclude %f%% exclude2 %f%% __exclude %f%%",
> -               (double)(total - display->exclude_stat.total) / total * 100,
> -               (double)(display->exclude_stat.total) / total * 100,
> -               (double)(display->exclude_stat.total -
> -                        display->__exclude_stat.total) /
> display->exclude_stat.total * 100,
> -               (double)(display->__exclude_stat.total) /
> display->exclude_stat.total * 100);
> -    stat_reset(&display->add_stat);
> -    stat_reset(&display->exclude_stat);
> -    stat_reset(&display->__exclude_stat);
> +               (double)(total - display->priv->exclude_stat.total) / total *
> 100,
> +               (double)(display->priv->exclude_stat.total) / total * 100,
> +               (double)(display->priv->exclude_stat.total -
> +                        display->priv->__exclude_stat.total) /
> display->priv->exclude_stat.total * 100,
> +               (double)(display->priv->__exclude_stat.total) /
> display->priv->exclude_stat.total * 100);
> +    stat_reset(&display->priv->add_stat);
> +    stat_reset(&display->priv->exclude_stat);
> +    stat_reset(&display->priv->__exclude_stat);
>  #endif
>  }
>  
> @@ -914,7 +1063,7 @@ static void drawable_ref_surface_deps(DisplayChannel
> *display, Drawable *drawabl
>          if (surface_id == -1) {
>              continue;
>          }
> -        surface = &display->surfaces[surface_id];
> +        surface = &display->priv->surfaces[surface_id];
>          surface->refs++;
>      }
>  }
> @@ -923,7 +1072,7 @@ static void surface_read_bits(DisplayChannel *display,
> int surface_id,
>                                const SpiceRect *area, uint8_t *dest, int
>                                dest_stride)
>  {
>      SpiceCanvas *canvas;
> -    RedSurface *surface = &display->surfaces[surface_id];
> +    RedSurface *surface = &display->priv->surfaces[surface_id];
>  
>      canvas = surface->context.canvas;
>      canvas->ops->read_bits(canvas, dest, dest_stride, area);
> @@ -941,7 +1090,7 @@ static void handle_self_bitmap(DisplayChannel *display,
> Drawable *drawable)
>      int bpp;
>      int all_set;
>  
> -    surface = &display->surfaces[drawable->surface_id];
> +    surface = &display->priv->surfaces[drawable->surface_id];
>  
>      bpp = SPICE_SURFACE_FMT_DEPTH(surface->context.format) / 8;
>      width = red_drawable->self_bitmap_area.right -
>      red_drawable->self_bitmap_area.left;
> @@ -993,7 +1142,7 @@ static void
> surface_add_reverse_dependency(DisplayChannel *display, int surface_
>          return;
>      }
>  
> -    surface = &display->surfaces[surface_id];
> +    surface = &display->priv->surfaces[surface_id];
>  
>      depend_item->drawable = drawable;
>      ring_add(&surface->depend_on_me, &depend_item->ring_item);
> @@ -1027,7 +1176,7 @@ static void draw_depend_on_me(DisplayChannel *display,
> uint32_t surface_id)
>      RedSurface *surface;
>      RingItem *ring_item;
>  
> -    surface = &display->surfaces[surface_id];
> +    surface = &display->priv->surfaces[surface_id];
>  
>      while ((ring_item = ring_get_tail(&surface->depend_on_me))) {
>          Drawable *drawable;
> @@ -1045,10 +1194,10 @@ static int validate_drawable_bbox(DisplayChannel
> *display, RedDrawable *drawable
>          /* surface_id must be validated before calling into
>           * validate_drawable_bbox
>           */
> -        if (!validate_surface(display, drawable->surface_id)) {
> +        if (!display_channel_validate_surface(display,
> drawable->surface_id)) {
>              return FALSE;
>          }
> -        context = &display->surfaces[surface_id].context;
> +        context = &display->priv->surfaces[surface_id].context;
>  
>          if (drawable->bbox.top < 0)
>                  return FALSE;
> @@ -1088,7 +1237,7 @@ static Drawable
> *display_channel_get_drawable(DisplayChannel *display, uint8_t e
>      }
>      for (x = 0; x < 3; ++x) {
>          if (red_drawable->surface_deps[x] != -1
> -            && !validate_surface(display, red_drawable->surface_deps[x])) {
> +            && !display_channel_validate_surface(display,
> red_drawable->surface_deps[x])) {
>              return NULL;
>          }
>      }
> @@ -1102,7 +1251,7 @@ static Drawable
> *display_channel_get_drawable(DisplayChannel *display, uint8_t e
>      drawable->red_drawable = red_drawable_ref(red_drawable);
>  
>      drawable->surface_id = red_drawable->surface_id;
> -    display->surfaces[drawable->surface_id].refs++;
> +    display->priv->surfaces[drawable->surface_id].refs++;
>  
>      memcpy(drawable->surface_deps, red_drawable->surface_deps,
>      sizeof(drawable->surface_deps));
>      /*
> @@ -1152,7 +1301,7 @@ static void display_channel_add_drawable(DisplayChannel
> *display, Drawable *draw
>          return;
>      }
>  
> -    Ring *ring = &display->surfaces[surface_id].current;
> +    Ring *ring = &display->priv->surfaces[surface_id].current;
>      int add_to_pipe;
>      if (has_shadow(red_drawable)) {
>          add_to_pipe = current_add_with_shadow(display, ring, drawable);
> @@ -1165,7 +1314,7 @@ static void display_channel_add_drawable(DisplayChannel
> *display, Drawable *draw
>          pipes_add_drawable(display, drawable);
>  
>  #ifdef RED_WORKER_STAT
> -    if ((++display->add_count % 100) == 0)
> +    if ((++display->priv->add_count % 100) == 0)
>          display_channel_print_stats(display);
>  #endif
>  }
> @@ -1189,18 +1338,18 @@ void display_channel_process_draw(DisplayChannel
> *display, RedDrawable *red_draw
>  int display_channel_wait_for_migrate_data(DisplayChannel *display)
>  {
>      uint64_t end_time = spice_get_monotonic_time_ns() +
>      DISPLAY_CLIENT_MIGRATE_DATA_TIMEOUT;
> -    RedChannel *channel = &display->common.base;
>      RedChannelClient *rcc;
>      int ret = FALSE;
> +    GList *clients = red_channel_get_clients(RED_CHANNEL(display));;
>  
> -    if (!red_channel_is_waiting_for_migrate_data(&display->common.base)) {
> +    if (!red_channel_is_waiting_for_migrate_data(RED_CHANNEL(display))) {
>          return FALSE;
>      }
>  
>      spice_debug(NULL);
> -    spice_warn_if_fail(g_list_length(channel->clients) == 1);
> +    spice_warn_if_fail(g_list_length(clients) == 1);
>  
> -    rcc = channel->clients->data;
> +    rcc = clients->data;
>  
>      g_object_ref(rcc);
>      for (;;) {
> @@ -1228,8 +1377,8 @@ void display_channel_flush_all_surfaces(DisplayChannel
> *display)
>  {
>      int x;
>  
> -    for (x = 0; x < NUM_SURFACES; ++x) {
> -        if (display->surfaces[x].context.canvas) {
> +    for (x = 0; x < display->priv->n_surfaces; ++x) {
> +        if (display->priv->surfaces[x].context.canvas) {
>              display_channel_current_flush(display, x);
>          }
>      }
> @@ -1261,7 +1410,7 @@ void display_channel_free_glz_drawables(DisplayChannel
> *display)
>  
>  static bool free_one_drawable(DisplayChannel *display, int force_glz_free)
>  {
> -    RingItem *ring_item = ring_get_tail(&display->current_list);
> +    RingItem *ring_item = ring_get_tail(&display->priv->current_list);
>      Drawable *drawable;
>      Container *container;
>  
> @@ -1287,7 +1436,7 @@ static bool free_one_drawable(DisplayChannel *display,
> int force_glz_free)
>  
>  void display_channel_current_flush(DisplayChannel *display, int surface_id)
>  {
> -    while (!ring_is_empty(&display->surfaces[surface_id].current_list)) {
> +    while
> (!ring_is_empty(&display->priv->surfaces[surface_id].current_list)) {
>          free_one_drawable(display, FALSE);
>      }
>      current_remove_all(display, surface_id);
> @@ -1299,7 +1448,7 @@ void display_channel_free_some(DisplayChannel *display)
>      DisplayChannelClient *dcc;
>      GList *link, *next;
>  
> -    spice_debug("#draw=%d, #glz_draw=%d", display->drawable_count,
> +    spice_debug("#draw=%d, #glz_draw=%d", display->priv->drawable_count,
>                  display->glz_drawable_count);
>      FOREACH_DCC(display, link, next, dcc) {
>          GlzSharedDictionary *glz_dict = dcc_get_glz_dictionary(dcc);
> @@ -1312,7 +1461,7 @@ void display_channel_free_some(DisplayChannel *display)
>          }
>      }
>  
> -    while (!ring_is_empty(&display->current_list) && n++ <
> RED_RELEASE_BUNCH_SIZE) {
> +    while (!ring_is_empty(&display->priv->current_list) && n++ <
> RED_RELEASE_BUNCH_SIZE) {
>          free_one_drawable(display, TRUE);
>      }
>  
> @@ -1329,29 +1478,30 @@ static Drawable* drawable_try_new(DisplayChannel
> *display)
>  {
>      Drawable *drawable;
>  
> -    if (!display->free_drawables)
> +    if (!display->priv->free_drawables)
>          return NULL;
>  
> -    drawable = &display->free_drawables->u.drawable;
> -    display->free_drawables = display->free_drawables->u.next;
> -    display->drawable_count++;
> +    drawable = &display->priv->free_drawables->u.drawable;
> +    display->priv->free_drawables = display->priv->free_drawables->u.next;
> +    display->priv->drawable_count++;
>  
>      return drawable;
>  }
>  
>  static void drawable_free(DisplayChannel *display, Drawable *drawable)
>  {
> -    ((_Drawable *)drawable)->u.next = display->free_drawables;
> -    display->free_drawables = (_Drawable *)drawable;
> +    ((_Drawable *)drawable)->u.next = display->priv->free_drawables;
> +    display->priv->free_drawables = (_Drawable *)drawable;
>  }
>  
>  static void drawables_init(DisplayChannel *display)
>  {
>      int i;
>  
> -    display->free_drawables = NULL;
> +    display->priv->drawables = g_new0(_Drawable, NUM_DRAWABLES);
> +    display->priv->free_drawables = NULL;
>      for (i = 0; i < NUM_DRAWABLES; i++) {
> -        drawable_free(display, &display->drawables[i].u.drawable);
> +        drawable_free(display, &display->priv->drawables[i].u.drawable);
>      }
>  }
>  
> @@ -1449,11 +1599,12 @@ void drawable_unref(Drawable *drawable)
>          SPICE_CONTAINEROF(item, RedGlzDrawable, drawable_link)->drawable =
>          NULL;
>          ring_remove(item);
>      }
> +
>      if (drawable->red_drawable) {
>          red_drawable_unref(drawable->red_drawable);
>      }
>      drawable_free(display, drawable);
> -    display->drawable_count--;
> +    display->priv->drawable_count--;
>  }
>  
>  static void drawable_deps_draw(DisplayChannel *display, Drawable *drawable)
> @@ -1478,11 +1629,11 @@ static void drawable_draw(DisplayChannel *display,
> Drawable *drawable)
>  
>      drawable_deps_draw(display, drawable);
>  
> -    surface = &display->surfaces[drawable->surface_id];
> +    surface = &display->priv->surfaces[drawable->surface_id];
>      canvas = surface->context.canvas;
>      spice_return_if_fail(canvas);
>  
> -    image_cache_aging(&display->image_cache);
> +    image_cache_aging(display->priv->image_cache);
>  
>      region_add(&surface->draw_dirty_region, &drawable->red_drawable->bbox);
>  
> @@ -1490,8 +1641,8 @@ static void drawable_draw(DisplayChannel *display,
> Drawable *drawable)
>      case QXL_DRAW_FILL: {
>          SpiceFill fill = drawable->red_drawable->u.fill;
>          SpiceImage img1, img2;
> -        image_cache_localize_brush(&display->image_cache, &fill.brush,
> &img1);
> -        image_cache_localize_mask(&display->image_cache, &fill.mask, &img2);
> +        image_cache_localize_brush(display->priv->image_cache, &fill.brush,
> &img1);
> +        image_cache_localize_mask(display->priv->image_cache, &fill.mask,
> &img2);
>          canvas->ops->draw_fill(canvas, &drawable->red_drawable->bbox,
>                                 &clip, &fill);
>          break;
> @@ -1499,17 +1650,17 @@ static void drawable_draw(DisplayChannel *display,
> Drawable *drawable)
>      case QXL_DRAW_OPAQUE: {
>          SpiceOpaque opaque = drawable->red_drawable->u.opaque;
>          SpiceImage img1, img2, img3;
> -        image_cache_localize_brush(&display->image_cache, &opaque.brush,
> &img1);
> -        image_cache_localize(&display->image_cache, &opaque.src_bitmap,
> &img2, drawable);
> -        image_cache_localize_mask(&display->image_cache, &opaque.mask,
> &img3);
> +        image_cache_localize_brush(display->priv->image_cache,
> &opaque.brush, &img1);
> +        image_cache_localize(display->priv->image_cache, &opaque.src_bitmap,
> &img2, drawable);
> +        image_cache_localize_mask(display->priv->image_cache, &opaque.mask,
> &img3);
>          canvas->ops->draw_opaque(canvas, &drawable->red_drawable->bbox,
>          &clip, &opaque);
>          break;
>      }
>      case QXL_DRAW_COPY: {
>          SpiceCopy copy = drawable->red_drawable->u.copy;
>          SpiceImage img1, img2;
> -        image_cache_localize(&display->image_cache, &copy.src_bitmap, &img1,
> drawable);
> -        image_cache_localize_mask(&display->image_cache, &copy.mask, &img2);
> +        image_cache_localize(display->priv->image_cache, &copy.src_bitmap,
> &img1, drawable);
> +        image_cache_localize_mask(display->priv->image_cache, &copy.mask,
> &img2);
>          canvas->ops->draw_copy(canvas, &drawable->red_drawable->bbox,
>                                 &clip, &copy);
>          break;
> @@ -1517,7 +1668,7 @@ static void drawable_draw(DisplayChannel *display,
> Drawable *drawable)
>      case QXL_DRAW_TRANSPARENT: {
>          SpiceTransparent transparent =
>          drawable->red_drawable->u.transparent;
>          SpiceImage img1;
> -        image_cache_localize(&display->image_cache, &transparent.src_bitmap,
> &img1, drawable);
> +        image_cache_localize(display->priv->image_cache,
> &transparent.src_bitmap, &img1, drawable);
>          canvas->ops->draw_transparent(canvas,
>                                        &drawable->red_drawable->bbox, &clip,
>                                        &transparent);
>          break;
> @@ -1525,7 +1676,7 @@ static void drawable_draw(DisplayChannel *display,
> Drawable *drawable)
>      case QXL_DRAW_ALPHA_BLEND: {
>          SpiceAlphaBlend alpha_blend = drawable->red_drawable->u.alpha_blend;
>          SpiceImage img1;
> -        image_cache_localize(&display->image_cache, &alpha_blend.src_bitmap,
> &img1, drawable);
> +        image_cache_localize(display->priv->image_cache,
> &alpha_blend.src_bitmap, &img1, drawable);
>          canvas->ops->draw_alpha_blend(canvas,
>                                        &drawable->red_drawable->bbox, &clip,
>                                        &alpha_blend);
>          break;
> @@ -1538,8 +1689,8 @@ static void drawable_draw(DisplayChannel *display,
> Drawable *drawable)
>      case QXL_DRAW_BLEND: {
>          SpiceBlend blend = drawable->red_drawable->u.blend;
>          SpiceImage img1, img2;
> -        image_cache_localize(&display->image_cache, &blend.src_bitmap,
> &img1, drawable);
> -        image_cache_localize_mask(&display->image_cache, &blend.mask,
> &img2);
> +        image_cache_localize(display->priv->image_cache, &blend.src_bitmap,
> &img1, drawable);
> +        image_cache_localize_mask(display->priv->image_cache, &blend.mask,
> &img2);
>          canvas->ops->draw_blend(canvas, &drawable->red_drawable->bbox,
>                                  &clip, &blend);
>          break;
> @@ -1547,7 +1698,7 @@ static void drawable_draw(DisplayChannel *display,
> Drawable *drawable)
>      case QXL_DRAW_BLACKNESS: {
>          SpiceBlackness blackness = drawable->red_drawable->u.blackness;
>          SpiceImage img1;
> -        image_cache_localize_mask(&display->image_cache, &blackness.mask,
> &img1);
> +        image_cache_localize_mask(display->priv->image_cache,
> &blackness.mask, &img1);
>          canvas->ops->draw_blackness(canvas,
>                                      &drawable->red_drawable->bbox, &clip,
>                                      &blackness);
>          break;
> @@ -1555,7 +1706,7 @@ static void drawable_draw(DisplayChannel *display,
> Drawable *drawable)
>      case QXL_DRAW_WHITENESS: {
>          SpiceWhiteness whiteness = drawable->red_drawable->u.whiteness;
>          SpiceImage img1;
> -        image_cache_localize_mask(&display->image_cache, &whiteness.mask,
> &img1);
> +        image_cache_localize_mask(display->priv->image_cache,
> &whiteness.mask, &img1);
>          canvas->ops->draw_whiteness(canvas,
>                                      &drawable->red_drawable->bbox, &clip,
>                                      &whiteness);
>          break;
> @@ -1563,7 +1714,7 @@ static void drawable_draw(DisplayChannel *display,
> Drawable *drawable)
>      case QXL_DRAW_INVERS: {
>          SpiceInvers invers = drawable->red_drawable->u.invers;
>          SpiceImage img1;
> -        image_cache_localize_mask(&display->image_cache, &invers.mask,
> &img1);
> +        image_cache_localize_mask(display->priv->image_cache, &invers.mask,
> &img1);
>          canvas->ops->draw_invers(canvas,
>                                   &drawable->red_drawable->bbox, &clip,
>                                   &invers);
>          break;
> @@ -1571,9 +1722,9 @@ static void drawable_draw(DisplayChannel *display,
> Drawable *drawable)
>      case QXL_DRAW_ROP3: {
>          SpiceRop3 rop3 = drawable->red_drawable->u.rop3;
>          SpiceImage img1, img2, img3;
> -        image_cache_localize_brush(&display->image_cache, &rop3.brush,
> &img1);
> -        image_cache_localize(&display->image_cache, &rop3.src_bitmap, &img2,
> drawable);
> -        image_cache_localize_mask(&display->image_cache, &rop3.mask, &img3);
> +        image_cache_localize_brush(display->priv->image_cache, &rop3.brush,
> &img1);
> +        image_cache_localize(display->priv->image_cache, &rop3.src_bitmap,
> &img2, drawable);
> +        image_cache_localize_mask(display->priv->image_cache, &rop3.mask,
> &img3);
>          canvas->ops->draw_rop3(canvas, &drawable->red_drawable->bbox,
>                                 &clip, &rop3);
>          break;
> @@ -1581,9 +1732,9 @@ static void drawable_draw(DisplayChannel *display,
> Drawable *drawable)
>      case QXL_DRAW_COMPOSITE: {
>          SpiceComposite composite = drawable->red_drawable->u.composite;
>          SpiceImage src, mask;
> -        image_cache_localize(&display->image_cache, &composite.src_bitmap,
> &src, drawable);
> +        image_cache_localize(display->priv->image_cache,
> &composite.src_bitmap, &src, drawable);
>          if (composite.mask_bitmap)
> -            image_cache_localize(&display->image_cache,
> &composite.mask_bitmap, &mask, drawable);
> +            image_cache_localize(display->priv->image_cache,
> &composite.mask_bitmap, &mask, drawable);
>          canvas->ops->draw_composite(canvas, &drawable->red_drawable->bbox,
>                                      &clip, &composite);
>          break;
> @@ -1591,7 +1742,7 @@ static void drawable_draw(DisplayChannel *display,
> Drawable *drawable)
>      case QXL_DRAW_STROKE: {
>          SpiceStroke stroke = drawable->red_drawable->u.stroke;
>          SpiceImage img1;
> -        image_cache_localize_brush(&display->image_cache, &stroke.brush,
> &img1);
> +        image_cache_localize_brush(display->priv->image_cache,
> &stroke.brush, &img1);
>          canvas->ops->draw_stroke(canvas,
>                                   &drawable->red_drawable->bbox, &clip,
>                                   &stroke);
>          break;
> @@ -1599,8 +1750,8 @@ static void drawable_draw(DisplayChannel *display,
> Drawable *drawable)
>      case QXL_DRAW_TEXT: {
>          SpiceText text = drawable->red_drawable->u.text;
>          SpiceImage img1, img2;
> -        image_cache_localize_brush(&display->image_cache, &text.fore_brush,
> &img1);
> -        image_cache_localize_brush(&display->image_cache, &text.back_brush,
> &img2);
> +        image_cache_localize_brush(display->priv->image_cache,
> &text.fore_brush, &img1);
> +        image_cache_localize_brush(display->priv->image_cache,
> &text.back_brush, &img2);
>          canvas->ops->draw_text(canvas, &drawable->red_drawable->bbox,
>                                 &clip, &text);
>          break;
> @@ -1692,11 +1843,11 @@ void display_channel_draw_until(DisplayChannel
> *display, const SpiceRect *area,
>      spice_return_if_fail(last);
>      spice_return_if_fail(ring_item_is_linked(&last->list_link));
>  
> -    surface = &display->surfaces[surface_id];
> +    surface = &display->priv->surfaces[surface_id];
>  
>      if (surface_id != last->surface_id) {
>          // find the nearest older drawable from the appropriate surface
> -        ring = &display->current_list;
> +        ring = &display->priv->current_list;
>          ring_item = &last->list_link;
>          while ((ring_item = ring_next(ring, ring_item))) {
>              now = SPICE_CONTAINEROF(ring_item, Drawable, list_link);
> @@ -1732,12 +1883,12 @@ void display_channel_draw(DisplayChannel *display,
> const SpiceRect *area, int su
>      spice_debug("surface %d: area ==>", surface_id);
>      rect_debug(area);
>  
> -    spice_return_if_fail(surface_id >= 0 && surface_id < NUM_SURFACES);
> +    spice_return_if_fail(surface_id >= 0 && surface_id <
> display->priv->n_surfaces);
>      spice_return_if_fail(area);
>      spice_return_if_fail(area->left >= 0 && area->top >= 0 &&
>                           area->left < area->right && area->top <
>                           area->bottom);
>  
> -    surface = &display->surfaces[surface_id];
> +    surface = &display->priv->surfaces[surface_id];
>  
>      last = current_find_intersects_rect(&surface->current_list, NULL, area);
>      if (last)
> @@ -1769,12 +1920,12 @@ void display_channel_update(DisplayChannel *display,
>      SpiceRect rect;
>      RedSurface *surface;
>  
> -    spice_return_if_fail(validate_surface(display, surface_id));
> +    spice_return_if_fail(display_channel_validate_surface(display,
> surface_id));
>  
>      red_get_rect_ptr(&rect, area);
>      display_channel_draw(display, &rect, surface_id);
>  
> -    surface = &display->surfaces[surface_id];
> +    surface = &display->priv->surfaces[surface_id];
>      if (*qxl_dirty_rects == NULL) {
>          *num_dirty_rects =
>          pixman_region32_n_rects(&surface->draw_dirty_region);
>          *qxl_dirty_rects = spice_new0(QXLRect, *num_dirty_rects);
> @@ -1812,9 +1963,9 @@ void display_channel_destroy_surface(DisplayChannel
> *display, uint32_t surface_i
>  
>  void display_channel_destroy_surface_wait(DisplayChannel *display, uint32_t
>  surface_id)
>  {
> -    if (!validate_surface(display, surface_id))
> +    if (!display_channel_validate_surface(display, surface_id))
>          return;
> -    if (!display->surfaces[surface_id].context.canvas)
> +    if (!display->priv->surfaces[surface_id].context.canvas)
>          return;
>  
>      draw_depend_on_me(display, surface_id);
> @@ -1833,16 +1984,16 @@ void display_channel_destroy_surfaces(DisplayChannel
> *display)
>  
>      spice_debug(NULL);
>      //to handle better
> -    for (i = 0; i < NUM_SURFACES; ++i) {
> -        if (display->surfaces[i].context.canvas) {
> +    for (i = 0; i < display->priv->n_surfaces; ++i) {
> +        if (display->priv->surfaces[i].context.canvas) {
>              display_channel_destroy_surface_wait(display, i);
> -            if (display->surfaces[i].context.canvas) {
> +            if (display->priv->surfaces[i].context.canvas) {
>                  display_channel_surface_unref(display, i);
>              }
> -            spice_assert(!display->surfaces[i].context.canvas);
> +            spice_assert(!display->priv->surfaces[i].context.canvas);
>          }
>      }
> -    spice_warn_if_fail(ring_is_empty(&display->streams));
> +    spice_warn_if_fail(ring_is_empty(&display->priv->streams));
>  
>      if (red_channel_is_connected(RED_CHANNEL(display))) {
>          red_channel_pipes_add_type(RED_CHANNEL(display),
>          RED_PIPE_ITEM_TYPE_INVAL_PALETTE_CACHE);
> @@ -1873,8 +2024,8 @@ create_canvas_for_surface(DisplayChannel *display,
> RedSurface *surface, uint32_t
>      case RED_RENDERER_SW:
>          canvas = canvas_create_for_data(surface->context.width,
>          surface->context.height, surface->context.format,
>                                          surface->context.line_0,
>                                          surface->context.stride,
> -                                        &display->image_cache.base,
> -                                        &display->image_surfaces, NULL,
> NULL, NULL);
> +                                        &display->priv->image_cache->base,
> +                                        &display->priv->image_surfaces,
> NULL, NULL, NULL);
>          surface->context.top_down = TRUE;
>          surface->context.canvas_draws_on_surface = TRUE;
>          return canvas;
> @@ -1889,7 +2040,7 @@ void display_channel_create_surface(DisplayChannel
> *display, uint32_t surface_id
>                                      uint32_t height, int32_t stride,
>                                      uint32_t format,
>                                      void *line_0, int data_is_valid, int
>                                      send_client)
>  {
> -    RedSurface *surface = &display->surfaces[surface_id];
> +    RedSurface *surface = &display->priv->surfaces[surface_id];
>  
>      spice_warn_if_fail(!surface->context.canvas);
>  
> @@ -1914,21 +2065,21 @@ void display_channel_create_surface(DisplayChannel
> *display, uint32_t surface_id
>      region_init(&surface->draw_dirty_region);
>      surface->refs = 1;
>  
> -    if (display->renderer == RED_RENDERER_INVALID) {
> +    if (display->priv->renderer == RED_RENDERER_INVALID) {
>          int i;
> -        QXLInstance *qxl = display->common.qxl;
> +        QXLInstance *qxl =
> common_graphics_channel_get_qxl(&display->parent);
>          RedsState *reds = red_qxl_get_server(qxl->st);
>          GArray *renderers = reds_get_renderers(reds);
>          for (i = 0; i < renderers->len; i++) {
>              uint32_t renderer = g_array_index(renderers, uint32_t, i);
>              surface->context.canvas = create_canvas_for_surface(display,
>              surface, renderer);
>              if (surface->context.canvas) {
> -                display->renderer = renderer;
> +                display->priv->renderer = renderer;
>                  break;
>              }
>          }
>      } else {
> -        surface->context.canvas = create_canvas_for_surface(display,
> surface, display->renderer);
> +        surface->context.canvas = create_canvas_for_surface(display,
> surface, display->priv->renderer);
>      }
>  
>      spice_return_if_fail(surface->context.canvas);
> @@ -1952,7 +2103,7 @@ static void on_disconnect(RedChannelClient *rcc)
>  
>      // this was the last channel client
>      spice_debug("#draw=%d, #glz_draw=%d",
> -                display->drawable_count,
> +                display->priv->drawable_count,
>                  display->glz_drawable_count);
>  }
>  
> @@ -2007,72 +2158,27 @@ static int handle_migrate_data(RedChannelClient *rcc,
> uint32_t size, void *messa
>      return dcc_handle_migrate_data(DISPLAY_CHANNEL_CLIENT(rcc), size,
>      message);
>  }
>  
> -static SpiceCanvas *image_surfaces_get(SpiceImageSurfaces *surfaces,
> uint32_t surface_id)
> -{
> -    DisplayChannel *display = SPICE_CONTAINEROF(surfaces, DisplayChannel,
> image_surfaces);
> -
> -    spice_return_val_if_fail(validate_surface(display, surface_id), NULL);
> -
> -    return display->surfaces[surface_id].context.canvas;
> -}
> -
> -DisplayChannel* display_channel_new(SpiceServer *reds, RedWorker *worker,
> +DisplayChannel* display_channel_new(SpiceServer *reds,
> +                                    QXLInstance *qxl,
> +                                    const SpiceCoreInterfaceInternal* core,
>                                      int migrate, int stream_video,
>                                      uint32_t n_surfaces)
>  {
>      DisplayChannel *display;
> -    ChannelCbs cbs = {
> -        .on_disconnect = on_disconnect,
> -        .send_item = send_item,
> -        .hold_item = hold_item,
> -        .release_item = release_item,
> -        .handle_migrate_flush_mark = handle_migrate_flush_mark,
> -        .handle_migrate_data = handle_migrate_data,
> -        .handle_migrate_data_get_serial = handle_migrate_data_get_serial
> -    };
> -    static SpiceImageSurfacesOps image_surfaces_ops = {
> -        image_surfaces_get,
> -    };
>  
> +    /* FIXME: migrate is not used...? */
>      spice_info("create display channel");
> -    display = (DisplayChannel *)red_worker_new_channel(
> -        worker, sizeof(*display), "display_channel",
> -        SPICE_CHANNEL_DISPLAY,
> -        SPICE_MIGRATE_NEED_FLUSH | SPICE_MIGRATE_NEED_DATA_TRANSFER,
> -        &cbs, dcc_handle_message);
> -    spice_return_val_if_fail(display, NULL);
> -
> -    clockid_t stat_clock = CLOCK_THREAD_CPUTIME_ID;
> -    stat_init(&display->add_stat, "add", stat_clock);
> -    stat_init(&display->exclude_stat, "exclude", stat_clock);
> -    stat_init(&display->__exclude_stat, "__exclude", stat_clock);
> -#ifdef RED_STATISTICS
> -    RedChannel *channel = RED_CHANNEL(display);
> -    display->cache_hits_counter = stat_add_counter(reds, channel->stat,
> -                                                   "cache_hits", TRUE);
> -    display->add_to_cache_counter = stat_add_counter(reds, channel->stat,
> -                                                     "add_to_cache", TRUE);
> -    display->non_cache_counter = stat_add_counter(reds, channel->stat,
> -                                                  "non_cache", TRUE);
> -#endif
> -    stat_compress_init(&display->lz_stat, "lz", stat_clock);
> -    stat_compress_init(&display->glz_stat, "glz", stat_clock);
> -    stat_compress_init(&display->quic_stat, "quic", stat_clock);
> -    stat_compress_init(&display->jpeg_stat, "jpeg", stat_clock);
> -    stat_compress_init(&display->zlib_glz_stat, "zlib", stat_clock);
> -    stat_compress_init(&display->jpeg_alpha_stat, "jpeg_alpha", stat_clock);
> -    stat_compress_init(&display->lz4_stat, "lz4", stat_clock);
> -
> -    display->n_surfaces = n_surfaces;
> -    display->renderer = RED_RENDERER_INVALID;
> -
> -    ring_init(&display->current_list);
> -    display->image_surfaces.ops = &image_surfaces_ops;
> -    drawables_init(display);
> -    image_cache_init(&display->image_cache);
> -    display->stream_video = stream_video;
> -    display_channel_init_streams(display);
> -
> +    display = g_object_new(TYPE_DISPLAY_CHANNEL,
> +                           "spice-server", reds,
> +                           "core-interface", core,
> +                           "channel-type", SPICE_CHANNEL_DISPLAY,
> +                           "migration-flags", (SPICE_MIGRATE_NEED_FLUSH |
> SPICE_MIGRATE_NEED_DATA_TRANSFER),
> +                           "qxl", qxl,
> +                           "n-surfaces", n_surfaces,
> +                           NULL);
> +    if (display) {
> +        display_channel_set_stream_video(display, stream_video);
> +    }
>      return display;
>  }
>  
> @@ -2084,11 +2190,11 @@ void
> display_channel_process_surface_cmd(DisplayChannel *display, RedSurfaceCmd
>      uint8_t *data;
>  
>      surface_id = surface->surface_id;
> -    if SPICE_UNLIKELY(surface_id >= display->n_surfaces) {
> +    if SPICE_UNLIKELY(surface_id >= display->priv->n_surfaces) {
>          return;
>      }
>  
> -    red_surface = &display->surfaces[surface_id];
> +    red_surface = &display->priv->surfaces[surface_id];
>  
>      switch (surface->type) {
>      case QXL_SURFACE_CMD_CREATE: {
> @@ -2129,18 +2235,18 @@ void
> display_channel_update_compression(DisplayChannel *display, DisplayChannelC
>  {
>      gboolean is_low_bw =
>      common_graphics_channel_client_is_low_bandwidth(COMMON_GRAPHICS_CHANNEL_CLIENT(dcc));
>      if (dcc_get_jpeg_state(dcc) == SPICE_WAN_COMPRESSION_AUTO) {
> -        display->enable_jpeg = is_low_bw;
> +        display->priv->enable_jpeg = is_low_bw;
>      } else {
> -        display->enable_jpeg = (dcc_get_jpeg_state(dcc) ==
> SPICE_WAN_COMPRESSION_ALWAYS);
> +        display->priv->enable_jpeg = (dcc_get_jpeg_state(dcc) ==
> SPICE_WAN_COMPRESSION_ALWAYS);
>      }
>  
>      if (dcc_get_zlib_glz_state(dcc) == SPICE_WAN_COMPRESSION_AUTO) {
> -        display->enable_zlib_glz_wrap = is_low_bw;
> +        display->priv->enable_zlib_glz_wrap = is_low_bw;
>      } else {
> -        display->enable_zlib_glz_wrap = (dcc_get_zlib_glz_state(dcc) ==
> SPICE_WAN_COMPRESSION_ALWAYS);
> +        display->priv->enable_zlib_glz_wrap = (dcc_get_zlib_glz_state(dcc)
> == SPICE_WAN_COMPRESSION_ALWAYS);
>      }
> -    spice_info("jpeg %s", display->enable_jpeg ? "enabled" : "disabled");
> -    spice_info("zlib-over-glz %s", display->enable_zlib_glz_wrap ? "enabled"
> : "disabled");
> +    spice_info("jpeg %s", display->priv->enable_jpeg ? "enabled" :
> "disabled");
> +    spice_info("zlib-over-glz %s", display->priv->enable_zlib_glz_wrap ?
> "enabled" : "disabled");
>  }
>  
>  void display_channel_gl_scanout(DisplayChannel *display)
> @@ -2150,9 +2256,9 @@ void display_channel_gl_scanout(DisplayChannel
> *display)
>  
>  static void set_gl_draw_async_count(DisplayChannel *display, int num)
>  {
> -    QXLInstance *qxl = display->common.qxl;
> +    QXLInstance *qxl = common_graphics_channel_get_qxl(&display->parent);
>  
> -    display->gl_draw_async_count = num;
> +    display->priv->gl_draw_async_count = num;
>  
>      if (num == 0) {
>          red_qxl_gl_draw_async_complete(qxl);
> @@ -2163,7 +2269,7 @@ void display_channel_gl_draw(DisplayChannel *display,
> SpiceMsgDisplayGlDraw *dra
>  {
>      int num;
>  
> -    spice_return_if_fail(display->gl_draw_async_count == 0);
> +    spice_return_if_fail(display->priv->gl_draw_async_count == 0);
>  
>      num = red_channel_pipes_new_add_push(RED_CHANNEL(display),
>      dcc_gl_draw_item_new, draw);
>      set_gl_draw_async_count(display, num);
> @@ -2171,5 +2277,93 @@ void display_channel_gl_draw(DisplayChannel *display,
> SpiceMsgDisplayGlDraw *dra
>  
>  void display_channel_gl_draw_done(DisplayChannel *display)
>  {
> -    set_gl_draw_async_count(display, display->gl_draw_async_count - 1);
> +    set_gl_draw_async_count(display, display->priv->gl_draw_async_count -
> 1);
> +}
> +
> +int display_channel_get_stream_id(DisplayChannel *display, Stream *stream)
> +{
> +    return (int)(stream - display->priv->streams_buf);
> +}
> +
> +gboolean display_channel_validate_surface(DisplayChannel *display, uint32_t
> surface_id)
> +{
> +    if SPICE_UNLIKELY(surface_id >= display->priv->n_surfaces) {
> +        spice_warning("invalid surface_id %u", surface_id);
> +        return 0;
> +    }
> +    if (!display->priv->surfaces[surface_id].context.canvas) {
> +        spice_warning("canvas address is %p for %d (and is NULL)\n",
> +                   &(display->priv->surfaces[surface_id].context.canvas),
> surface_id);
> +        spice_warning("failed on %d", surface_id);
> +        return 0;
> +    }
> +    return 1;
> +}
> +
> +void display_channel_update_monitors_config(DisplayChannel *display,
> +                                            QXLMonitorsConfig *config,
> +                                            uint16_t count, uint16_t
> max_allowed)
> +{
> +    if (display->priv->monitors_config)
> +        monitors_config_unref(display->priv->monitors_config);
> +
> +    display->priv->monitors_config =
> +        monitors_config_new(config->heads, count, max_allowed);
> +
> +}
> +
> +void display_channel_set_monitors_config_to_primary(DisplayChannel *display)
> +{
> +    DrawContext *context = &display->priv->surfaces[0].context;
> +    QXLHead head = { 0, };
> +
> +    spice_return_if_fail(display->priv->surfaces[0].context.canvas);
> +
> +    if (display->priv->monitors_config)
> +        monitors_config_unref(display->priv->monitors_config);
> +
> +    head.width = context->width;
> +    head.height = context->height;
> +    display->priv->monitors_config = monitors_config_new(&head, 1, 1);
> +}
> +
> +void display_channel_reset_image_cache(DisplayChannel *self)
> +{
> +    image_cache_reset(self->priv->image_cache);
> +}
> +
> +static void
> +display_channel_class_init(DisplayChannelClass *klass)
> +{
> +    GObjectClass *object_class = G_OBJECT_CLASS(klass);
> +    RedChannelClass *channel_class = RED_CHANNEL_CLASS(klass);
> +
> +    g_type_class_add_private(klass, sizeof(DisplayChannelPrivate));
> +
> +    object_class->get_property = display_channel_get_property;
> +    object_class->set_property = display_channel_set_property;
> +    object_class->constructed = display_channel_constructed;
> +    object_class->finalize = display_channel_finalize;
> +
> +    channel_class->parser =
> spice_get_client_channel_parser(SPICE_CHANNEL_DISPLAY, NULL);
> +    channel_class->handle_parsed = dcc_handle_message;
> +
> +    channel_class->on_disconnect = on_disconnect;
> +    channel_class->send_item = send_item;
> +    channel_class->hold_item = hold_item;
> +    channel_class->release_item = release_item;
> +    channel_class->handle_migrate_flush_mark = handle_migrate_flush_mark;
> +    channel_class->handle_migrate_data = handle_migrate_data;
> +    channel_class->handle_migrate_data_get_serial =
> handle_migrate_data_get_serial;
> +
> +    g_object_class_install_property(object_class,
> +                                    PROP_N_SURFACES,
> +                                    g_param_spec_uint("n-surfaces",
> +                                                      "number of surfaces",
> +                                                      "Number of surfaces
> for this channel",
> +                                                      0, G_MAXUINT,
> +                                                      0,
> +                                                      G_PARAM_CONSTRUCT_ONLY
> |
> +                                                      G_PARAM_READWRITE |
> +
> G_PARAM_STATIC_STRINGS));
>  }
> diff --git a/server/display-channel.h b/server/display-channel.h
> index cb0a1e3..597d615 100644
> --- a/server/display-channel.h
> +++ b/server/display-channel.h
> @@ -20,31 +20,63 @@
>  
>  #include <setjmp.h>
>  
> -#include "common/rect.h"
> -#include "reds-stream.h"
>  #include "cache-item.h"
> -#include "pixmap-cache.h"
>  #include "sw-canvas.h"
> -#include "stat.h"
> -#include "reds.h"
> -#include "memslot.h"
> -#include "red-parse-qxl.h"
> -#include "red-record-qxl.h"
> +#include "common-graphics-channel.h"
> +#include "common/rect.h"
> +#include "dcc-encoders.h"
> +#include "dcc.h"
>  #include "demarshallers.h"
> -#include "red-channel.h"
> -#include "red-qxl.h"
>  #include "dispatcher.h"
>  #include "main-channel.h"
> -#include "migration-protocol.h"
>  #include "main-dispatcher.h"
> +#include "memslot.h"
> +#include "migration-protocol.h"
> +#include "mjpeg-encoder.h"
> +#include "pixmap-cache.h"
> +#include "red-channel.h"
> +#include "red-qxl.h"
> +#include "red-parse-qxl.h"
> +#include "red-record-qxl.h"
> +#include "reds-stream.h"
> +#include "reds.h"
>  #include "spice-bitmap-utils.h"
> -#include "image-cache.h"
> -#include "utils.h"
> -#include "tree.h"
> +#include "stat.h"
>  #include "stream.h"
> -#include "dcc.h"
> -#include "dcc-encoders.h"
> +#include "tree.h"
> +#include "utils.h"
> +
> +G_BEGIN_DECLS
>  
> +#define TYPE_DISPLAY_CHANNEL display_channel_get_type()
> +
> +#define DISPLAY_CHANNEL(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),
> TYPE_DISPLAY_CHANNEL, DisplayChannel))
> +#define DISPLAY_CHANNEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),
> TYPE_DISPLAY_CHANNEL, DisplayChannelClass))
> +#define IS_DISPLAY_CHANNEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),
> TYPE_DISPLAY_CHANNEL))
> +#define IS_DISPLAY_CHANNEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),
> TYPE_DISPLAY_CHANNEL))
> +#define DISPLAY_CHANNEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj),
> TYPE_DISPLAY_CHANNEL, DisplayChannelClass))
> +
> +typedef struct DisplayChannel DisplayChannel;
> +typedef struct DisplayChannelClass DisplayChannelClass;
> +typedef struct DisplayChannelPrivate DisplayChannelPrivate;
> +
> +struct DisplayChannel
> +{
> +    CommonGraphicsChannel parent;
> +
> +    uint32_t glz_drawable_count;
> +
> +    DisplayChannelPrivate *priv;
> +};
> +
> +struct DisplayChannelClass
> +{
> +    CommonGraphicsChannelClass parent_class;
> +};
> +
> +GType display_channel_get_type(void) G_GNUC_CONST;
> +
> +G_END_DECLS
>  typedef struct DependItem {
>      Drawable *drawable;
>      RingItem ring_item;
> @@ -164,68 +196,8 @@ struct _Drawable {
>      } u;
>  };
>  
> -struct DisplayChannel {
> -    CommonGraphicsChannel common; // Must be the first thing
> -    uint32_t bits_unique;
> -
> -    MonitorsConfig *monitors_config;
> -
> -    uint32_t renderer;
> -    int enable_jpeg;
> -    int enable_zlib_glz_wrap;
> -
> -    Ring current_list; // of TreeItem
> -    uint32_t current_size;
> -
> -    uint32_t drawable_count;
> -    _Drawable drawables[NUM_DRAWABLES];
> -    _Drawable *free_drawables;
> -
> -    uint32_t glz_drawable_count;
> -
> -    int stream_video;
> -    uint32_t stream_count;
> -    Stream streams_buf[NUM_STREAMS];
> -    Stream *free_streams;
> -    Ring streams;
> -    ItemTrace items_trace[NUM_TRACE_ITEMS];
> -    uint32_t next_item_trace;
> -    uint64_t streams_size_total;
> -
> -    RedSurface surfaces[NUM_SURFACES];
> -    uint32_t n_surfaces;
> -    SpiceImageSurfaces image_surfaces;
> -
> -    ImageCache image_cache;
> -    RedCompressBuf *free_compress_bufs;
> -
> -    int gl_draw_async_count;
> -
> -/* TODO: some day unify this, make it more runtime.. */
> -    stat_info_t add_stat;
> -    stat_info_t exclude_stat;
> -    stat_info_t __exclude_stat;
> -#ifdef RED_WORKER_STAT
> -    uint32_t add_count;
> -    uint32_t add_with_shadow_count;
> -#endif
> -#ifdef RED_STATISTICS
> -    uint64_t *cache_hits_counter;
> -    uint64_t *add_to_cache_counter;
> -    uint64_t *non_cache_counter;
> -#endif
> -    stat_info_t off_stat;
> -    stat_info_t lz_stat;
> -    stat_info_t glz_stat;
> -    stat_info_t quic_stat;
> -    stat_info_t jpeg_stat;
> -    stat_info_t zlib_glz_stat;
> -    stat_info_t jpeg_alpha_stat;
> -    stat_info_t lz4_stat;
> -};
> -
>  #define FOREACH_DCC(channel, _link, _next, _data)                   \
> -    for (_link = (channel ? RED_CHANNEL(channel)->clients : NULL), \
> +    for (_link = (channel ? red_channel_get_clients(RED_CHANNEL(channel)) :
> NULL), \
>           _next = (_link ? _link->next : NULL), \
>           _data = (_link ? _link->data : NULL); \
>           _link; \
> @@ -233,10 +205,7 @@ struct DisplayChannel {
>           _next = (_link ? _link->next : NULL), \
>           _data = (_link ? _link->data : NULL))
>  
> -static inline int get_stream_id(DisplayChannel *display, Stream *stream)
> -{
> -    return (int)(stream - display->streams_buf);
> -}
> +int display_channel_get_stream_id(DisplayChannel *display, Stream *stream);
>  
>  typedef struct RedSurfaceDestroyItem {
>      SpiceMsgSurfaceDestroy surface_destroy;
> @@ -251,7 +220,8 @@ typedef struct RedUpgradeItem {
>  
>  
>  DisplayChannel*            display_channel_new
>  (SpiceServer *reds,
> -
> RedWorker
> *worker,
> +
> QXLInstance
> *qxl,
> +                                                                      const
> SpiceCoreInterfaceInternal* core,
>                                                                        int
>                                                                        migrate,
>                                                                        int
>                                                                        stream_video,
>                                                                        uint32_t
>                                                                        n_surfaces);
> @@ -275,13 +245,16 @@ void                       display_channel_update
> (DisplayCha
>  void                       display_channel_free_some
>  (DisplayChannel *display);
>  void                       display_channel_set_stream_video
>  (DisplayChannel *display,
>                                                                        int
>                                                                        stream_video);
> +int                        display_channel_get_stream_video
> (DisplayChannel *display);
>  int                        display_channel_get_streams_timeout
>  (DisplayChannel *display);
> -void                       display_channel_compress_stats_print      (const
> DisplayChannel *display);
> +void                       display_channel_compress_stats_print
> (DisplayChannel *display);
>  void                       display_channel_compress_stats_reset
>  (DisplayChannel *display);
>  Drawable *                 display_channel_drawable_try_new
>  (DisplayChannel *display,
>                                                                        int
>                                                                        process_commands_generation);
>  void                       display_channel_surface_unref
>  (DisplayChannel *display,
>                                                                        uint32_t
>                                                                        surface_id);
> +bool                       display_channel_surface_has_canvas
> (DisplayChannel *display,
> +
> uint32_t
> surface_id);
>  void                       display_channel_current_flush
>  (DisplayChannel *display,
>                                                                        int
>                                                                        surface_id);
>  int                        display_channel_wait_for_migrate_data
>  (DisplayChannel *display);
> @@ -306,21 +279,12 @@ void                       display_channel_gl_scanout
> (DisplayCha
>  void                       display_channel_gl_draw
>  (DisplayChannel *display,
>                                                                        SpiceMsgDisplayGlDraw
>                                                                        *draw);
>  void                       display_channel_gl_draw_done
>  (DisplayChannel *display);
> +void display_channel_update_monitors_config(DisplayChannel *display,
> QXLMonitorsConfig *config,
> +                                            uint16_t count, uint16_t
> max_allowed);
> +void display_channel_set_monitors_config_to_primary(DisplayChannel
> *display);
>  
> -static inline int validate_surface(DisplayChannel *display, uint32_t
> surface_id)
> -{
> -    if SPICE_UNLIKELY(surface_id >= display->n_surfaces) {
> -        spice_warning("invalid surface_id %u", surface_id);
> -        return 0;
> -    }
> -    if (!display->surfaces[surface_id].context.canvas) {
> -        spice_warning("canvas address is %p for %d (and is NULL)\n",
> -                   &(display->surfaces[surface_id].context.canvas),
> surface_id);
> -        spice_warning("failed on %d", surface_id);
> -        return 0;
> -    }
> -    return 1;
> -}
> +gboolean display_channel_validate_surface(DisplayChannel *display, uint32_t
> surface_id);
> +void display_channel_reset_image_cache(DisplayChannel *self);
>  
>  static inline int is_equal_path(SpicePath *path1, SpicePath *path2)
>  {
> diff --git a/server/dummy-channel-client.c b/server/dummy-channel-client.c
> index a0354fd..6f0b868 100644
> --- a/server/dummy-channel-client.c
> +++ b/server/dummy-channel-client.c
> @@ -36,9 +36,11 @@ struct DummyChannelClientPrivate
>  
>  static int dummy_channel_client_pre_create_validate(RedChannel *channel,
>  RedClient  *client)
>  {
> -    if (red_client_get_channel(client, channel->type, channel->id)) {
> +    uint32_t type, id;
> +    g_object_get(channel, "channel-type", &type, "id", &id, NULL);
> +    if (red_client_get_channel(client, type, id)) {
>          spice_printerr("Error client %p: duplicate channel type %d id %d",
> -                       client, channel->type, channel->id);
> +                       client, type, id);
>          return FALSE;
>      }
>      return TRUE;
> @@ -53,6 +55,9 @@ static gboolean
> dummy_channel_client_initable_init(GInitable *initable,
>      RedChannelClient *rcc = RED_CHANNEL_CLIENT(self);
>      RedClient *client = red_channel_client_get_client(rcc);
>      RedChannel *channel = red_channel_client_get_channel(rcc);
> +    uint32_t type, id;
> +
> +    g_object_get(channel, "channel-type", &type, "id", &id, NULL);
>      pthread_mutex_lock(&client->lock);
>      if (!dummy_channel_client_pre_create_validate(channel,
>                                                    client)) {
> @@ -60,7 +65,7 @@ static gboolean
> dummy_channel_client_initable_init(GInitable *initable,
>                      SPICE_SERVER_ERROR,
>                      SPICE_SERVER_ERROR_FAILED,
>                      "Client %p: duplicate channel type %d id %d",
> -                    client, channel->type, channel->id);
> +                    client, type, id);
>          goto cleanup;
>      }
>  
> @@ -94,10 +99,12 @@ void dummy_channel_client_disconnect(RedChannelClient
> *rcc)
>      DummyChannelClient *self = DUMMY_CHANNEL_CLIENT(rcc);
>      RedChannel *channel = red_channel_client_get_channel(rcc);
>      GList *link;
> +    uint32_t type, id;
>  
> -    if (channel && (link = g_list_find(channel->clients, rcc))) {
> +    if (channel && (link = g_list_find(red_channel_get_clients(channel),
> rcc))) {
> +        g_object_get(channel, "channel-type", &type, "id", &id, NULL);
>          spice_printerr("rcc=%p (channel=%p type=%d id=%d)", rcc, channel,
> -                       channel->type, channel->id);
> +                       type, id);
>          red_channel_remove_client(channel, link->data);
>      }
>      self->priv->connected = FALSE;
> diff --git a/server/dummy-channel.c b/server/dummy-channel.c
> new file mode 100644
> index 0000000..6ec7842
> --- /dev/null
> +++ b/server/dummy-channel.c
> @@ -0,0 +1,58 @@
> +/* dummy-channel.c */
> +#ifdef HAVE_CONFIG_H
> +#include <config.h>
> +#endif
> +
> +#include "dummy-channel.h"
> +
> +G_DEFINE_TYPE(DummyChannel, dummy_channel, RED_TYPE_CHANNEL)
> +
> +#define DUMMY_CHANNEL_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o),
> TYPE_DUMMY_CHANNEL, DummyChannelPrivate))
> +
> +struct DummyChannelPrivate
> +{
> +    gpointer padding;
> +};
> +
> +static void
> +dummy_channel_class_init(DummyChannelClass *klass)
> +{
> +    g_type_class_add_private(klass, sizeof(DummyChannelPrivate));
> +}
> +
> +static void
> +dummy_channel_init(DummyChannel *self)
> +{
> +    self->priv = DUMMY_CHANNEL_PRIVATE(self);
> +}
> +
> +// TODO: red_worker can use this one
> +static void dummy_watch_update_mask(SpiceWatch *watch, int event_mask)
> +{
> +}
> +
> +static SpiceWatch *dummy_watch_add(int fd, int event_mask, SpiceWatchFunc
> func, void *opaque)
> +{
> +    return NULL; // apparently allowed?
> +}
> +
> +static void dummy_watch_remove(SpiceWatch *watch)
> +{
> +}
> +
> +// TODO: actually, since I also use channel_client_dummym, no need for core.
> Can be NULL
> +static const SpiceCoreInterface dummy_core = {
> +    .watch_update_mask = dummy_watch_update_mask,
> +    .watch_add = dummy_watch_add,
> +    .watch_remove = dummy_watch_remove,
> +};
> +
> +RedChannel *dummy_channel_new(RedsState *reds, uint32_t type, uint32_t id)
> +{
> +    return g_object_new(TYPE_DUMMY_CHANNEL,
> +                        "spice-server", reds,
> +                        "core-interface", &dummy_core,
> +                        "channel-type", type,
> +                        "id", id,
> +                        NULL);
> +}
> diff --git a/server/dummy-channel.h b/server/dummy-channel.h
> new file mode 100644
> index 0000000..dd2f005
> --- /dev/null
> +++ b/server/dummy-channel.h
> @@ -0,0 +1,61 @@
> +/*
> +   Copyright (C) 2009-2015 Red Hat, Inc.
> +
> +   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, see
> <http://www.gnu.org/licenses/>.
> +   */
> +
> +#ifndef __DUMMY_CHANNEL_H__
> +#define __DUMMY_CHANNEL_H__
> +
> +#include <glib-object.h>
> +
> +#include "red-channel.h"
> +
> +G_BEGIN_DECLS
> +
> +// TODO: tmp, for channels that don't use RedChannel yet (e.g., snd
> channel), but
> +// do use the client callbacks. So the channel clients are not connected
> (the channel doesn't
> +// have list of them, but they do have a link to the channel, and the client
> has a list of them)
> +
> +#define TYPE_DUMMY_CHANNEL dummy_channel_get_type()
> +
> +#define DUMMY_CHANNEL(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),
> TYPE_DUMMY_CHANNEL, DummyChannel))
> +#define DUMMY_CHANNEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),
> TYPE_DUMMY_CHANNEL, DummyChannelClass))
> +#define _IS_DUMMY_CHANNEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),
> TYPE_DUMMY_CHANNEL))
> +#define _IS_DUMMY_CHANNEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),
> TYPE_DUMMY_CHANNEL))
> +#define DUMMY_CHANNEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj),
> TYPE_DUMMY_CHANNEL, DummyChannelClass))
> +
> +typedef struct DummyChannel DummyChannel;
> +typedef struct DummyChannelClass DummyChannelClass;
> +typedef struct DummyChannelPrivate DummyChannelPrivate;
> +
> +struct DummyChannel
> +{
> +    RedChannel parent;
> +
> +    DummyChannelPrivate *priv;
> +};
> +
> +struct DummyChannelClass
> +{
> +    RedChannelClass parent_class;
> +};
> +
> +GType dummy_channel_get_type(void) G_GNUC_CONST;
> +
> +RedChannel *dummy_channel_new(RedsState *reds, uint32_t type, uint32_t id);
> +
> +G_END_DECLS
> +
> +#endif /* __DUMMY_CHANNEL_H__ */
> diff --git a/server/inputs-channel.c b/server/inputs-channel.c
> index c0fdc98..32e2cfe 100644
> --- a/server/inputs-channel.c
> +++ b/server/inputs-channel.c
> @@ -57,6 +57,83 @@
>  #define RECEIVE_BUF_SIZE \
>      (4096 + (REDS_AGENT_WINDOW_SIZE + REDS_NUM_INTERNAL_AGENT_MESSAGES) *
>      SPICE_AGENT_MAX_DATA_SIZE)
>  
> +G_DEFINE_TYPE(InputsChannel, inputs_channel, RED_TYPE_CHANNEL)
> +
> +#define CHANNEL_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o),
> TYPE_INPUTS_CHANNEL, InputsChannelPrivate))
> +
> +struct InputsChannelPrivate
> +{
> +    uint8_t recv_buf[RECEIVE_BUF_SIZE];
> +    VDAgentMouseState mouse_state;
> +    int src_during_migrate;
> +
> +    SpiceKbdInstance *keyboard;
> +    SpiceMouseInstance *mouse;
> +    SpiceTabletInstance *tablet;
> +};
> +
> +
> +static void
> +inputs_channel_get_property(GObject *object,
> +                            guint property_id,
> +                            GValue *value,
> +                            GParamSpec *pspec)
> +{
> +    switch (property_id)
> +    {
> +        default:
> +            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
> +    }
> +}
> +
> +static void
> +inputs_channel_set_property(GObject *object,
> +                            guint property_id,
> +                            const GValue *value,
> +                            GParamSpec *pspec)
> +{
> +    switch (property_id)
> +    {
> +        default:
> +            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
> +    }
> +}
> +
> +static void inputs_connect(RedChannel *channel, RedClient *client,
> +                           RedsStream *stream, int migration,
> +                           int num_common_caps, uint32_t *common_caps,
> +                           int num_caps, uint32_t *caps);
> +static void inputs_migrate(RedChannelClient *rcc);
> +static SpiceTimer *key_modifiers_timer;
> +static void key_modifiers_sender(void *opaque);
> +
> +static void
> +inputs_channel_constructed(GObject *object)
> +{
> +    ClientCbs client_cbs = { NULL, };
> +    InputsChannel *self = INPUTS_CHANNEL(object);
> +    RedsState *reds = red_channel_get_server(RED_CHANNEL(self));
> +
> +    G_OBJECT_CLASS(inputs_channel_parent_class)->constructed(object);
> +
> +    client_cbs.connect = inputs_connect;
> +    client_cbs.migrate = inputs_migrate;
> +    red_channel_register_client_cbs(RED_CHANNEL(self), &client_cbs, NULL);
> +
> +    red_channel_set_cap(RED_CHANNEL(self), SPICE_INPUTS_CAP_KEY_SCANCODE);
> +    reds_register_channel(reds, RED_CHANNEL(self));
> +
> +    if (!(key_modifiers_timer = reds_core_timer_add(reds,
> key_modifiers_sender, self))) {
> +        spice_error("key modifiers timer create failed");
> +    }
> +}
> +
> +static void
> +inputs_channel_init(InputsChannel *self)
> +{
> +    self->priv = CHANNEL_PRIVATE(self);
> +}
> +
>  struct SpiceKbdState {
>      bool push_ext;
>  
> @@ -101,17 +178,6 @@ RedsState*
> spice_tablet_state_get_server(SpiceTabletState *st)
>      return st->reds;
>  }
>  
> -struct InputsChannel {
> -    RedChannel base;
> -    uint8_t recv_buf[RECEIVE_BUF_SIZE];
> -    VDAgentMouseState mouse_state;
> -    int src_during_migrate;
> -
> -    SpiceKbdInstance *keyboard;
> -    SpiceMouseInstance *mouse;
> -    SpiceTabletInstance *tablet;
> -};
> -
>  typedef struct RedInputsPipeItem {
>      RedPipeItem base;
>  } RedInputsPipeItem;
> @@ -126,8 +192,6 @@ typedef struct RedInputsInitPipeItem {
>      uint8_t modifiers;
>  } RedInputsInitPipeItem;
>  
> -static SpiceTimer *key_modifiers_timer;
> -
>  
>  #define KEY_MODIFIERS_TTL (MSEC_PER_SEC * 2)
>  
> @@ -139,26 +203,26 @@ void
> inputs_channel_set_tablet_logical_size(InputsChannel *inputs, int x_res, in
>  {
>      SpiceTabletInterface *sif;
>  
> -    sif = SPICE_CONTAINEROF(inputs->tablet->base.sif, SpiceTabletInterface,
> base);
> -    sif->set_logical_size(inputs->tablet, x_res, y_res);
> +    sif = SPICE_CONTAINEROF(inputs->priv->tablet->base.sif,
> SpiceTabletInterface, base);
> +    sif->set_logical_size(inputs->priv->tablet, x_res, y_res);
>  }
>  
>  VDAgentMouseState *inputs_channel_get_mouse_state(InputsChannel *inputs)
>  {
> -    return &inputs->mouse_state;
> +    return &inputs->priv->mouse_state;
>  }
>  
>  static uint8_t *inputs_channel_alloc_msg_rcv_buf(RedChannelClient *rcc,
>                                                   uint16_t type,
>                                                   uint32_t size)
>  {
> -    InputsChannel *inputs_channel =
> (InputsChannel*)red_channel_client_get_channel(rcc);
> +    InputsChannel *inputs =
> (InputsChannel*)red_channel_client_get_channel(rcc);
>  
>      if (size > RECEIVE_BUF_SIZE) {
>          spice_printerr("error: too large incoming message");
>          return NULL;
>      }
> -    return inputs_channel->recv_buf;
> +    return inputs->priv->recv_buf;
>  }
>  
>  static void inputs_channel_release_msg_rcv_buf(RedChannelClient *rcc,
> @@ -276,10 +340,10 @@ static void inputs_channel_send_item(RedChannelClient
> *rcc, RedPipeItem *base)
>  static int inputs_channel_handle_parsed(RedChannelClient *rcc, uint32_t
>  size, uint16_t type,
>                                          void *message)
>  {
> -    InputsChannel *inputs_channel = (InputsChannel
> *)red_channel_client_get_channel(rcc);
> +    InputsChannel *inputs =
> INPUTS_CHANNEL(red_channel_client_get_channel(rcc));
>      InputsChannelClient *icc = INPUTS_CHANNEL_CLIENT(rcc);
>      uint32_t i;
> -    RedsState *reds = red_channel_get_server(&inputs_channel->base);
> +    RedsState *reds = red_channel_get_server(RED_CHANNEL(inputs));
>  
>      switch (type) {
>      case SPICE_MSGC_INPUTS_KEY_DOWN: {
> @@ -297,19 +361,19 @@ static int
> inputs_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, ui
>              if (code == 0) {
>                  break;
>              }
> -            kbd_push_scan(inputs_channel_get_keyboard(inputs_channel),
> code);
> +            kbd_push_scan(inputs_channel_get_keyboard(inputs), code);
>          }
>          break;
>      }
>      case SPICE_MSGC_INPUTS_KEY_SCANCODE: {
>          uint8_t *code = message;
>          for (i = 0; i < size; i++) {
> -            kbd_push_scan(inputs_channel_get_keyboard(inputs_channel),
> code[i]);
> +            kbd_push_scan(inputs_channel_get_keyboard(inputs), code[i]);
>          }
>          break;
>      }
>      case SPICE_MSGC_INPUTS_MOUSE_MOTION: {
> -        SpiceMouseInstance *mouse =
> inputs_channel_get_mouse(inputs_channel);
> +        SpiceMouseInstance *mouse = inputs_channel_get_mouse(inputs);
>          SpiceMsgcMouseMotion *mouse_motion = message;
>  
>          inputs_channel_client_on_mouse_motion(icc);
> @@ -324,7 +388,7 @@ static int inputs_channel_handle_parsed(RedChannelClient
> *rcc, uint32_t size, ui
>      }
>      case SPICE_MSGC_INPUTS_MOUSE_POSITION: {
>          SpiceMsgcMousePosition *pos = message;
> -        SpiceTabletInstance *tablet =
> inputs_channel_get_tablet(inputs_channel);
> +        SpiceTabletInstance *tablet = inputs_channel_get_tablet(inputs);
>  
>          inputs_channel_client_on_mouse_motion(icc);
>          if (reds_get_mouse_mode(reds) != SPICE_MOUSE_MODE_CLIENT) {
> @@ -337,7 +401,7 @@ static int inputs_channel_handle_parsed(RedChannelClient
> *rcc, uint32_t size, ui
>              sif->position(tablet, pos->x, pos->y,
>              RED_MOUSE_STATE_TO_LOCAL(pos->buttons_state));
>              break;
>          }
> -        VDAgentMouseState *mouse_state = &inputs_channel->mouse_state;
> +        VDAgentMouseState *mouse_state = &inputs->priv->mouse_state;
>          mouse_state->x = pos->x;
>          mouse_state->y = pos->y;
>          mouse_state->buttons =
>          RED_MOUSE_BUTTON_STATE_TO_AGENT(pos->buttons_state);
> @@ -355,20 +419,20 @@ static int
> inputs_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, ui
>          }
>          if (reds_get_mouse_mode(reds) == SPICE_MOUSE_MODE_CLIENT) {
>              if (reds_config_get_agent_mouse(reds) && reds_has_vdagent(reds))
>              {
> -                inputs_channel->mouse_state.buttons =
> +                inputs->priv->mouse_state.buttons =
>                      RED_MOUSE_BUTTON_STATE_TO_AGENT(mouse_press->buttons_state)
>                      |
>                      (dz == -1 ? VD_AGENT_UBUTTON_MASK : 0) |
>                      (dz == 1 ? VD_AGENT_DBUTTON_MASK : 0);
> -                reds_handle_agent_mouse_event(reds,
> &inputs_channel->mouse_state);
> -            } else if (inputs_channel_get_tablet(inputs_channel)) {
> +                reds_handle_agent_mouse_event(reds,
> &inputs->priv->mouse_state);
> +            } else if (inputs_channel_get_tablet(inputs)) {
>                  SpiceTabletInterface *sif;
> -                sif =
> SPICE_CONTAINEROF(inputs_channel_get_tablet(inputs_channel)->base.sif,
> SpiceTabletInterface, base);
> -                sif->wheel(inputs_channel_get_tablet(inputs_channel), dz,
> RED_MOUSE_STATE_TO_LOCAL(mouse_press->buttons_state));
> +                sif =
> SPICE_CONTAINEROF(inputs_channel_get_tablet(inputs)->base.sif,
> SpiceTabletInterface, base);
> +                sif->wheel(inputs_channel_get_tablet(inputs), dz,
> RED_MOUSE_STATE_TO_LOCAL(mouse_press->buttons_state));
>              }
> -        } else if (inputs_channel_get_mouse(inputs_channel)) {
> +        } else if (inputs_channel_get_mouse(inputs)) {
>              SpiceMouseInterface *sif;
> -            sif =
> SPICE_CONTAINEROF(inputs_channel_get_mouse(inputs_channel)->base.sif,
> SpiceMouseInterface, base);
> -            sif->motion(inputs_channel_get_mouse(inputs_channel), 0, 0, dz,
> +            sif =
> SPICE_CONTAINEROF(inputs_channel_get_mouse(inputs)->base.sif,
> SpiceMouseInterface, base);
> +            sif->motion(inputs_channel_get_mouse(inputs), 0, 0, dz,
>                          RED_MOUSE_STATE_TO_LOCAL(mouse_press->buttons_state));
>          }
>          break;
> @@ -377,18 +441,18 @@ static int
> inputs_channel_handle_parsed(RedChannelClient *rcc, uint32_t size, ui
>          SpiceMsgcMouseRelease *mouse_release = message;
>          if (reds_get_mouse_mode(reds) == SPICE_MOUSE_MODE_CLIENT) {
>              if (reds_config_get_agent_mouse(reds) && reds_has_vdagent(reds))
>              {
> -                inputs_channel->mouse_state.buttons =
> +                inputs->priv->mouse_state.buttons =
>                      RED_MOUSE_BUTTON_STATE_TO_AGENT(mouse_release->buttons_state);
> -                reds_handle_agent_mouse_event(reds,
> &inputs_channel->mouse_state);
> -            } else if (inputs_channel_get_tablet(inputs_channel)) {
> +                reds_handle_agent_mouse_event(reds,
> &inputs->priv->mouse_state);
> +            } else if (inputs_channel_get_tablet(inputs)) {
>                  SpiceTabletInterface *sif;
> -                sif =
> SPICE_CONTAINEROF(inputs_channel_get_tablet(inputs_channel)->base.sif,
> SpiceTabletInterface, base);
> -                sif->buttons(inputs_channel_get_tablet(inputs_channel),
> RED_MOUSE_STATE_TO_LOCAL(mouse_release->buttons_state));
> +                sif =
> SPICE_CONTAINEROF(inputs_channel_get_tablet(inputs)->base.sif,
> SpiceTabletInterface, base);
> +                sif->buttons(inputs_channel_get_tablet(inputs),
> RED_MOUSE_STATE_TO_LOCAL(mouse_release->buttons_state));
>              }
> -        } else if (inputs_channel_get_mouse(inputs_channel)) {
> +        } else if (inputs_channel_get_mouse(inputs)) {
>              SpiceMouseInterface *sif;
> -            sif =
> SPICE_CONTAINEROF(inputs_channel_get_mouse(inputs_channel)->base.sif,
> SpiceMouseInterface, base);
> -            sif->buttons(inputs_channel_get_mouse(inputs_channel),
> +            sif =
> SPICE_CONTAINEROF(inputs_channel_get_mouse(inputs)->base.sif,
> SpiceMouseInterface, base);
> +            sif->buttons(inputs_channel_get_mouse(inputs),
>                           RED_MOUSE_STATE_TO_LOCAL(mouse_release->buttons_state));
>          }
>          break;
> @@ -396,7 +460,7 @@ static int inputs_channel_handle_parsed(RedChannelClient
> *rcc, uint32_t size, ui
>      case SPICE_MSGC_INPUTS_KEY_MODIFIERS: {
>          SpiceMsgcKeyModifiers *modifiers = message;
>          uint8_t leds;
> -        SpiceKbdInstance *keyboard =
> inputs_channel_get_keyboard(inputs_channel);
> +        SpiceKbdInstance *keyboard = inputs_channel_get_keyboard(inputs);
>  
>          if (!keyboard) {
>              break;
> @@ -520,17 +584,17 @@ static void inputs_connect(RedChannel *channel,
> RedClient *client,
>  static void inputs_migrate(RedChannelClient *rcc)
>  {
>      InputsChannel *inputs =
>      (InputsChannel*)red_channel_client_get_channel(rcc);
> -    inputs->src_during_migrate = TRUE;
> +    inputs->priv->src_during_migrate = TRUE;
>      red_channel_client_default_migrate(rcc);
>  }
>  
>  static void inputs_channel_push_keyboard_modifiers(InputsChannel *inputs,
>  uint8_t modifiers)
>  {
> -    if (!inputs || !red_channel_is_connected(&inputs->base) ||
> -        inputs->src_during_migrate) {
> +    if (!inputs || !red_channel_is_connected(RED_CHANNEL(inputs)) ||
> +        inputs->priv->src_during_migrate) {
>          return;
>      }
> -    red_channel_pipes_new_add_push(&inputs->base,
> +    red_channel_pipes_new_add_push(RED_CHANNEL(inputs),
>          red_inputs_key_modifiers_item_new, (void*)&modifiers);
>  }
>  
> @@ -574,117 +638,113 @@ static int
> inputs_channel_handle_migrate_data(RedChannelClient *rcc,
>      return TRUE;
>  }
>  
> -InputsChannel* inputs_channel_new(RedsState *reds)
> +static void
> +inputs_channel_class_init(InputsChannelClass *klass)
>  {
> -    ChannelCbs channel_cbs = { NULL, };
> -    ClientCbs client_cbs = { NULL, };
> -    InputsChannel *inputs;
> -
> -    channel_cbs.config_socket = inputs_channel_config_socket;
> -    channel_cbs.on_disconnect = inputs_channel_on_disconnect;
> -    channel_cbs.send_item = inputs_channel_send_item;
> -    channel_cbs.hold_item = inputs_channel_hold_pipe_item;
> -    channel_cbs.release_item = inputs_channel_release_pipe_item;
> -    channel_cbs.alloc_recv_buf = inputs_channel_alloc_msg_rcv_buf;
> -    channel_cbs.release_recv_buf = inputs_channel_release_msg_rcv_buf;
> -    channel_cbs.handle_migrate_data = inputs_channel_handle_migrate_data;
> -    channel_cbs.handle_migrate_flush_mark =
> inputs_channel_handle_migrate_flush_mark;
> -
> -    inputs = (InputsChannel *)red_channel_create_parser(
> -                                    sizeof(InputsChannel),
> -                                    reds,
> -                                    reds_get_core_interface(reds),
> -                                    SPICE_CHANNEL_INPUTS, 0,
> -                                    FALSE, /* handle_acks */
> -
> spice_get_client_channel_parser(SPICE_CHANNEL_INPUTS,
> NULL),
> -                                    inputs_channel_handle_parsed,
> -                                    &channel_cbs,
> -                                    SPICE_MIGRATE_NEED_FLUSH |
> SPICE_MIGRATE_NEED_DATA_TRANSFER);
> -
> -    if (!inputs) {
> -        spice_error("failed to allocate Inputs Channel");
> -    }
> +    GObjectClass *object_class = G_OBJECT_CLASS(klass);
> +    RedChannelClass *channel_class = RED_CHANNEL_CLASS(klass);
>  
> -    client_cbs.connect = inputs_connect;
> -    client_cbs.migrate = inputs_migrate;
> -    red_channel_register_client_cbs(&inputs->base, &client_cbs, NULL);
> +    g_type_class_add_private(klass, sizeof(InputsChannelPrivate));
>  
> -    red_channel_set_cap(&inputs->base, SPICE_INPUTS_CAP_KEY_SCANCODE);
> -    reds_register_channel(reds, &inputs->base);
> +    object_class->get_property = inputs_channel_get_property;
> +    object_class->set_property = inputs_channel_set_property;
> +    object_class->constructed = inputs_channel_constructed;
> +
> +    channel_class->parser =
> spice_get_client_channel_parser(SPICE_CHANNEL_INPUTS, NULL);
> +    channel_class->handle_parsed = inputs_channel_handle_parsed;
> +
> +    /* channel callbacks */
> +    channel_class->config_socket = inputs_channel_config_socket;
> +    channel_class->on_disconnect = inputs_channel_on_disconnect;
> +    channel_class->send_item = inputs_channel_send_item;
> +    channel_class->hold_item = inputs_channel_hold_pipe_item;
> +    channel_class->release_item = inputs_channel_release_pipe_item;
> +    channel_class->alloc_recv_buf = inputs_channel_alloc_msg_rcv_buf;
> +    channel_class->release_recv_buf = inputs_channel_release_msg_rcv_buf;
> +    channel_class->handle_migrate_data = inputs_channel_handle_migrate_data;
> +    channel_class->handle_migrate_flush_mark =
> inputs_channel_handle_migrate_flush_mark;
> +}
> +
> +InputsChannel* inputs_channel_new(RedsState *reds)
> +{
> +    return  g_object_new(TYPE_INPUTS_CHANNEL,
> +                         "spice-server", reds,
> +                         "core-interface", reds_get_core_interface(reds),
> +                         "channel-type", (int)SPICE_CHANNEL_INPUTS,
> +                         "id", 0,
> +                         "handle-acks", FALSE,
> +                         "migration-flags", (guint)(SPICE_MIGRATE_NEED_FLUSH
> | SPICE_MIGRATE_NEED_DATA_TRANSFER),
> +                         NULL);
>  
> -    if (!(key_modifiers_timer = reds_core_timer_add(reds,
> key_modifiers_sender, inputs))) {
> -        spice_error("key modifiers timer create failed");
> -    }
> -    return inputs;
>  }
>  
>  SpiceKbdInstance* inputs_channel_get_keyboard(InputsChannel *inputs)
>  {
> -    return inputs->keyboard;
> +    return inputs->priv->keyboard;
>  }
>  
>  int inputs_channel_set_keyboard(InputsChannel *inputs, SpiceKbdInstance
>  *keyboard)
>  {
> -    if (inputs->keyboard) {
> +    if (inputs->priv->keyboard) {
>          spice_printerr("already have keyboard");
>          return -1;
>      }
> -    inputs->keyboard = keyboard;
> -    inputs->keyboard->st =
> spice_kbd_state_new(red_channel_get_server(&inputs->base));
> +    inputs->priv->keyboard = keyboard;
> +    inputs->priv->keyboard->st =
> spice_kbd_state_new(red_channel_get_server(RED_CHANNEL(inputs)));
>      return 0;
>  }
>  
>  SpiceMouseInstance* inputs_channel_get_mouse(InputsChannel *inputs)
>  {
> -    return inputs->mouse;
> +    return inputs->priv->mouse;
>  }
>  
>  int inputs_channel_set_mouse(InputsChannel *inputs, SpiceMouseInstance
>  *mouse)
>  {
> -    if (inputs->mouse) {
> +    if (inputs->priv->mouse) {
>          spice_printerr("already have mouse");
>          return -1;
>      }
> -    inputs->mouse = mouse;
> -    inputs->mouse->st = spice_mouse_state_new();
> +    inputs->priv->mouse = mouse;
> +    inputs->priv->mouse->st = spice_mouse_state_new();
>      return 0;
>  }
>  
>  SpiceTabletInstance* inputs_channel_get_tablet(InputsChannel *inputs)
>  {
> -    return inputs->tablet;
> +    return inputs->priv->tablet;
>  }
>  
>  int inputs_channel_set_tablet(InputsChannel *inputs, SpiceTabletInstance
>  *tablet, RedsState *reds)
>  {
> -    if (inputs->tablet) {
> +    if (inputs->priv->tablet) {
>          spice_printerr("already have tablet");
>          return -1;
>      }
> -    inputs->tablet = tablet;
> -    inputs->tablet->st = spice_tablet_state_new();
> -    inputs->tablet->st->reds = reds;
> +    inputs->priv->tablet = tablet;
> +    inputs->priv->tablet->st = spice_tablet_state_new();
> +    inputs->priv->tablet->st->reds = reds;
>      return 0;
>  }
>  
>  int inputs_channel_has_tablet(InputsChannel *inputs)
>  {
> -    return inputs != NULL && inputs->tablet != NULL;
> +    return inputs != NULL && inputs->priv->tablet != NULL;
>  }
>  
>  void inputs_channel_detach_tablet(InputsChannel *inputs, SpiceTabletInstance
>  *tablet)
>  {
>      spice_printerr("");
> -    inputs->tablet = NULL;
> +    inputs->priv->tablet = NULL;
>  }
>  
>  gboolean inputs_channel_is_src_during_migrate(InputsChannel *inputs)
>  {
> -    return inputs->src_during_migrate;
> +    return inputs->priv->src_during_migrate;
>  }
>  
>  void inputs_channel_set_src_during_migrate(InputsChannel *inputs,
>                                             gboolean value)
>  {
> -    inputs->src_during_migrate = value;
> +    inputs->priv->src_during_migrate = value;
>  }
> diff --git a/server/inputs-channel.h b/server/inputs-channel.h
> index 5317578..1dbb3a2 100644
> --- a/server/inputs-channel.h
> +++ b/server/inputs-channel.h
> @@ -21,14 +21,42 @@
>  // Inputs channel, dealing with keyboard, mouse, tablet.
>  // This include should only be used by reds.c and inputs-channel.c
>  
> +#include <glib-object.h>
>  #include <stdint.h>
>  #include <spice/vd_agent.h>
>  
>  #include "red-channel.h"
>  
> +G_BEGIN_DECLS
> +
> +#define TYPE_INPUTS_CHANNEL inputs_channel_get_type()
> +
> +#define INPUTS_CHANNEL(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),
> TYPE_INPUTS_CHANNEL, InputsChannel))
> +#define INPUTS_CHANNEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),
> TYPE_INPUTS_CHANNEL, InputsChannelClass))
> +#define INPUTS_IS_CHANNEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),
> TYPE_INPUTS_CHANNEL))
> +#define INPUTS_IS_CHANNEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),
> TYPE_INPUTS_CHANNEL))
> +#define INPUTS_CHANNEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj),
> TYPE_INPUTS_CHANNEL, InputsChannelClass))
> +
>  typedef struct InputsChannel InputsChannel;
> +typedef struct InputsChannelClass InputsChannelClass;
> +typedef struct InputsChannelPrivate InputsChannelPrivate;
> +
> +struct InputsChannel
> +{
> +    RedChannel parent;
> +
> +    InputsChannelPrivate *priv;
> +};
> +
> +struct InputsChannelClass
> +{
> +    RedChannelClass parent_class;
> +};
> +
> +GType inputs_channel_get_type(void) G_GNUC_CONST;
>  
>  InputsChannel* inputs_channel_new(RedsState *reds);
> +
>  VDAgentMouseState *inputs_channel_get_mouse_state(InputsChannel *inputs);
>  void inputs_channel_on_keyboard_leds_change(InputsChannel *inputs, uint8_t
>  leds);
>  void inputs_channel_set_tablet_logical_size(InputsChannel *inputs, int
>  x_res, int y_res);
> @@ -53,4 +81,6 @@ enum {
>      RED_PIPE_ITEM_MIGRATE_DATA,
>  };
>  
> +G_END_DECLS
> +
>  #endif
> diff --git a/server/main-channel-client.c b/server/main-channel-client.c
> index 82cb5c3..f18be1c 100644
> --- a/server/main-channel-client.c
> +++ b/server/main-channel-client.c
> @@ -101,16 +101,6 @@ static void main_channel_client_set_property(GObject
> *object,
>      }
>  }
>  
> -static void main_channel_client_dispose(GObject *object)
> -{
> -    G_OBJECT_CLASS(main_channel_client_parent_class)->dispose(object);
> -}
> -
> -static void main_channel_client_finalize(GObject *object)
> -{
> -    G_OBJECT_CLASS(main_channel_client_parent_class)->finalize(object);
> -}
> -
>  static void ping_timer_cb(void *opaque);
>  static void main_channel_client_constructed(GObject *object)
>  {
> @@ -135,8 +125,6 @@ static void
> main_channel_client_class_init(MainChannelClientClass *klass)
>  
>      object_class->get_property = main_channel_client_get_property;
>      object_class->set_property = main_channel_client_set_property;
> -    object_class->dispose = main_channel_client_dispose;
> -    object_class->finalize = main_channel_client_finalize;
>      object_class->constructed = main_channel_client_constructed;
>  
>      g_object_class_install_property(object_class,
> @@ -341,15 +329,11 @@ void
> main_channel_client_handle_migrate_connected(MainChannelClient *mcc,
>      spice_printerr("client %p connected: %d seamless %d",
>                     client, success, seamless);
>      if (mcc->priv->mig_wait_connect) {
> -        MainChannel *main_channel = SPICE_CONTAINEROF(channel, MainChannel,
> base);
> +        MainChannel *main_channel = MAIN_CHANNEL(channel);
>  
>          mcc->priv->mig_wait_connect = FALSE;
>          mcc->priv->mig_connect_ok = success;
> -        spice_assert(main_channel->num_clients_mig_wait);
> -        spice_assert(!seamless || main_channel->num_clients_mig_wait == 1);
> -        if (!--main_channel->num_clients_mig_wait) {
> -            reds_on_main_migrate_connected(channel->reds, seamless &&
> success);
> -        }
> +        main_channel_on_migrate_connected(main_channel, seamless &&
> success);
>      } else {
>          if (success) {
>              spice_printerr("client %p MIGRATE_CANCEL", client);
> @@ -362,7 +346,7 @@ void
> main_channel_client_handle_migrate_dst_do_seamless(MainChannelClient *mcc,
>                                                          uint32_t
>                                                          src_version)
>  {
>      RedChannel *channel =
>      red_channel_client_get_channel(RED_CHANNEL_CLIENT(mcc));
> -    if (reds_on_migrate_dst_set_seamless(channel->reds, mcc, src_version)) {
> +    if (reds_on_migrate_dst_set_seamless(red_channel_get_server(channel),
> mcc, src_version)) {
>          mcc->priv->seamless_mig_dst = TRUE;
>          red_channel_client_pipe_add_empty_msg(RED_CHANNEL_CLIENT(mcc),
>                                               SPICE_MSG_MAIN_MIGRATE_DST_SEAMLESS_ACK);
> @@ -429,7 +413,10 @@ void main_channel_client_handle_pong(MainChannelClient
> *mcc, SpiceMsgPing *ping,
>          red_channel_client_handle_message(rcc, size, SPICE_MSGC_PONG, ping);
>      }
>  #ifdef RED_STATISTICS
> -    stat_update_value(red_channel_client_get_channel(rcc)->reds, roundtrip);
> +    {
> +        RedChannel *channel = red_channel_client_get_channel(rcc);
> +        stat_update_value(red_channel_get_server(channel), roundtrip);
> +    }
>  #endif
>  }
>  
> @@ -470,7 +457,7 @@ void
> main_channel_client_migrate_dst_complete(MainChannelClient *mcc)
>      RedChannel *channel =
>      red_channel_client_get_channel(RED_CHANNEL_CLIENT(mcc));
>      if (mcc->priv->mig_wait_prev_complete) {
>          if (mcc->priv->mig_wait_prev_try_seamless) {
> -            spice_assert(channel->clients_num == 1);
> +            spice_assert(red_channel_get_n_clients(channel) == 1);
>              red_channel_client_pipe_add_type(RED_CHANNEL_CLIENT(mcc),
>                                               RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_BEGIN_SEAMLESS);
>          } else {
> @@ -528,9 +515,11 @@ static void do_ping_client(MainChannelClient *mcc,
>          if (has_interval && interval > 0) {
>              mcc->priv->ping_interval = interval * MSEC_PER_SEC;
>          }
> -        reds_core_timer_start(channel->reds, mcc->priv->ping_timer,
> mcc->priv->ping_interval);
> +        reds_core_timer_start(red_channel_get_server(channel),
> +                              mcc->priv->ping_timer,
> mcc->priv->ping_interval);
>      } else if (!strcmp(opt, "off")) {
> -        reds_core_timer_cancel(channel->reds, mcc->priv->ping_timer);
> +        reds_core_timer_cancel(red_channel_get_server(channel),
> +                               mcc->priv->ping_timer);
>      } else {
>          return;
>      }
> @@ -543,11 +532,13 @@ static void ping_timer_cb(void *opaque)
>  
>      if (!red_channel_client_is_connected(RED_CHANNEL_CLIENT(mcc))) {
>          spice_printerr("not connected to peer, ping off");
> -        reds_core_timer_cancel(channel->reds, mcc->priv->ping_timer);
> +        reds_core_timer_cancel(red_channel_get_server(channel),
> +                               mcc->priv->ping_timer);
>          return;
>      }
>      do_ping_client(mcc, NULL, 0, 0);
> -    reds_core_timer_start(channel->reds, mcc->priv->ping_timer,
> mcc->priv->ping_interval);
> +    reds_core_timer_start(red_channel_get_server(channel),
> +                          mcc->priv->ping_timer, mcc->priv->ping_interval);
>  }
>  #endif /* RED_STATISTICS */
>  
> @@ -611,15 +602,14 @@ uint64_t
> main_channel_client_get_roundtrip_ms(MainChannelClient *mcc)
>  void main_channel_client_migrate(RedChannelClient *rcc)
>  {
>      RedChannel *channel = red_channel_client_get_channel(rcc);
> -    reds_on_main_channel_migrate(channel->reds, MAIN_CHANNEL_CLIENT(rcc));
> +    reds_on_main_channel_migrate(red_channel_get_server(channel),
> +                                 MAIN_CHANNEL_CLIENT(rcc));
>      red_channel_client_default_migrate(rcc);
>  }
>  
>  gboolean main_channel_client_connect_semi_seamless(MainChannelClient *mcc)
>  {
>      RedChannelClient *rcc = RED_CHANNEL_CLIENT(mcc);
> -    MainChannel* main_channel =
> SPICE_CONTAINEROF(red_channel_client_get_channel(rcc),
> -                                                  MainChannel, base);
>      if (red_channel_client_test_remote_cap(rcc,
>                                             SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE))
>                                             {
>          RedClient *client = red_channel_client_get_client(rcc);
> @@ -633,7 +623,6 @@ gboolean
> main_channel_client_connect_semi_seamless(MainChannelClient *mcc)
>              mcc->priv->mig_wait_connect = TRUE;
>          }
>          mcc->priv->mig_connect_ok = FALSE;
> -        main_channel->num_clients_mig_wait++;
>          return TRUE;
>      }
>      return FALSE;
> diff --git a/server/main-channel-client.h b/server/main-channel-client.h
> index 5d284ad..50713ea 100644
> --- a/server/main-channel-client.h
> +++ b/server/main-channel-client.h
> @@ -23,8 +23,6 @@
>  
>  G_BEGIN_DECLS
>  
> -typedef struct MainChannel MainChannel;
> -
>  #define TYPE_MAIN_CHANNEL_CLIENT main_channel_client_get_type()
>  
>  #define MAIN_CHANNEL_CLIENT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),
>  TYPE_MAIN_CHANNEL_CLIENT, MainChannelClient))
> @@ -49,6 +47,8 @@ struct MainChannelClientClass
>      RedChannelClientClass parent_class;
>  };
>  
> +typedef struct MainChannel MainChannel;
> +
>  GType main_channel_client_get_type(void) G_GNUC_CONST;
>  
>  MainChannelClient *main_channel_client_create(MainChannel *main_chan,
>  RedClient *client,
> diff --git a/server/main-channel.c b/server/main-channel.c
> index e3d6c57..554c20d 100644
> --- a/server/main-channel.c
> +++ b/server/main-channel.c
> @@ -50,15 +50,51 @@
>  #include "utils.h"
>  
>  #define ZERO_BUF_SIZE 4096
> +// approximate max receive message size for main channel
> +#define MAIN_CHANNEL_RECEIVE_BUF_SIZE \
> +    (4096 + (REDS_AGENT_WINDOW_SIZE + REDS_NUM_INTERNAL_AGENT_MESSAGES) *
> SPICE_AGENT_MAX_DATA_SIZE)
>  
>  static const uint8_t zero_page[ZERO_BUF_SIZE] = {0};
>  
> +
> +G_DEFINE_TYPE(MainChannel, main_channel, RED_TYPE_CHANNEL)
> +
> +#define MAIN_CHANNEL_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o),
> TYPE_MAIN_CHANNEL, MainChannelPrivate))
> +
> +struct MainChannelPrivate
> +{
> +    uint8_t recv_buf[MAIN_CHANNEL_RECEIVE_BUF_SIZE];
> +    RedsMigSpice mig_target; // TODO: add refs and release (afrer all
> clients completed migration in one way or the other?)
> +    int num_clients_mig_wait;
> +};
> +
> +static void
> +main_channel_constructed(GObject *object)
> +{
> +    MainChannel *self = MAIN_CHANNEL(object);
> +    ClientCbs client_cbs = { NULL, };
> +
> +    G_OBJECT_CLASS(main_channel_parent_class)->constructed(object);
> +
> +    red_channel_set_cap(RED_CHANNEL(self),
> SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE);
> +    red_channel_set_cap(RED_CHANNEL(self), SPICE_MAIN_CAP_SEAMLESS_MIGRATE);
> +
> +    client_cbs.migrate = main_channel_client_migrate;
> +    red_channel_register_client_cbs(RED_CHANNEL(self), &client_cbs, NULL);
> +}
> +
> +static void
> +main_channel_init(MainChannel *self)
> +{
> +    self->priv = MAIN_CHANNEL_PRIVATE(self);
> +}
> +
>  static void main_channel_release_pipe_item(RedChannelClient *rcc,
>                                             RedPipeItem *base, int
>                                             item_pushed);
>  
>  int main_channel_is_connected(MainChannel *main_chan)
>  {
> -    return red_channel_is_connected(&main_chan->base);
> +    return red_channel_is_connected(RED_CHANNEL(main_chan));
>  }
>  
>  /*
> @@ -78,7 +114,7 @@ RedClient *main_channel_get_client_by_link_id(MainChannel
> *main_chan, uint32_t c
>      MainChannelClient *mcc;
>      RedChannelClient *rcc;
>  
> -    for (link = main_chan->base.clients; link != NULL; link = link->next) {
> +    for (link = red_channel_get_clients(RED_CHANNEL(main_chan)); link !=
> NULL; link = link->next) {
>          rcc = link->data;
>          mcc = MAIN_CHANNEL_CLIENT(rcc);
>          if (main_channel_client_get_connection_id(mcc) == connection_id) {
> @@ -134,7 +170,7 @@ static void
> main_channel_marshall_channels(RedChannelClient *rcc,
>      RedChannel *channel = red_channel_client_get_channel(rcc);
>  
>      red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_CHANNELS_LIST,
>      item);
> -    channels_info = reds_msg_channels_new(channel->reds);
> +    channels_info = reds_msg_channels_new(red_channel_get_server(channel));
>      spice_marshall_msg_main_channels_list(m, channels_info);
>      free(channels_info);
>  }
> @@ -167,7 +203,7 @@ void main_channel_push_mouse_mode(MainChannel *main_chan,
> int current_mode,
>          .is_client_mouse_allowed=is_client_mouse_allowed,
>      };
>  
> -    red_channel_pipes_new_add_push(&main_chan->base,
> +    red_channel_pipes_new_add_push(RED_CHANNEL(main_chan),
>          main_mouse_mode_item_new, &info);
>  }
>  
> @@ -188,10 +224,10 @@ static void
> main_channel_marshall_mouse_mode(RedChannelClient *rcc,
>  
>  void main_channel_push_agent_connected(MainChannel *main_chan)
>  {
> -    if (red_channel_test_remote_cap(&main_chan->base,
> SPICE_MAIN_CAP_AGENT_CONNECTED_TOKENS)) {
> -        red_channel_pipes_add_type(&main_chan->base,
> RED_PIPE_ITEM_TYPE_MAIN_AGENT_CONNECTED_TOKENS);
> +    if (red_channel_test_remote_cap(RED_CHANNEL(main_chan),
> SPICE_MAIN_CAP_AGENT_CONNECTED_TOKENS)) {
> +        red_channel_pipes_add_type(RED_CHANNEL(main_chan),
> RED_PIPE_ITEM_TYPE_MAIN_AGENT_CONNECTED_TOKENS);
>      } else {
> -        red_channel_pipes_add_empty_msg(&main_chan->base,
> SPICE_MSG_MAIN_AGENT_CONNECTED);
> +        red_channel_pipes_add_empty_msg(RED_CHANNEL(main_chan),
> SPICE_MSG_MAIN_AGENT_CONNECTED);
>      }
>  }
>  
> @@ -208,7 +244,7 @@ static void
> main_channel_marshall_agent_connected(SpiceMarshaller *m,
>  
>  void main_channel_push_agent_disconnected(MainChannel *main_chan)
>  {
> -    red_channel_pipes_add_type(&main_chan->base,
> RED_PIPE_ITEM_TYPE_MAIN_AGENT_DISCONNECTED);
> +    red_channel_pipes_add_type(RED_CHANNEL(main_chan),
> RED_PIPE_ITEM_TYPE_MAIN_AGENT_DISCONNECTED);
>  }
>  
>  static void main_channel_marshall_agent_disconnected(RedChannelClient *rcc,
> @@ -242,7 +278,7 @@ static void
> main_channel_marshall_agent_data(RedChannelClient *rcc,
>  
>  static void main_channel_push_migrate_data_item(MainChannel *main_chan)
>  {
> -    red_channel_pipes_add_type(&main_chan->base,
> RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_DATA);
> +    red_channel_pipes_add_type(RED_CHANNEL(main_chan),
> RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_DATA);
>  }
>  
>  static void main_channel_marshall_migrate_data_item(RedChannelClient *rcc,
> @@ -251,7 +287,7 @@ static void
> main_channel_marshall_migrate_data_item(RedChannelClient *rcc,
>  {
>      RedChannel *channel = red_channel_client_get_channel(rcc);
>      red_channel_client_init_send_data(rcc, SPICE_MSG_MIGRATE_DATA, item);
> -    reds_marshall_migrate_data(channel->reds, m); // TODO: from reds split.
> ugly separation.
> +    reds_marshall_migrate_data(red_channel_get_server(channel), m); // TODO:
> from reds split. ugly separation.
>  }
>  
>  static int main_channel_handle_migrate_data(RedChannelClient *rcc,
> @@ -262,7 +298,7 @@ static int
> main_channel_handle_migrate_data(RedChannelClient *rcc,
>      SpiceMigrateDataHeader *header = (SpiceMigrateDataHeader *)message;
>  
>      /* not supported with multi-clients */
> -    spice_assert(channel->clients_num == 1);
> +    spice_assert(red_channel_get_n_clients(channel) == 1);
>  
>      if (size < sizeof(SpiceMigrateDataHeader) +
>      sizeof(SpiceMigrateDataMain)) {
>          spice_printerr("bad message size %u", size);
> @@ -274,7 +310,9 @@ static int
> main_channel_handle_migrate_data(RedChannelClient *rcc,
>          spice_error("bad header");
>          return FALSE;
>      }
> -    return reds_handle_migrate_data(channel->reds, mcc,
> (SpiceMigrateDataMain *)(header + 1), size);
> +    return reds_handle_migrate_data(red_channel_get_server(channel), mcc,
> +                                    (SpiceMigrateDataMain *)(header + 1),
> +                                    size);
>  }
>  
>  static void main_channel_marshall_init(RedChannelClient *rcc,
> @@ -292,7 +330,7 @@ static void main_channel_marshall_init(RedChannelClient
> *rcc,
>      if (item->is_client_mouse_allowed) {
>          init.supported_mouse_modes |= SPICE_MOUSE_MODE_CLIENT;
>      }
> -    init.agent_connected = reds_has_vdagent(channel->reds);
> +    init.agent_connected =
> reds_has_vdagent(red_channel_get_server(channel));
>      init.agent_tokens = REDS_AGENT_WINDOW_SIZE;
>      init.multi_media_time = item->multi_media_time;
>      init.ram_hint = item->ram_hint;
> @@ -317,7 +355,7 @@ static void main_channel_marshall_notify(RedChannelClient
> *rcc,
>  static void main_channel_fill_migrate_dst_info(MainChannel *main_channel,
>                                                 SpiceMigrationDstInfo
>                                                 *dst_info)
>  {
> -    RedsMigSpice *mig_dst = &main_channel->mig_target;
> +    RedsMigSpice *mig_dst = &main_channel->priv->mig_target;
>      dst_info->port = mig_dst->port;
>      dst_info->sport = mig_dst->sport;
>      dst_info->host_size = strlen(mig_dst->host) + 1;
> @@ -336,11 +374,9 @@ static void
> main_channel_marshall_migrate_begin(SpiceMarshaller *m, RedChannelCl
>  {
>      RedChannel *channel = red_channel_client_get_channel(rcc);
>      SpiceMsgMainMigrationBegin migrate;
> -    MainChannel *main_ch;
>  
>      red_channel_client_init_send_data(rcc, SPICE_MSG_MAIN_MIGRATE_BEGIN,
>      item);
> -    main_ch = SPICE_CONTAINEROF(channel, MainChannel, base);
> -    main_channel_fill_migrate_dst_info(main_ch, &migrate.dst_info);
> +    main_channel_fill_migrate_dst_info(MAIN_CHANNEL(channel),
> &migrate.dst_info);
>      spice_marshall_msg_main_migrate_begin(m, &migrate);
>  }
>  
> @@ -350,11 +386,9 @@ static void
> main_channel_marshall_migrate_begin_seamless(SpiceMarshaller *m,
>  {
>      RedChannel *channel = red_channel_client_get_channel(rcc);
>      SpiceMsgMainMigrateBeginSeamless migrate_seamless;
> -    MainChannel *main_ch;
>  
>      red_channel_client_init_send_data(rcc,
>      SPICE_MSG_MAIN_MIGRATE_BEGIN_SEAMLESS, item);
> -    main_ch = SPICE_CONTAINEROF(channel, MainChannel, base);
> -    main_channel_fill_migrate_dst_info(main_ch, &migrate_seamless.dst_info);
> +    main_channel_fill_migrate_dst_info(MAIN_CHANNEL(channel),
> &migrate_seamless.dst_info);
>      migrate_seamless.src_mig_version = SPICE_MIGRATION_PROTOCOL_VERSION;
>      spice_marshall_msg_main_migrate_begin_seamless(m, &migrate_seamless);
>  }
> @@ -365,29 +399,29 @@ void main_channel_push_multi_media_time(MainChannel
> *main_chan, int time)
>          .time = time,
>      };
>  
> -    red_channel_pipes_new_add_push(&main_chan->base,
> +    red_channel_pipes_new_add_push(RED_CHANNEL(main_chan),
>          main_multi_media_time_item_new, &info);
>  }
>  
>  static void main_channel_fill_mig_target(MainChannel *main_channel,
>  RedsMigSpice *mig_target)
>  {
>      spice_assert(mig_target);
> -    free(main_channel->mig_target.host);
> -    main_channel->mig_target.host = spice_strdup(mig_target->host);
> -    free(main_channel->mig_target.cert_subject);
> +    free(main_channel->priv->mig_target.host);
> +    main_channel->priv->mig_target.host = spice_strdup(mig_target->host);
> +    free(main_channel->priv->mig_target.cert_subject);
>      if (mig_target->cert_subject) {
> -        main_channel->mig_target.cert_subject =
> spice_strdup(mig_target->cert_subject);
> +        main_channel->priv->mig_target.cert_subject =
> spice_strdup(mig_target->cert_subject);
>      } else {
> -        main_channel->mig_target.cert_subject = NULL;
> +        main_channel->priv->mig_target.cert_subject = NULL;
>      }
> -    main_channel->mig_target.port = mig_target->port;
> -    main_channel->mig_target.sport = mig_target->sport;
> +    main_channel->priv->mig_target.port = mig_target->port;
> +    main_channel->priv->mig_target.sport = mig_target->sport;
>  }
>  
>  void main_channel_migrate_switch(MainChannel *main_chan, RedsMigSpice
>  *mig_target)
>  {
>      main_channel_fill_mig_target(main_chan, mig_target);
> -    red_channel_pipes_add_type(&main_chan->base,
> RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST);
> +    red_channel_pipes_add_type(RED_CHANNEL(main_chan),
> RED_PIPE_ITEM_TYPE_MAIN_MIGRATE_SWITCH_HOST);
>  }
>  
>  static void main_channel_marshall_migrate_switch(SpiceMarshaller *m,
>  RedChannelClient *rcc,
> @@ -395,18 +429,18 @@ static void
> main_channel_marshall_migrate_switch(SpiceMarshaller *m, RedChannelC
>  {
>      RedChannel *channel = red_channel_client_get_channel(rcc);
>      SpiceMsgMainMigrationSwitchHost migrate;
> -    MainChannel *main_ch;
> +    MainChannel *main_chan;
>  
>      spice_printerr("");
>      red_channel_client_init_send_data(rcc,
>      SPICE_MSG_MAIN_MIGRATE_SWITCH_HOST, item);
> -    main_ch = SPICE_CONTAINEROF(channel, MainChannel, base);
> -    migrate.port = main_ch->mig_target.port;
> -    migrate.sport = main_ch->mig_target.sport;
> -    migrate.host_size = strlen(main_ch->mig_target.host) + 1;
> -    migrate.host_data = (uint8_t *)main_ch->mig_target.host;
> -    if (main_ch->mig_target.cert_subject) {
> -        migrate.cert_subject_size = strlen(main_ch->mig_target.cert_subject)
> + 1;
> -        migrate.cert_subject_data = (uint8_t
> *)main_ch->mig_target.cert_subject;
> +    main_chan = MAIN_CHANNEL(channel);
> +    migrate.port = main_chan->priv->mig_target.port;
> +    migrate.sport = main_chan->priv->mig_target.sport;
> +    migrate.host_size = strlen(main_chan->priv->mig_target.host) + 1;
> +    migrate.host_data = (uint8_t *)main_chan->priv->mig_target.host;
> +    if (main_chan->priv->mig_target.cert_subject) {
> +        migrate.cert_subject_size =
> strlen(main_chan->priv->mig_target.cert_subject) + 1;
> +        migrate.cert_subject_data = (uint8_t
> *)main_chan->priv->mig_target.cert_subject;
>      } else {
>          migrate.cert_subject_size = 0;
>          migrate.cert_subject_data = NULL;
> @@ -536,8 +570,9 @@ static int main_channel_handle_parsed(RedChannelClient
> *rcc, uint32_t size, uint
>                                        void *message)
>  {
>      RedChannel *channel = red_channel_client_get_channel(rcc);
> -    MainChannel *main_chan = SPICE_CONTAINEROF(channel, MainChannel, base);
> +    MainChannel *main_chan = MAIN_CHANNEL(channel);
>      MainChannelClient *mcc = MAIN_CHANNEL_CLIENT(rcc);
> +    RedsState *reds = red_channel_get_server(channel);
>  
>      switch (type) {
>      case SPICE_MSGC_MAIN_AGENT_START: {
> @@ -548,18 +583,18 @@ static int main_channel_handle_parsed(RedChannelClient
> *rcc, uint32_t size, uint
>              return FALSE;
>          }
>          tokens = (SpiceMsgcMainAgentStart *)message;
> -        reds_on_main_agent_start(channel->reds, mcc, tokens->num_tokens);
> +        reds_on_main_agent_start(reds, mcc, tokens->num_tokens);
>          break;
>      }
>      case SPICE_MSGC_MAIN_AGENT_DATA: {
> -        reds_on_main_agent_data(channel->reds, mcc, message, size);
> +        reds_on_main_agent_data(reds, mcc, message, size);
>          break;
>      }
>      case SPICE_MSGC_MAIN_AGENT_TOKEN: {
>          SpiceMsgcMainAgentTokens *tokens;
>  
>          tokens = (SpiceMsgcMainAgentTokens *)message;
> -        reds_on_main_agent_tokens(channel->reds, mcc, tokens->num_tokens);
> +        reds_on_main_agent_tokens(reds, mcc, tokens->num_tokens);
>          break;
>      }
>      case SPICE_MSGC_MAIN_ATTACH_CHANNELS:
> @@ -583,7 +618,7 @@ static int main_channel_handle_parsed(RedChannelClient
> *rcc, uint32_t size, uint
>              ((SpiceMsgcMainMigrateDstDoSeamless *)message)->src_version);
>          break;
>      case SPICE_MSGC_MAIN_MOUSE_MODE_REQUEST:
> -        reds_on_main_mouse_mode_request(channel->reds, message, size);
> +        reds_on_main_mouse_mode_request(reds, message, size);
>          break;
>      case SPICE_MSGC_PONG: {
>          main_channel_client_handle_pong(mcc, (SpiceMsgPing *)message, size);
> @@ -605,13 +640,13 @@ static uint8_t
> *main_channel_alloc_msg_rcv_buf(RedChannelClient *rcc,
>                                                 uint32_t size)
>  {
>      RedChannel *channel = red_channel_client_get_channel(rcc);
> -    MainChannel *main_chan = SPICE_CONTAINEROF(channel, MainChannel, base);
> +    MainChannel *main_chan = MAIN_CHANNEL(channel);
>      MainChannelClient *mcc = MAIN_CHANNEL_CLIENT(rcc);
>  
>      if (type == SPICE_MSGC_MAIN_AGENT_DATA) {
> -        return reds_get_agent_data_buffer(channel->reds, mcc, size);
> +        return reds_get_agent_data_buffer(red_channel_get_server(channel),
> mcc, size);
>      } else {
> -        return main_chan->recv_buf;
> +        return main_chan->priv->recv_buf;
>      }
>  }
>  
> @@ -622,7 +657,7 @@ static void
> main_channel_release_msg_rcv_buf(RedChannelClient *rcc,
>  {
>      RedChannel *channel = red_channel_client_get_channel(rcc);
>      if (type == SPICE_MSGC_MAIN_AGENT_DATA) {
> -        reds_release_agent_data_buffer(channel->reds, msg);
> +        reds_release_agent_data_buffer(red_channel_get_server(channel),
> msg);
>      }
>  }
>  
> @@ -639,8 +674,7 @@ static int
> main_channel_handle_migrate_flush_mark(RedChannelClient *rcc)
>  {
>      RedChannel *channel = red_channel_client_get_channel(rcc);
>      spice_debug(NULL);
> -    main_channel_push_migrate_data_item(SPICE_CONTAINEROF(channel,
> -                                        MainChannel, base));
> +    main_channel_push_migrate_data_item(MAIN_CHANNEL(channel));
>      return TRUE;
>  }
>  
> @@ -665,12 +699,12 @@ MainChannelClient *main_channel_link(MainChannel
> *channel, RedClient *client,
>  
>  int main_channel_getsockname(MainChannel *main_chan, struct sockaddr *sa,
>  socklen_t *salen)
>  {
> -    return main_chan ?
> getsockname(red_channel_get_first_socket(&main_chan->base), sa, salen) : -1;
> +    return main_chan ?
> getsockname(red_channel_get_first_socket(RED_CHANNEL(main_chan)), sa, salen)
> : -1;
>  }
>  
>  int main_channel_getpeername(MainChannel *main_chan, struct sockaddr *sa,
>  socklen_t *salen)
>  {
> -    return main_chan ?
> getpeername(red_channel_get_first_socket(&main_chan->base), sa, salen) : -1;
> +    return main_chan ?
> getpeername(red_channel_get_first_socket(RED_CHANNEL(main_chan)), sa, salen)
> : -1;
>  }
>  
>  // TODO: ? shouldn't it disonnect all clients? or shutdown all
>  main_channels?
> @@ -678,79 +712,57 @@ void main_channel_close(MainChannel *main_chan)
>  {
>      int socketfd;
>  
> -    if (main_chan && (socketfd =
> red_channel_get_first_socket(&main_chan->base)) != -1) {
> +    if (main_chan && (socketfd =
> red_channel_get_first_socket(RED_CHANNEL(main_chan))) != -1) {
>          close(socketfd);
>      }
>  }
>  
>  MainChannel* main_channel_new(RedsState *reds)
>  {
> -    RedChannel *channel;
> -    ChannelCbs channel_cbs = { NULL, };
> -    ClientCbs client_cbs = {NULL, };
> -
> -    channel_cbs.config_socket = main_channel_config_socket;
> -    channel_cbs.on_disconnect = main_channel_client_on_disconnect;
> -    channel_cbs.send_item = main_channel_send_item;
> -    channel_cbs.hold_item = main_channel_hold_pipe_item;
> -    channel_cbs.release_item = main_channel_release_pipe_item;
> -    channel_cbs.alloc_recv_buf = main_channel_alloc_msg_rcv_buf;
> -    channel_cbs.release_recv_buf = main_channel_release_msg_rcv_buf;
> -    channel_cbs.handle_migrate_flush_mark =
> main_channel_handle_migrate_flush_mark;
> -    channel_cbs.handle_migrate_data = main_channel_handle_migrate_data;
> -
>      // TODO: set the migration flag of the channel
> -    channel = red_channel_create_parser(sizeof(MainChannel), reds,
> -                                        reds_get_core_interface(reds),
> -                                        SPICE_CHANNEL_MAIN, 0,
> -                                        FALSE, /* handle_acks */
> -
> spice_get_client_channel_parser(SPICE_CHANNEL_MAIN,
> NULL),
> -                                        main_channel_handle_parsed,
> -                                        &channel_cbs,
> -                                        SPICE_MIGRATE_NEED_FLUSH |
> SPICE_MIGRATE_NEED_DATA_TRANSFER);
> -    spice_assert(channel);
> -    red_channel_set_cap(channel, SPICE_MAIN_CAP_SEMI_SEAMLESS_MIGRATE);
> -    red_channel_set_cap(channel, SPICE_MAIN_CAP_SEAMLESS_MIGRATE);
> -
> -    client_cbs.migrate = main_channel_client_migrate;
> -    red_channel_register_client_cbs(channel, &client_cbs, NULL);
> -
> -    return (MainChannel *)channel;
> +    return g_object_new(TYPE_MAIN_CHANNEL,
> +                        "spice-server", reds,
> +                        "core-interface", reds_get_core_interface(reds),
> +                        "channel-type", (gint)SPICE_CHANNEL_MAIN,
> +                        "id", 0,
> +                        "handle-acks", FALSE, /* handle_acks */
> +                        "migration-flags", (SPICE_MIGRATE_NEED_FLUSH |
> SPICE_MIGRATE_NEED_DATA_TRANSFER),
> +                        NULL);
>  }
>  
>  static int main_channel_connect_semi_seamless(MainChannel *main_channel)
>  {
>      GList *link;
>  
> -    for (link = main_channel->base.clients; link != NULL; link = link->next)
> {
> +    for (link = red_channel_get_clients(RED_CHANNEL(main_channel)); link !=
> NULL; link = link->next) {
>          RedChannelClient *rcc = link->data;
>          MainChannelClient *mcc = MAIN_CHANNEL_CLIENT(rcc);
>          if (main_channel_client_connect_semi_seamless(mcc))
> -            main_channel->num_clients_mig_wait++;
> +            main_channel->priv->num_clients_mig_wait++;
>      }
> -    return main_channel->num_clients_mig_wait;
> +    return main_channel->priv->num_clients_mig_wait;
>  }
>  
>  static int main_channel_connect_seamless(MainChannel *main_channel)
>  {
>      GList *link;
>  
> -    spice_assert(g_list_length(main_channel->base.clients) == 1);
> +    spice_assert(red_channel_get_n_clients(RED_CHANNEL(main_channel)) == 1);
>  
> -    for (link = main_channel->base.clients; link != NULL; link = link->next)
> {
> +    for (link = red_channel_get_clients(RED_CHANNEL(main_channel)); link !=
> NULL; link = link->next) {
>          RedChannelClient *rcc = link->data;
>          MainChannelClient *mcc = MAIN_CHANNEL_CLIENT(rcc);
>          main_channel_client_connect_seamless(mcc);
> -        main_channel->num_clients_mig_wait++;
> +        main_channel->priv->num_clients_mig_wait++;
>      }
> -    return main_channel->num_clients_mig_wait;
> +    return main_channel->priv->num_clients_mig_wait;
>  }
>  
>  int main_channel_migrate_connect(MainChannel *main_channel, RedsMigSpice
>  *mig_target,
>                                   int try_seamless)
>  {
>      main_channel_fill_mig_target(main_channel, mig_target);
> -    main_channel->num_clients_mig_wait = 0;
> +    main_channel->priv->num_clients_mig_wait = 0;
>  
>      if (!main_channel_is_connected(main_channel)) {
>          return 0;
> @@ -760,8 +772,10 @@ int main_channel_migrate_connect(MainChannel
> *main_channel, RedsMigSpice *mig_ta
>          return main_channel_connect_semi_seamless(main_channel);
>      } else {
>          RedChannelClient *rcc;
> +        GList *clients = red_channel_get_clients(RED_CHANNEL(main_channel));
>  
> -        rcc = main_channel->base.clients->data;
> +        /* just test the first one */
> +        rcc = clients->data;
>  
>          if (!red_channel_client_test_remote_cap(rcc,
>                                                  SPICE_MAIN_CAP_SEAMLESS_MIGRATE))
>                                                  {
> @@ -777,27 +791,28 @@ void main_channel_migrate_cancel_wait(MainChannel
> *main_chan)
>  {
>      GList *link;
>  
> -    for (link = main_chan->base.clients; link != NULL; link = link->next) {
> +    for (link = red_channel_get_clients(RED_CHANNEL(main_chan)); link !=
> NULL; link = link->next) {
>          RedChannelClient *rcc = link->data;
>          MainChannelClient *mcc = MAIN_CHANNEL_CLIENT(rcc);
>          main_channel_client_migrate_cancel_wait(mcc);
>      }
> -    main_chan->num_clients_mig_wait = 0;
> +    main_chan->priv->num_clients_mig_wait = 0;
>  }
>  
>  int main_channel_migrate_src_complete(MainChannel *main_chan, int success)
>  {
>      GList *link;
> +    GList *clients = red_channel_get_clients(RED_CHANNEL(main_chan));
>      int semi_seamless_count = 0;
>  
>      spice_printerr("");
>  
> -    if (!main_chan->base.clients) {
> +    if (!clients) {
>          spice_printerr("no peer connected");
>          return 0;
>      }
>  
> -    for (link = main_chan->base.clients; link != NULL; link = link->next) {
> +    for (link = clients; link != NULL; link = link->next) {
>          RedChannelClient *rcc = link->data;
>          MainChannelClient *mcc = MAIN_CHANNEL_CLIENT(rcc);
>          if (main_channel_client_migrate_src_complete(mcc, success))
> @@ -805,3 +820,39 @@ int main_channel_migrate_src_complete(MainChannel
> *main_chan, int success)
>     }
>     return semi_seamless_count;
>  }
> +
> +void main_channel_on_migrate_connected(MainChannel *main_channel, gboolean
> seamless)
> +{
> +        g_return_if_fail(main_channel->priv->num_clients_mig_wait);
> +        g_warn_if_fail(!seamless || main_channel->priv->num_clients_mig_wait
> == 1);
> +        if (!--main_channel->priv->num_clients_mig_wait) {
> +
> reds_on_main_migrate_connected(red_channel_get_server(RED_CHANNEL(main_channel)),
> +                                           seamless);
> +        }
> +}
> +
> +static void
> +main_channel_class_init(MainChannelClass *klass)
> +{
> +    GObjectClass *object_class = G_OBJECT_CLASS(klass);
> +    RedChannelClass *channel_class = RED_CHANNEL_CLASS(klass);
> +
> +    g_type_class_add_private(klass, sizeof(MainChannelPrivate));
> +
> +    object_class->constructed = main_channel_constructed;
> +
> +    channel_class->parser =
> spice_get_client_channel_parser(SPICE_CHANNEL_MAIN, NULL);
> +    channel_class->handle_parsed = main_channel_handle_parsed;
> +
> +    /* channel callbacks */
> +    channel_class->config_socket = main_channel_config_socket;
> +    channel_class->on_disconnect = main_channel_client_on_disconnect;
> +    channel_class->send_item = main_channel_send_item;
> +    channel_class->hold_item = main_channel_hold_pipe_item;
> +    channel_class->release_item = main_channel_release_pipe_item;
> +    channel_class->alloc_recv_buf = main_channel_alloc_msg_rcv_buf;
> +    channel_class->release_recv_buf = main_channel_release_msg_rcv_buf;
> +    channel_class->handle_migrate_flush_mark =
> main_channel_handle_migrate_flush_mark;
> +    channel_class->handle_migrate_data = main_channel_handle_migrate_data;
> +}
> +
> diff --git a/server/main-channel.h b/server/main-channel.h
> index 43a2679..ce67241 100644
> --- a/server/main-channel.h
> +++ b/server/main-channel.h
> @@ -18,21 +18,47 @@
>  #ifndef __MAIN_CHANNEL_H__
>  #define __MAIN_CHANNEL_H__
>  
> +#include <glib-object.h>
>  #include <stdint.h>
>  #include <spice/vd_agent.h>
> +
>  #include "common/marshaller.h"
>  #include "red-channel.h"
>  #include "main-channel-client.h"
>  
> +G_BEGIN_DECLS
> +
> +#define TYPE_MAIN_CHANNEL main_channel_get_type()
> +
> +#define MAIN_CHANNEL(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),
> TYPE_MAIN_CHANNEL, MainChannel))
> +#define MAIN_CHANNEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),
> TYPE_MAIN_CHANNEL, MainChannelClass))
> +#define IS_MAIN_CHANNEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),
> TYPE_MAIN_CHANNEL))
> +#define IS_MAIN_CHANNEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),
> TYPE_MAIN_CHANNEL))
> +#define MAIN_CHANNEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj),
> TYPE_MAIN_CHANNEL, MainChannelClass))
> +
> +typedef struct MainChannel MainChannel;
> +typedef struct MainChannelClass MainChannelClass;
> +typedef struct MainChannelPrivate MainChannelPrivate;
> +
> +struct MainChannel
> +{
> +    RedChannel parent;
> +
> +    MainChannelPrivate *priv;
> +};
> +
> +struct MainChannelClass
> +{
> +    RedChannelClass parent_class;
> +};
> +
> +GType main_channel_get_type(void) G_GNUC_CONST;
> +
>  // TODO: Defines used to calculate receive buffer size, and also by reds.c
>  // other options: is to make a reds_main_consts.h, to duplicate defines.
>  #define REDS_AGENT_WINDOW_SIZE 10
>  #define REDS_NUM_INTERNAL_AGENT_MESSAGES 1
>  
> -// approximate max receive message size for main channel
> -#define MAIN_CHANNEL_RECEIVE_BUF_SIZE \
> -    (4096 + (REDS_AGENT_WINDOW_SIZE + REDS_NUM_INTERNAL_AGENT_MESSAGES) *
> SPICE_AGENT_MAX_DATA_SIZE)
> -
>  struct RedsMigSpice {
>      char *host;
>      char *cert_subject;
> @@ -41,13 +67,6 @@ struct RedsMigSpice {
>  };
>  typedef struct RedsMigSpice RedsMigSpice;
>  
> -typedef struct MainChannel {
> -    RedChannel base;
> -    uint8_t recv_buf[MAIN_CHANNEL_RECEIVE_BUF_SIZE];
> -    RedsMigSpice mig_target; // TODO: add refs and release (afrer all
> clients completed migration in one way or the other?)
> -    int num_clients_mig_wait;
> -} MainChannel;
> -
>  
>  MainChannel *main_channel_new(RedsState *reds);
>  RedClient *main_channel_get_client_by_link_id(MainChannel *main_chan,
>  uint32_t link_id);
> @@ -77,5 +96,8 @@ int main_channel_migrate_connect(MainChannel *main_channel,
> RedsMigSpice *mig_ta
>  void main_channel_migrate_cancel_wait(MainChannel *main_chan);
>  /* returns the number of clients for which SPICE_MSG_MAIN_MIGRATE_END was
>  sent*/
>  int main_channel_migrate_src_complete(MainChannel *main_chan, int success);
> +void main_channel_on_migrate_connected(MainChannel *main_channel, gboolean
> seamless);
> +
> +G_END_DECLS
>  
>  #endif
> diff --git a/server/red-channel-client-private.h
> b/server/red-channel-client-private.h
> index c7009fe..7fe54d0 100644
> --- a/server/red-channel-client-private.h
> +++ b/server/red-channel-client-private.h
> @@ -21,6 +21,25 @@
>  #include "red-channel-client.h"
>  #include "red-channel.h"
>  
> +typedef struct RedChannelClientLatencyMonitor {
> +    int state;
> +    uint64_t last_pong_time;
> +    SpiceTimer *timer;
> +    uint32_t id;
> +    int tcp_nodelay;
> +    int warmup_was_sent;
> +
> +    int64_t roundtrip;
> +} RedChannelClientLatencyMonitor;
> +
> +typedef struct RedChannelClientConnectivityMonitor {
> +    int state;
> +    uint32_t out_bytes;
> +    uint32_t in_bytes;
> +    uint32_t timeout;
> +    SpiceTimer *timer;
> +} RedChannelClientConnectivityMonitor;
> +
>  struct RedChannelClientPrivate {
>      RedChannel *channel;
>      RedClient  *client;
> diff --git a/server/red-channel-client.c b/server/red-channel-client.c
> index 1c0339b..5e937b6 100644
> --- a/server/red-channel-client.c
> +++ b/server/red-channel-client.c
> @@ -158,6 +158,8 @@ static const SpiceDataHeaderOpaque mini_header_wrapper =
> {NULL, sizeof(SpiceMini
>  
>  static void red_channel_client_start_ping_timer(RedChannelClient *rcc,
>  uint32_t timeout)
>  {
> +    SpiceCoreInterfaceInternal *core;
> +
>      if (!rcc->priv->latency_monitor.timer) {
>          return;
>      }
> @@ -165,11 +167,15 @@ static void
> red_channel_client_start_ping_timer(RedChannelClient *rcc, uint32_t
>          return;
>      }
>      rcc->priv->latency_monitor.state = PING_STATE_TIMER;
> -    rcc->priv->channel->core->timer_start(rcc->priv->latency_monitor.timer,
> timeout);
> +
> +    core = red_channel_get_core_interface(rcc->priv->channel);
> +    core->timer_start(rcc->priv->latency_monitor.timer, timeout);
>  }
>  
>  static void red_channel_client_cancel_ping_timer(RedChannelClient *rcc)
>  {
> +    SpiceCoreInterfaceInternal *core;
> +
>      if (!rcc->priv->latency_monitor.timer) {
>          return;
>      }
> @@ -177,7 +183,8 @@ static void
> red_channel_client_cancel_ping_timer(RedChannelClient *rcc)
>          return;
>      }
>  
> -
> rcc->priv->channel->core->timer_cancel(rcc->priv->latency_monitor.timer);
> +    core = red_channel_get_core_interface(rcc->priv->channel);
> +    core->timer_cancel(rcc->priv->latency_monitor.timer);
>      rcc->priv->latency_monitor.state = PING_STATE_NONE;
>  }
>  
> @@ -252,10 +259,10 @@ red_channel_client_set_property(GObject *object,
>              break;
>          case PROP_CHANNEL:
>              if (self->priv->channel)
> -                red_channel_unref(self->priv->channel);
> +                g_object_unref(self->priv->channel);
>              self->priv->channel = g_value_get_pointer(value);
>              if (self->priv->channel)
> -                red_channel_ref(self->priv->channel);
> +                g_object_ref(self->priv->channel);
>              break;
>          case PROP_CLIENT:
>              self->priv->client = g_value_get_pointer(value);
> @@ -312,7 +319,7 @@ red_channel_client_finalize(GObject *object)
>  
>      red_channel_client_destroy_remote_caps(self);
>      if (self->priv->channel) {
> -        red_channel_unref(self->priv->channel);
> +        g_object_unref(self->priv->channel);
>      }
>  
>      G_OBJECT_CLASS(red_channel_client_parent_class)->finalize(object);
> @@ -438,7 +445,6 @@ void red_channel_client_on_output(void *opaque, int n)
>      if (rcc->priv->connectivity_monitor.timer) {
>          rcc->priv->connectivity_monitor.out_bytes += n;
>      }
> -    stat_inc_counter(reds, rcc->priv->channel->out_bytes_counter, n);
>  }
>  
>  void red_channel_client_on_input(void *opaque, int n)
> @@ -468,12 +474,14 @@ void red_channel_client_prepare_out_msg(void *opaque,
> struct iovec *vec,
>  
>  void red_channel_client_on_out_block(void *opaque)
>  {
> +    SpiceCoreInterfaceInternal *core;
>      RedChannelClient *rcc = (RedChannelClient *)opaque;
>  
>      rcc->priv->send_data.blocked = TRUE;
> -    rcc->priv->channel->core->watch_update_mask(rcc->priv->stream->watch,
> -                                                SPICE_WATCH_EVENT_READ |
> -                                                SPICE_WATCH_EVENT_WRITE);
> +    core = red_channel_get_core_interface(rcc->priv->channel);
> +    core->watch_update_mask(rcc->priv->stream->watch,
> +                            SPICE_WATCH_EVENT_READ |
> +                            SPICE_WATCH_EVENT_WRITE);
>  }
>  
>  static inline int
>  red_channel_client_urgent_marshaller_is_active(RedChannelClient *rcc)
> @@ -533,9 +541,9 @@ static void
> red_channel_client_send_migrate(RedChannelClient *rcc)
>      SpiceMsgMigrate migrate;
>  
>      red_channel_client_init_send_data(rcc, SPICE_MSG_MIGRATE, NULL);
> -    migrate.flags = rcc->priv->channel->migration_flags;
> +    g_object_get(rcc->priv->channel, "migration-flags", &migrate.flags,
> NULL);
>      spice_marshall_msg_migrate(rcc->priv->send_data.marshaller, &migrate);
> -    if (rcc->priv->channel->migration_flags & SPICE_MIGRATE_NEED_FLUSH) {
> +    if (migrate.flags & SPICE_MIGRATE_NEED_FLUSH) {
>          rcc->priv->wait_migrate_flush_mark = TRUE;
>      }
>  
> @@ -607,7 +615,7 @@ static void red_channel_client_send_item(RedChannelClient
> *rcc, RedPipeItem *ite
>              red_channel_client_send_ping(rcc);
>              break;
>          default:
> -            rcc->priv->channel->channel_cbs.send_item(rcc, item);
> +            red_channel_send_item(rcc->priv->channel, rcc, item);
>              return;
>      }
>      free(item);
> @@ -625,7 +633,7 @@ static void
> red_channel_client_release_item(RedChannelClient *rcc,
>              free(item);
>              break;
>          default:
> -            rcc->priv->channel->channel_cbs.release_item(rcc, item,
> item_pushed);
> +            red_channel_release_item(rcc->priv->channel, rcc, item,
> item_pushed);
>      }
>  }
>  
> @@ -670,9 +678,10 @@ void red_channel_client_on_out_msg_done(void *opaque)
>  
>      red_channel_client_release_sent_item(rcc);
>      if (rcc->priv->send_data.blocked) {
> +        SpiceCoreInterfaceInternal *core =
> red_channel_get_core_interface(rcc->priv->channel);
>          rcc->priv->send_data.blocked = FALSE;
> -
> rcc->priv->channel->core->watch_update_mask(rcc->priv->stream->watch,
> -                                                    SPICE_WATCH_EVENT_READ);
> +        core->watch_update_mask(rcc->priv->stream->watch,
> +                                SPICE_WATCH_EVENT_READ);
>      }
>  
>      if (red_channel_client_urgent_marshaller_is_active(rcc)) {
> @@ -750,8 +759,13 @@ static void red_channel_client_ping_timer(void *opaque)
>  
>  static inline int red_channel_client_waiting_for_ack(RedChannelClient *rcc)
>  {
> -    return (rcc->priv->channel->handle_acks &&
> -            (rcc->priv->ack_data.messages_window >
> rcc->priv->ack_data.client_window * 2));
> +    gboolean handle_acks;
> +    g_object_get(rcc->priv->channel,
> +                 "handle-acks", &handle_acks,
> +                 NULL);
> +
> +    return (handle_acks && (rcc->priv->ack_data.messages_window >
> +                            rcc->priv->ack_data.client_window * 2));
>  }
>  
>  /*
> @@ -792,6 +806,7 @@ static void red_channel_client_connectivity_timer(void
> *opaque)
>      }
>  
>      if (is_alive) {
> +        SpiceCoreInterfaceInternal *core =
> red_channel_get_core_interface(rcc->priv->channel);
>          monitor->in_bytes = 0;
>          monitor->out_bytes = 0;
>          if (rcc->priv->send_data.blocked ||
>          red_channel_client_waiting_for_ack(rcc)) {
> @@ -802,18 +817,24 @@ static void red_channel_client_connectivity_timer(void
> *opaque)
>          } else {
>               monitor->state = CONNECTIVITY_STATE_CONNECTED;
>          }
> -
> rcc->priv->channel->core->timer_start(rcc->priv->connectivity_monitor.timer,
> +        core->timer_start(rcc->priv->connectivity_monitor.timer,
>                                                rcc->priv->connectivity_monitor.timeout);
>      } else {
> +        uint32_t type, id;
> +        g_object_get(rcc->priv->channel,
> +                     "channel-type", &type,
> +                     "id", &id,
> +                     NULL);
>          monitor->state = CONNECTIVITY_STATE_DISCONNECTED;
>          spice_warning("rcc %p on channel %d:%d has been unresponsive for
>          more than %u ms, disconnecting",
> -                      rcc, rcc->priv->channel->type, rcc->priv->channel->id,
> monitor->timeout);
> +                      rcc, type, id, monitor->timeout);
>          red_channel_client_disconnect(rcc);
>      }
>  }
>  
>  void red_channel_client_start_connectivity_monitoring(RedChannelClient *rcc,
>  uint32_t timeout_ms)
>  {
> +    SpiceCoreInterfaceInternal *core =
> red_channel_get_core_interface(rcc->priv->channel);
>      if (!red_channel_client_is_connected(rcc)) {
>          return;
>      }
> @@ -826,8 +847,8 @@ void
> red_channel_client_start_connectivity_monitoring(RedChannelClient *rcc, uin
>       * on this channel.
>       */
>      if (rcc->priv->latency_monitor.timer == NULL) {
> -        rcc->priv->latency_monitor.timer =
> rcc->priv->channel->core->timer_add(
> -            rcc->priv->channel->core, red_channel_client_ping_timer, rcc);
> +        rcc->priv->latency_monitor.timer = core->timer_add(
> +            core, red_channel_client_ping_timer, rcc);
>          if (!red_client_during_migrate_at_target(rcc->priv->client)) {
>              red_channel_client_start_ping_timer(rcc,
>              PING_TEST_IDLE_NET_TIMEOUT_MS);
>          }
> @@ -835,12 +856,12 @@ void
> red_channel_client_start_connectivity_monitoring(RedChannelClient *rcc, uin
>      }
>      if (rcc->priv->connectivity_monitor.timer == NULL) {
>          rcc->priv->connectivity_monitor.state =
>          CONNECTIVITY_STATE_CONNECTED;
> -        rcc->priv->connectivity_monitor.timer =
> rcc->priv->channel->core->timer_add(
> -            rcc->priv->channel->core, red_channel_client_connectivity_timer,
> rcc);
> +        rcc->priv->connectivity_monitor.timer = core->timer_add(
> +            core, red_channel_client_connectivity_timer, rcc);
>          rcc->priv->connectivity_monitor.timeout = timeout_ms;
>          if (!red_client_during_migrate_at_target(rcc->priv->client)) {
> -
> rcc->priv->channel->core->timer_start(rcc->priv->connectivity_monitor.timer,
> -
> rcc->priv->connectivity_monitor.timeout);
> +            core->timer_start(rcc->priv->connectivity_monitor.timer,
> +                              rcc->priv->connectivity_monitor.timeout);
>          }
>      }
>  }
> @@ -861,9 +882,11 @@ static void red_channel_client_event(int fd, int event,
> void *data)
>  
>  static int red_channel_client_pre_create_validate(RedChannel *channel,
>  RedClient  *client)
>  {
> -    if (red_client_get_channel(client, channel->type, channel->id)) {
> +    uint32_t type, id;
> +    g_object_get(channel, "channel-type", &type, "id", &id, NULL);
> +    if (red_client_get_channel(client, type, id)) {
>          spice_printerr("Error client %p: duplicate channel type %d id %d",
> -                       client, channel->type, channel->id);
> +                       client, type, id);
>          return FALSE;
>      }
>      return TRUE;
> @@ -874,24 +897,28 @@ static gboolean
> red_channel_client_initable_init(GInitable *initable,
>                                                   GError **error)
>  {
>      GError *local_error = NULL;
> +    SpiceCoreInterfaceInternal *core;
>      RedChannelClient *self = RED_CHANNEL_CLIENT(initable);
>      pthread_mutex_lock(&self->priv->client->lock);
>      if (!red_channel_client_pre_create_validate(self->priv->channel,
>      self->priv->client)) {
> +        uint32_t id, type;
> +        g_object_get(self->priv->channel,
> +                     "channel-type", &type,
> +                     "id", &id,
> +                     NULL);
>          g_set_error(&local_error,
>                      SPICE_SERVER_ERROR,
>                      SPICE_SERVER_ERROR_FAILED,
>                      "Client %p: duplicate channel type %d id %d",
> -                    self->priv->client, self->priv->channel->type,
> -                    self->priv->channel->id);
> +                    self->priv->client, type, id);
>          goto cleanup;
>      }
>  
> +    core = red_channel_get_core_interface(self->priv->channel);
>      if (self->priv->monitor_latency
>          && reds_stream_get_family(self->priv->stream) != AF_UNIX) {
>          self->priv->latency_monitor.timer =
> -            self->priv->channel->core->timer_add(self->priv->channel->core,
> -
> red_channel_client_ping_timer,
> -                                                 self);
> +            core->timer_add(core, red_channel_client_ping_timer, self);
>  
>          if (!self->priv->client->during_target_migrate) {
>              red_channel_client_start_ping_timer(self,
> @@ -901,27 +928,26 @@ static gboolean
> red_channel_client_initable_init(GInitable *initable,
>      }
>  
>      self->incoming.opaque = self;
> -    self->incoming.cb = &self->priv->channel->incoming_cb;
> +    self->incoming.cb =
> red_channel_get_incoming_handler(self->priv->channel);
>      self->incoming.header.data = self->incoming.header_buf;
>      self->incoming.serial = 1;
>  
>      self->outgoing.opaque = self;
> -    self->outgoing.cb = &self->priv->channel->outgoing_cb;
> +    self->outgoing.cb =
> red_channel_get_outgoing_handler(self->priv->channel);
>      self->outgoing.pos = 0;
>      self->outgoing.size = 0;
>  
>      if (self->priv->stream)
>          self->priv->stream->watch =
> -            self->priv->channel->core->watch_add(self->priv->channel->core,
> -                                                 self->priv->stream->socket,
> -                                                 SPICE_WATCH_EVENT_READ,
> -                                                 red_channel_client_event,
> -                                                 self);
> -    self->priv->id = self->priv->channel->clients_num;
> +            core->watch_add(core, self->priv->stream->socket,
> +                            SPICE_WATCH_EVENT_READ,
> +                            red_channel_client_event,
> +                            self);
> +    self->priv->id = red_channel_get_n_clients(self->priv->channel);
>      red_channel_add_client(self->priv->channel, self);
>      red_client_add_channel(self->priv->client, self);
>  
> -    if (!self->priv->channel->channel_cbs.config_socket(self)) {
> +    if (!red_channel_config_socket(self->priv->channel, self)) {
>          g_set_error_literal(&local_error,
>                              SPICE_SERVER_ERROR,
>                              SPICE_SERVER_ERROR_FAILED,
> @@ -981,8 +1007,9 @@ void
> red_channel_client_seamless_migration_done(RedChannelClient *rcc)
>              red_channel_client_start_ping_timer(rcc,
>              PING_TEST_IDLE_NET_TIMEOUT_MS);
>          }
>          if (rcc->priv->connectivity_monitor.timer) {
> -
> rcc->priv->channel->core->timer_start(rcc->priv->connectivity_monitor.timer,
> -
> rcc->priv->connectivity_monitor.timeout);
> +            SpiceCoreInterfaceInternal *core =
> red_channel_get_core_interface(rcc->priv->channel);
> +            core->timer_start(rcc->priv->connectivity_monitor.timer,
> +                              rcc->priv->connectivity_monitor.timeout);
>          }
>      }
>  }
> @@ -1001,13 +1028,14 @@ int
> red_channel_client_is_waiting_for_migrate_data(RedChannelClient *rcc)
>  
>  void red_channel_client_default_migrate(RedChannelClient *rcc)
>  {
> +    SpiceCoreInterfaceInternal *core =
> red_channel_get_core_interface(rcc->priv->channel);
>      if (rcc->priv->latency_monitor.timer) {
>          red_channel_client_cancel_ping_timer(rcc);
> -
> rcc->priv->channel->core->timer_remove(rcc->priv->latency_monitor.timer);
> +        core->timer_remove(rcc->priv->latency_monitor.timer);
>          rcc->priv->latency_monitor.timer = NULL;
>      }
>      if (rcc->priv->connectivity_monitor.timer) {
> -
> rcc->priv->channel->core->timer_remove(rcc->priv->connectivity_monitor.timer);
> +        core->timer_remove(rcc->priv->connectivity_monitor.timer);
>          rcc->priv->connectivity_monitor.timer = NULL;
>      }
>      red_channel_client_pipe_add_type(rcc, RED_PIPE_ITEM_TYPE_MIGRATE);
> @@ -1024,7 +1052,8 @@ void red_channel_client_destroy(RedChannelClient *rcc)
>  void red_channel_client_shutdown(RedChannelClient *rcc)
>  {
>      if (rcc->priv->stream && !rcc->priv->stream->shutdown) {
> -        rcc->priv->channel->core->watch_remove(rcc->priv->stream->watch);
> +        SpiceCoreInterfaceInternal *core =
> red_channel_get_core_interface(rcc->priv->channel);
> +        core->watch_remove(rcc->priv->stream->watch);
>          rcc->priv->stream->watch = NULL;
>          shutdown(rcc->priv->stream->socket, SHUT_RDWR);
>          rcc->priv->stream->shutdown = TRUE;
> @@ -1259,8 +1288,10 @@ void red_channel_client_push(RedChannelClient *rcc)
>      }
>      if (red_channel_client_no_item_being_sent(rcc) &&
>      ring_is_empty(&rcc->priv->pipe)
>          && rcc->priv->stream->watch) {
> -
> rcc->priv->channel->core->watch_update_mask(rcc->priv->stream->watch,
> -                                              SPICE_WATCH_EVENT_READ);
> +        SpiceCoreInterfaceInternal *core;
> +        core = red_channel_get_core_interface(rcc->priv->channel);
> +        core->watch_update_mask(rcc->priv->stream->watch,
> +                                SPICE_WATCH_EVENT_READ);
>      }
>      rcc->priv->during_send = FALSE;
>      g_object_unref(rcc);
> @@ -1331,11 +1362,12 @@ static void
> red_channel_client_handle_pong(RedChannelClient *rcc, SpiceMsgPing *
>      red_channel_client_start_ping_timer(rcc, PING_TEST_TIMEOUT_MS);
>  }
>  
> -static void red_channel_handle_migrate_flush_mark(RedChannelClient *rcc)
> +static void red_channel_client_handle_migrate_flush_mark(RedChannelClient
> *rcc)
>  {
>      RedChannel *channel = red_channel_client_get_channel(rcc);
> -    if (channel->channel_cbs.handle_migrate_flush_mark) {
> -        channel->channel_cbs.handle_migrate_flush_mark(rcc);
> +    RedChannelClass *klass = RED_CHANNEL_GET_CLASS(channel);
> +    if (klass->handle_migrate_flush_mark) {
> +        klass->handle_migrate_flush_mark(rcc);
>      }
>  }
>  
> @@ -1346,23 +1378,30 @@ static void
> red_channel_handle_migrate_flush_mark(RedChannelClient *rcc)
>  //  3) source migrates to target
>  //  4) target sends data to all
>  // So need to make all the handlers work with per channel/client data (what
>  data exactly?)
> -static void red_channel_handle_migrate_data(RedChannelClient *rcc, uint32_t
> size, void *message)
> +static void red_channel_client_handle_migrate_data(RedChannelClient *rcc,
> +                                                   uint32_t size,
> +                                                   void
> +                                                   *message)
>  {
>      RedChannel *channel = red_channel_client_get_channel(rcc);
> +    RedChannelClass *klass = RED_CHANNEL_GET_CLASS(channel);
> +    uint32_t type, id;
> +
> +    g_object_get(channel, "channel-type", &type, "id", &id, NULL);
>      spice_debug("channel type %d id %d rcc %p size %u",
> -                channel->type, channel->id, rcc, size);
> -    if (!channel->channel_cbs.handle_migrate_data) {
> +                type, id, rcc, size);
> +    if (!klass->handle_migrate_data) {
>          return;
>      }
>      if (!red_channel_client_is_waiting_for_migrate_data(rcc)) {
>          spice_channel_client_error(rcc, "unexpected");
>          return;
>      }
> -    if (channel->channel_cbs.handle_migrate_data_get_serial) {
> +    if (klass->handle_migrate_data_get_serial) {
>          red_channel_client_set_message_serial(rcc,
> -            channel->channel_cbs.handle_migrate_data_get_serial(rcc, size,
> message));
> +            klass->handle_migrate_data_get_serial(rcc, size, message));
>      }
> -    if (!channel->channel_cbs.handle_migrate_data(rcc, size, message)) {
> +    if (!klass->handle_migrate_data(rcc, size, message)) {
>          spice_channel_client_error(rcc, "handle_migrate_data failed");
>          return;
>      }
> @@ -1394,11 +1433,11 @@ int
> red_channel_client_handle_message(RedChannelClient *rcc, uint32_t size,
>              spice_error("unexpected flush mark");
>              return FALSE;
>          }
> -        red_channel_handle_migrate_flush_mark(rcc);
> +        red_channel_client_handle_migrate_flush_mark(rcc);
>          rcc->priv->wait_migrate_flush_mark = FALSE;
>          break;
>      case SPICE_MSGC_MIGRATE_DATA:
> -        red_channel_handle_migrate_data(rcc, size, message);
> +        red_channel_client_handle_migrate_data(rcc, size, message);
>          break;
>      case SPICE_MSGC_PONG:
>          red_channel_client_handle_pong(rcc, message);
> @@ -1417,7 +1456,7 @@ void red_channel_client_init_send_data(RedChannelClient
> *rcc, uint16_t msg_type,
>      rcc->priv->send_data.header.set_msg_type(&rcc->priv->send_data.header,
>      msg_type);
>      rcc->priv->send_data.item = item;
>      if (item) {
> -        rcc->priv->channel->channel_cbs.hold_item(rcc, item);
> +        red_channel_hold_item(rcc->priv->channel, rcc, item);
>      }
>  }
>  
> @@ -1477,9 +1516,10 @@ static inline gboolean
> client_pipe_add(RedChannelClient *rcc, RedPipeItem *item,
>          return FALSE;
>      }
>      if (ring_is_empty(&rcc->priv->pipe) && rcc->priv->stream->watch) {
> -
> rcc->priv->channel->core->watch_update_mask(rcc->priv->stream->watch,
> -                                         SPICE_WATCH_EVENT_READ |
> -                                         SPICE_WATCH_EVENT_WRITE);
> +        SpiceCoreInterfaceInternal *core;
> +        core = red_channel_get_core_interface(rcc->priv->channel);
> +        core->watch_update_mask(rcc->priv->stream->watch,
> +                                SPICE_WATCH_EVENT_READ |
> SPICE_WATCH_EVENT_WRITE);
>      }
>      rcc->priv->pipe_size++;
>      ring_add(pos, &item->link);
> @@ -1558,7 +1598,7 @@ uint32_t
> red_channel_client_get_pipe_size(RedChannelClient *rcc)
>  static gboolean red_channel_client_default_is_connected(RedChannelClient
>  *rcc)
>  {
>      return rcc->priv->channel
> -        && (g_list_find(rcc->priv->channel->clients, rcc) != NULL);
> +        && (g_list_find(red_channel_get_clients(rcc->priv->channel), rcc) !=
> NULL);
>  }
>  
>  gboolean red_channel_client_is_connected(RedChannelClient *rcc)
> @@ -1611,27 +1651,30 @@ void red_channel_client_push_set_ack(RedChannelClient
> *rcc)
>  static void red_channel_client_default_disconnect(RedChannelClient *rcc)
>  {
>      RedChannel *channel = rcc->priv->channel;
> +    SpiceCoreInterfaceInternal *core =
> red_channel_get_core_interface(channel);
> +    uint32_t type, id;
>  
>      if (!red_channel_client_is_connected(rcc)) {
>          return;
>      }
> +    g_object_get(channel, "channel-type", &type, "id", &id, NULL);
>      spice_printerr("rcc=%p (channel=%p type=%d id=%d)", rcc, channel,
> -                   channel->type, channel->id);
> +                   type, id);
>      red_channel_client_pipe_clear(rcc);
>      if (rcc->priv->stream->watch) {
> -        channel->core->watch_remove(rcc->priv->stream->watch);
> +        core->watch_remove(rcc->priv->stream->watch);
>          rcc->priv->stream->watch = NULL;
>      }
>      if (rcc->priv->latency_monitor.timer) {
> -        channel->core->timer_remove(rcc->priv->latency_monitor.timer);
> +        core->timer_remove(rcc->priv->latency_monitor.timer);
>          rcc->priv->latency_monitor.timer = NULL;
>      }
>      if (rcc->priv->connectivity_monitor.timer) {
> -        channel->core->timer_remove(rcc->priv->connectivity_monitor.timer);
> +        core->timer_remove(rcc->priv->connectivity_monitor.timer);
>          rcc->priv->connectivity_monitor.timer = NULL;
>      }
>      red_channel_remove_client(channel, rcc);
> -    channel->channel_cbs.on_disconnect(rcc);
> +    red_channel_on_disconnect(channel, rcc);
>  }
>  
>  void red_channel_client_disconnect(RedChannelClient *rcc)
> @@ -1688,7 +1731,7 @@ int
> red_channel_client_wait_pipe_item_sent(RedChannelClient *rcc,
>          end_time = UINT64_MAX;
>      }
>  
> -    rcc->priv->channel->channel_cbs.hold_item(rcc, item);
> +    red_channel_hold_item(rcc->priv->channel, rcc, item);
>  
>      if (red_channel_client_is_blocked(rcc)) {
>          red_channel_client_receive(rcc);
> @@ -1771,13 +1814,19 @@ void
> red_channel_client_pipe_remove_and_release(RedChannelClient *rcc,
>  gboolean red_channel_client_set_migration_seamless(RedChannelClient *rcc)
>  {
>      gboolean ret = FALSE;
> -
> -    if (rcc->priv->channel->migration_flags &
> SPICE_MIGRATE_NEED_DATA_TRANSFER) {
> +    uint32_t type, id, flags;
> +
> +    g_object_get(rcc->priv->channel,
> +                 "channel-type", &type,
> +                 "id", &id,
> +                 "migration-flags", &flags,
> +                 NULL);
> +    if (flags & SPICE_MIGRATE_NEED_DATA_TRANSFER) {
>          rcc->priv->wait_migrate_data = TRUE;
>          ret = TRUE;
>      }
> -    spice_debug("channel type %d id %d rcc %p wait data %d",
> rcc->priv->channel->type, rcc->priv->channel->id, rcc,
> -        rcc->priv->wait_migrate_data);
> +    spice_debug("channel type %d id %d rcc %p wait data %d", type, id, rcc,
> +                rcc->priv->wait_migrate_data);
>  
>      return ret;
>  }
> diff --git a/server/red-channel-client.h b/server/red-channel-client.h
> index d8cc317..6649485 100644
> --- a/server/red-channel-client.h
> +++ b/server/red-channel-client.h
> @@ -46,10 +46,10 @@ G_BEGIN_DECLS
>  #define RED_IS_CHANNEL_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),
>  RED_TYPE_CHANNEL_CLIENT))
>  #define RED_CHANNEL_CLIENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj),
>  RED_TYPE_CHANNEL_CLIENT, RedChannelClientClass))
>  
> -typedef struct RedChannel RedChannel;
>  typedef struct RedClient RedClient;
>  typedef struct IncomingHandler IncomingHandler;
>  
> +typedef struct RedChannel RedChannel;
>  typedef struct RedChannelClient RedChannelClient;
>  typedef struct RedChannelClientClass RedChannelClientClass;
>  typedef struct RedChannelClientPrivate RedChannelClientPrivate;
> @@ -161,8 +161,10 @@ GType red_channel_client_get_type(void) G_GNUC_CONST;
>  #define spice_channel_client_error(rcc, format, ...)
>  \
>      do {
>      \
>          RedChannel *_ch = red_channel_client_get_channel(rcc);
>          \
> +        uint32_t _type, _id;
> \
> +        g_object_get(_ch, "channel-type", &_type, "id", &_id, NULL);
> \
>          spice_warning("rcc %p type %u id %u: " format, rcc,
>          \
> -                    _ch->type, _ch->id, ## __VA_ARGS__);
> \
> +                    type, id, ## __VA_ARGS__);
> \
>          red_channel_client_shutdown(rcc);
>          \
>      } while (0)
>  
> diff --git a/server/red-channel.c b/server/red-channel.c
> index c714d90..df865f0 100644
> --- a/server/red-channel.c
> +++ b/server/red-channel.c
> @@ -65,9 +65,135 @@
>   * from the channel's thread.
>  */
>  
> -void red_channel_receive(RedChannel *channel)
> +G_DEFINE_ABSTRACT_TYPE(RedChannel, red_channel, G_TYPE_OBJECT)
> +
> +#define CHANNEL_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o),
> RED_TYPE_CHANNEL, RedChannelPrivate))
> +
> +struct RedChannelPrivate
> +{
> +    uint32_t type;
> +    uint32_t id;
> +
> +    SpiceCoreInterfaceInternal *core;
> +    gboolean handle_acks;
> +
> +    // RedChannel will hold only connected channel clients (logic - when
> pushing pipe item to all channel clients, there
> +    // is no need to go over disconnect clients)
> +    // . While client will hold the channel clients till it is destroyed
> +    // and then it will destroy them as well.
> +    // However RCC still holds a reference to the Channel.
> +    // Maybe replace these logic with ref count?
> +    // TODO: rename to 'connected_clients'?
> +    GList *clients;
> +
> +    RedChannelCapabilities local_caps;
> +    uint32_t migration_flags;
> +
> +    void *data;
> +
> +    OutgoingHandlerInterface outgoing_cb;
> +    IncomingHandlerInterface incoming_cb;
> +
> +    ClientCbs client_cbs;
> +    // TODO: when different channel_clients are in different threads from
> Channel -> need to protect!
> +    pthread_t thread_id;
> +    RedsState *reds;
> +#ifdef RED_STATISTICS
> +    StatNodeRef stat;
> +    uint64_t *out_bytes_counter;
> +#endif
> +};
> +
> +enum {
> +    PROP0,
> +    PROP_SPICE_SERVER,
> +    PROP_CORE_INTERFACE,
> +    PROP_TYPE,
> +    PROP_ID,
> +    PROP_HANDLE_ACKS,
> +    PROP_MIGRATION_FLAGS
> +};
> +
> +static void
> +red_channel_get_property(GObject *object,
> +                         guint property_id,
> +                         GValue *value,
> +                         GParamSpec *pspec)
>  {
> -    g_list_foreach(channel->clients, (GFunc)red_channel_client_receive,
> NULL);
> +    RedChannel *self = RED_CHANNEL(object);
> +
> +    switch (property_id)
> +    {
> +        case PROP_SPICE_SERVER:
> +            g_value_set_pointer(value, self->priv->reds);
> +            break;
> +        case PROP_CORE_INTERFACE:
> +            g_value_set_pointer(value, self->priv->core);
> +            break;
> +        case PROP_TYPE:
> +            g_value_set_int(value, self->priv->type);
> +            break;
> +        case PROP_ID:
> +            g_value_set_uint(value, self->priv->id);
> +            break;
> +        case PROP_HANDLE_ACKS:
> +            g_value_set_boolean(value, self->priv->handle_acks);
> +            break;
> +        case PROP_MIGRATION_FLAGS:
> +            g_value_set_uint(value, self->priv->migration_flags);
> +            break;
> +        default:
> +            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
> +    }
> +}
> +
> +static void
> +red_channel_set_property(GObject *object,
> +                         guint property_id,
> +                         const GValue *value,
> +                         GParamSpec *pspec)
> +{
> +    RedChannel *self = RED_CHANNEL(object);
> +
> +    switch (property_id)
> +    {
> +        case PROP_SPICE_SERVER:
> +            self->priv->reds = g_value_get_pointer(value);
> +            break;
> +        case PROP_CORE_INTERFACE:
> +            self->priv->core = g_value_get_pointer(value);
> +            break;
> +        case PROP_TYPE:
> +            self->priv->type = g_value_get_int(value);
> +            break;
> +        case PROP_ID:
> +            self->priv->id = g_value_get_uint(value);
> +            break;
> +        case PROP_HANDLE_ACKS:
> +            self->priv->handle_acks = g_value_get_boolean(value);
> +            break;
> +        case PROP_MIGRATION_FLAGS:
> +            self->priv->migration_flags = g_value_get_uint(value);
> +            break;
> +        default:
> +            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
> +    }
> +}
> +
> +static void
> +red_channel_finalize(GObject *object)
> +{
> +    RedChannel *self = RED_CHANNEL(object);
> +
> +    if (self->priv->local_caps.num_common_caps) {
> +        free(self->priv->local_caps.common_caps);
> +    }
> +
> +    if (self->priv->local_caps.num_caps) {
> +        free(self->priv->local_caps.caps);
> +    }
> +
> +    G_OBJECT_CLASS(red_channel_parent_class)->finalize(object);
>  }
>  
>  static void red_channel_client_default_peer_on_error(RedChannelClient *rcc)
> @@ -75,17 +201,170 @@ static void
> red_channel_client_default_peer_on_error(RedChannelClient *rcc)
>      red_channel_client_disconnect(rcc);
>  }
>  
> +static void red_channel_on_output(void *opaque, int n)
> +{
> +    RedChannelClient *rcc = opaque;
> +    RedChannel *self = red_channel_client_get_channel(rcc);;
> +
> +    red_channel_client_on_output(opaque, n);
> +
> +    stat_inc_counter(self->priv->reds, self->priv->out_bytes_counter, n);
> +}
> +
> +static void
> +red_channel_constructed(GObject *object)
> +{
> +    RedChannel *self = RED_CHANNEL(object);
> +    spice_debug("%p: channel type %d id %d thread_id 0x%lx", self,
> +                self->priv->type, self->priv->id, self->priv->thread_id);
> +
> +    RedChannelClass *klass = RED_CHANNEL_GET_CLASS(self);
> +    self->priv->incoming_cb.alloc_msg_buf =
> +        (alloc_msg_recv_buf_proc)klass->alloc_recv_buf;
> +    self->priv->incoming_cb.release_msg_buf =
> +        (release_msg_recv_buf_proc)klass->release_recv_buf;
> +    self->priv->incoming_cb.handle_message =
> (handle_message_proc)klass->handle_message;
> +    self->priv->incoming_cb.handle_parsed =
> (handle_parsed_proc)klass->handle_parsed;
> +    self->priv->incoming_cb.parser = klass->parser;
> +
> +    G_OBJECT_CLASS(red_channel_parent_class)->constructed(object);
> +}
> +
> +static void red_channel_client_default_connect(RedChannel *channel,
> RedClient *client,
> +                                               RedsStream *stream,
> +                                               int migration,
> +                                               int num_common_caps, uint32_t
> *common_caps,
> +                                               int num_caps, uint32_t *caps)
> +{
> +    spice_error("not implemented");
> +}
> +
> +static void red_channel_client_default_disconnect(RedChannelClient *base)
> +{
> +    red_channel_client_disconnect(base);
> +}
> +
> +static void
> +red_channel_class_init(RedChannelClass *klass)
> +{
> +    GObjectClass *object_class = G_OBJECT_CLASS(klass);
> +
> +    g_type_class_add_private(klass, sizeof (RedChannelPrivate));
> +
> +    object_class->get_property = red_channel_get_property;
> +    object_class->set_property = red_channel_set_property;
> +    object_class->finalize = red_channel_finalize;
> +    object_class->constructed = red_channel_constructed;
> +
> +    g_object_class_install_property(object_class,
> +                                    PROP_SPICE_SERVER,
> +                                    g_param_spec_pointer("spice-server",
> +                                                         "spice-server",
> +                                                         "The spice server
> associated with this channel",
> +                                                         G_PARAM_READWRITE |
> +
> G_PARAM_CONSTRUCT_ONLY
> |
> +
> G_PARAM_STATIC_STRINGS));
> +
> +    g_object_class_install_property(object_class,
> +                                    PROP_CORE_INTERFACE,
> +                                    g_param_spec_pointer("core-interface",
> +                                                         "core-interface",
> +                                                         "The
> SpiceCoreInterface server associated with this channel",
> +                                                         G_PARAM_READWRITE |
> +
> G_PARAM_CONSTRUCT_ONLY
> |
> +
> G_PARAM_STATIC_STRINGS));
> +
> +    /* FIXME: generate enums for this in spice-common? */
> +    g_object_class_install_property(object_class,
> +                                    PROP_TYPE,
> +                                    g_param_spec_int("channel-type",
> +                                                     "channel type",
> +                                                     "Type of this channel",
> +                                                     0,
> +                                                     SPICE_END_CHANNEL,
> +                                                     0,
> +                                                     G_PARAM_READWRITE |
> +                                                     G_PARAM_CONSTRUCT_ONLY
> |
> +
> G_PARAM_STATIC_STRINGS));
> +
> +    g_object_class_install_property(object_class,
> +                                    PROP_ID,
> +                                    g_param_spec_uint("id",
> +                                                      "id",
> +                                                      "ID of this channel",
> +                                                      0,
> +                                                      G_MAXUINT,
> +                                                      0,
> +                                                      G_PARAM_READWRITE |
> +                                                      G_PARAM_CONSTRUCT_ONLY
> |
> +
> G_PARAM_STATIC_STRINGS));
> +
> +    g_object_class_install_property(object_class,
> +                                    PROP_HANDLE_ACKS,
> +                                    g_param_spec_boolean("handle-acks",
> +                                                         "Handle ACKs",
> +                                                         "Whether this
> channel handles ACKs",
> +                                                         FALSE,
> +                                                         G_PARAM_READWRITE |
> +
> G_PARAM_CONSTRUCT_ONLY
> |
> +
> G_PARAM_STATIC_STRINGS));
> +
> +    g_object_class_install_property(object_class,
> +                                    PROP_MIGRATION_FLAGS,
> +                                    g_param_spec_uint("migration-flags",
> +                                                      "migration flags",
> +                                                      "Migration flags for
> this channel",
> +                                                      0,
> +                                                      G_MAXUINT,
> +                                                      0,
> +                                                      G_PARAM_READWRITE |
> +                                                      G_PARAM_CONSTRUCT_ONLY
> |
> +
> G_PARAM_STATIC_STRINGS));
> +}
> +
> +static void
> +red_channel_init(RedChannel *self)
> +{
> +    self->priv = CHANNEL_PRIVATE(self);
> +
> +    red_channel_set_common_cap(self, SPICE_COMMON_CAP_MINI_HEADER);
> +    self->priv->thread_id = pthread_self();
> +    self->priv->out_bytes_counter = 0;
> +
> +    // TODO: send incoming_cb as parameters instead of duplicating?
> +    self->priv->incoming_cb.on_error =
> +        (on_incoming_error_proc)red_channel_client_default_peer_on_error;
> +    self->priv->incoming_cb.on_input = red_channel_client_on_input;
> +    self->priv->outgoing_cb.get_msg_size =
> red_channel_client_get_out_msg_size;
> +    self->priv->outgoing_cb.prepare = red_channel_client_prepare_out_msg;
> +    self->priv->outgoing_cb.on_block = red_channel_client_on_out_block;
> +    self->priv->outgoing_cb.on_error =
> +        (on_outgoing_error_proc)red_channel_client_default_peer_on_error;
> +    self->priv->outgoing_cb.on_msg_done =
> red_channel_client_on_out_msg_done;
> +    self->priv->outgoing_cb.on_output = red_channel_on_output;
> +
> +    self->priv->client_cbs.connect = red_channel_client_default_connect;
> +    self->priv->client_cbs.disconnect =
> red_channel_client_default_disconnect;
> +    self->priv->client_cbs.migrate = red_channel_client_default_migrate;
> +}
> +
> +
> +void red_channel_receive(RedChannel *channel)
> +{
> +    g_list_foreach(channel->priv->clients,
> (GFunc)red_channel_client_receive, NULL);
> +}
> +
>  void red_channel_add_client(RedChannel *channel, RedChannelClient *rcc)
>  {
>      spice_assert(rcc);
> -    channel->clients = g_list_append(channel->clients, rcc);
> +    channel->priv->clients = g_list_append(channel->priv->clients, rcc);
>  }
>  
>  int red_channel_test_remote_common_cap(RedChannel *channel, uint32_t cap)
>  {
>      GList *link;
>  
> -    for (link = channel->clients; link != NULL; link = link->next) {
> +    for (link = channel->priv->clients; link != NULL; link = link->next) {
>          RedChannelClient *rcc = link->data;
>  
>          if (!red_channel_client_test_remote_common_cap(rcc, cap)) {
> @@ -99,7 +378,7 @@ int red_channel_test_remote_cap(RedChannel *channel,
> uint32_t cap)
>  {
>      GList *link;
>  
> -    for (link = channel->clients; link != NULL; link = link->next) {
> +    for (link = channel->priv->clients; link != NULL; link = link->next) {
>          RedChannelClient *rcc = link->data;
>  
>          if (!red_channel_client_test_remote_cap(rcc, cap)) {
> @@ -136,7 +415,7 @@ gboolean
> red_client_seamless_migration_done_for_channel(RedClient *client,
>  int red_channel_is_waiting_for_migrate_data(RedChannel *channel)
>  {
>      RedChannelClient *rcc;
> -    guint n_clients = g_list_length(channel->clients);
> +    guint n_clients = g_list_length(channel->priv->clients);
>  
>      if (!red_channel_is_connected(channel)) {
>          return FALSE;
> @@ -146,190 +425,42 @@ int red_channel_is_waiting_for_migrate_data(RedChannel
> *channel)
>          return FALSE;
>      }
>      spice_assert(n_clients == 1);
> -    rcc = channel->clients->data;
> +    rcc = channel->priv->clients->data;
>      return red_channel_client_is_waiting_for_migrate_data(rcc);
>  }
>  
> -static void red_channel_client_default_connect(RedChannel *channel,
> RedClient *client,
> -                                               RedsStream *stream,
> -                                               int migration,
> -                                               int num_common_caps, uint32_t
> *common_caps,
> -                                               int num_caps, uint32_t *caps)
> -{
> -    spice_error("not implemented");
> -}
> -
> -static void red_channel_client_default_disconnect(RedChannelClient *base)
> -{
> -    red_channel_client_disconnect(base);
> -}
> -
> -RedChannel *red_channel_create(int size,
> -                               RedsState *reds,
> -                               const SpiceCoreInterfaceInternal *core,
> -                               uint32_t type, uint32_t id,
> -                               int handle_acks,
> -                               channel_handle_message_proc handle_message,
> -                               const ChannelCbs *channel_cbs,
> -                               uint32_t migration_flags)
> -{
> -    RedChannel *channel;
> -    ClientCbs client_cbs = { NULL, };
> -
> -    spice_assert(size >= sizeof(*channel));
> -    spice_assert(channel_cbs->config_socket && channel_cbs->on_disconnect &&
> handle_message &&
> -           channel_cbs->alloc_recv_buf && channel_cbs->release_item);
> -    spice_assert(channel_cbs->handle_migrate_data ||
> -                 !(migration_flags & SPICE_MIGRATE_NEED_DATA_TRANSFER));
> -    channel = spice_malloc0(size);
> -    channel->type = type;
> -    channel->id = id;
> -    channel->refs = 1;
> -    channel->handle_acks = handle_acks;
> -    channel->migration_flags = migration_flags;
> -    memcpy(&channel->channel_cbs, channel_cbs, sizeof(ChannelCbs));
> -
> -    channel->reds = reds;
> -    channel->core = core;
> -
> -    // TODO: send incoming_cb as parameters instead of duplicating?
> -    channel->incoming_cb.alloc_msg_buf =
> (alloc_msg_recv_buf_proc)channel_cbs->alloc_recv_buf;
> -    channel->incoming_cb.release_msg_buf =
> (release_msg_recv_buf_proc)channel_cbs->release_recv_buf;
> -    channel->incoming_cb.handle_message =
> (handle_message_proc)handle_message;
> -    channel->incoming_cb.on_error =
> -        (on_incoming_error_proc)red_channel_client_default_peer_on_error;
> -    channel->incoming_cb.on_input = red_channel_client_on_input;
> -    channel->outgoing_cb.get_msg_size = red_channel_client_get_out_msg_size;
> -    channel->outgoing_cb.prepare = red_channel_client_prepare_out_msg;
> -    channel->outgoing_cb.on_block = red_channel_client_on_out_block;
> -    channel->outgoing_cb.on_error =
> -        (on_outgoing_error_proc)red_channel_client_default_peer_on_error;
> -    channel->outgoing_cb.on_msg_done = red_channel_client_on_out_msg_done;
> -    channel->outgoing_cb.on_output = red_channel_client_on_output;
> -
> -    client_cbs.connect = red_channel_client_default_connect;
> -    client_cbs.disconnect = red_channel_client_default_disconnect;
> -    client_cbs.migrate = red_channel_client_default_migrate;
> -
> -    red_channel_register_client_cbs(channel, &client_cbs, NULL);
> -    red_channel_set_common_cap(channel, SPICE_COMMON_CAP_MINI_HEADER);
> -
> -    channel->thread_id = pthread_self();
> -
> -    channel->out_bytes_counter = 0;
> -
> -    spice_debug("channel type %d id %d thread_id 0x%lx",
> -                channel->type, channel->id, channel->thread_id);
> -    return channel;
> -}
> -
> -// TODO: red_worker can use this one
> -static void dummy_watch_update_mask(SpiceWatch *watch, int event_mask)
> -{
> -}
> -
> -static SpiceWatch *dummy_watch_add(const SpiceCoreInterfaceInternal *iface,
> -                                   int fd, int event_mask, SpiceWatchFunc
> func, void *opaque)
> -{
> -    return NULL; // apparently allowed?
> -}
> -
> -static void dummy_watch_remove(SpiceWatch *watch)
> -{
> -}
> -
> -// TODO: actually, since I also use channel_client_dummy, no need for core.
> Can be NULL
> -static const SpiceCoreInterfaceInternal dummy_core = {
> -    .watch_update_mask = dummy_watch_update_mask,
> -    .watch_add = dummy_watch_add,
> -    .watch_remove = dummy_watch_remove,
> -};
> -
> -RedChannel *red_channel_create_dummy(int size, RedsState *reds, uint32_t
> type, uint32_t id)
> -{
> -    RedChannel *channel;
> -    ClientCbs client_cbs = { NULL, };
> -
> -    spice_assert(size >= sizeof(*channel));
> -    channel = spice_malloc0(size);
> -    channel->type = type;
> -    channel->id = id;
> -    channel->refs = 1;
> -    channel->reds = reds;
> -    channel->core = &dummy_core;
> -    client_cbs.connect = red_channel_client_default_connect;
> -    client_cbs.disconnect = red_channel_client_default_disconnect;
> -    client_cbs.migrate = red_channel_client_default_migrate;
> -
> -    red_channel_register_client_cbs(channel, &client_cbs, NULL);
> -    red_channel_set_common_cap(channel, SPICE_COMMON_CAP_MINI_HEADER);
> -
> -    channel->thread_id = pthread_self();
> -    spice_debug("channel type %d id %d thread_id 0x%lx",
> -                channel->type, channel->id, channel->thread_id);
> -
> -    channel->out_bytes_counter = 0;
> -
> -    return channel;
> -}
> -
> -static int do_nothing_handle_message(RedChannelClient *rcc,
> -                                     uint16_t type,
> -                                     uint32_t size,
> -                                     uint8_t *msg)
> -{
> -    return TRUE;
> -}
> -
> -RedChannel *red_channel_create_parser(int size,
> -                                      RedsState *reds,
> -                                      const SpiceCoreInterfaceInternal
> *core,
> -                                      uint32_t type, uint32_t id,
> -                                      int handle_acks,
> -                                      spice_parse_channel_func_t parser,
> -                                      channel_handle_parsed_proc
> handle_parsed,
> -                                      const ChannelCbs *channel_cbs,
> -                                      uint32_t migration_flags)
> +void red_channel_set_stat_node(RedChannel *channel, StatNodeRef stat)
>  {
> -    RedChannel *channel = red_channel_create(size, reds, core, type, id,
> -                                             handle_acks,
> -                                             do_nothing_handle_message,
> -                                             channel_cbs,
> -                                             migration_flags);
> -
> -    if (channel == NULL) {
> -        return NULL;
> -    }
> -    channel->incoming_cb.handle_parsed = (handle_parsed_proc)handle_parsed;
> -    channel->incoming_cb.parser = parser;
> +    spice_return_if_fail(channel != NULL);
> +    spice_return_if_fail(channel->priv->stat == 0);
>  
> -    return channel;
> +#ifdef RED_STATISTICS
> +    channel->priv->stat = stat;
> +    channel->priv->out_bytes_counter = stat_add_counter(channel->priv->reds,
> stat, "out_bytes", TRUE);
> +#endif
>  }
>  
> -void red_channel_set_stat_node(RedChannel *channel, StatNodeRef stat)
> +StatNodeRef red_channel_get_stat_node(RedChannel *channel)
>  {
> -    spice_return_if_fail(channel != NULL);
> -    spice_return_if_fail(channel->stat == 0);
> -
>  #ifdef RED_STATISTICS
> -    channel->stat = stat;
> -    channel->out_bytes_counter = stat_add_counter(channel->reds, stat,
> "out_bytes", TRUE);
> +    return channel->priv->stat;
>  #endif
> +    return 0;
>  }
>  
>  void red_channel_register_client_cbs(RedChannel *channel, const ClientCbs
>  *client_cbs, gpointer cbs_data)
>  {
> -    spice_assert(client_cbs->connect || channel->type ==
> SPICE_CHANNEL_MAIN);
> -    channel->client_cbs.connect = client_cbs->connect;
> +    spice_assert(client_cbs->connect || channel->priv->type ==
> SPICE_CHANNEL_MAIN);
> +    channel->priv->client_cbs.connect = client_cbs->connect;
>  
>      if (client_cbs->disconnect) {
> -        channel->client_cbs.disconnect = client_cbs->disconnect;
> +        channel->priv->client_cbs.disconnect = client_cbs->disconnect;
>      }
>  
>      if (client_cbs->migrate) {
> -        channel->client_cbs.migrate = client_cbs->migrate;
> +        channel->priv->client_cbs.migrate = client_cbs->migrate;
>      }
> -    channel->data = cbs_data;
> +    channel->priv->data = cbs_data;
>  }
>  
>  int test_capability(const uint32_t *caps, int num_caps, uint32_t cap)
> @@ -356,32 +487,12 @@ static void add_capability(uint32_t **caps, int
> *num_caps, uint32_t cap)
>  
>  void red_channel_set_common_cap(RedChannel *channel, uint32_t cap)
>  {
> -    add_capability(&channel->local_caps.common_caps,
> &channel->local_caps.num_common_caps, cap);
> +    add_capability(&channel->priv->local_caps.common_caps,
> &channel->priv->local_caps.num_common_caps, cap);
>  }
>  
>  void red_channel_set_cap(RedChannel *channel, uint32_t cap)
>  {
> -    add_capability(&channel->local_caps.caps, &channel->local_caps.num_caps,
> cap);
> -}
> -
> -void red_channel_ref(RedChannel *channel)
> -{
> -    channel->refs++;
> -}
> -
> -void red_channel_unref(RedChannel *channel)
> -{
> -    if (--channel->refs == 0) {
> -        if (channel->local_caps.num_common_caps) {
> -            free(channel->local_caps.common_caps);
> -        }
> -
> -        if (channel->local_caps.num_caps) {
> -            free(channel->local_caps.caps);
> -        }
> -
> -        free(channel);
> -    }
> +    add_capability(&channel->priv->local_caps.caps,
> &channel->priv->local_caps.num_caps, cap);
>  }
>  
>  void red_channel_destroy(RedChannel *channel)
> @@ -390,13 +501,13 @@ void red_channel_destroy(RedChannel *channel)
>          return;
>      }
>  
> -    g_list_foreach(channel->clients, (GFunc)red_channel_client_destroy,
> NULL);
> -    red_channel_unref(channel);
> +    g_list_foreach(channel->priv->clients,
> (GFunc)red_channel_client_destroy, NULL);
> +    g_object_unref(channel);
>  }
>  
>  void red_channel_send(RedChannel *channel)
>  {
> -    g_list_foreach(channel->clients, (GFunc)red_channel_client_send, NULL);
> +    g_list_foreach(channel->priv->clients, (GFunc)red_channel_client_send,
> NULL);
>  }
>  
>  void red_channel_push(RedChannel *channel)
> @@ -405,14 +516,14 @@ void red_channel_push(RedChannel *channel)
>          return;
>      }
>  
> -    g_list_foreach(channel->clients, (GFunc)red_channel_client_push, NULL);
> +    g_list_foreach(channel->priv->clients, (GFunc)red_channel_client_push,
> NULL);
>  }
>  
>  // TODO: this function doesn't make sense because the window should be
>  client (WAN/LAN)
>  // specific
>  void red_channel_init_outgoing_messages_window(RedChannel *channel)
>  {
> -    g_list_foreach(channel->clients,
> (GFunc)red_channel_client_init_outgoing_messages_window, NULL);
> +    g_list_foreach(channel->priv->clients,
> (GFunc)red_channel_client_init_outgoing_messages_window, NULL);
>  }
>  
>  static void red_channel_client_pipe_add_type_proxy(gpointer data, gpointer
>  user_data)
> @@ -423,7 +534,7 @@ static void
> red_channel_client_pipe_add_type_proxy(gpointer data, gpointer user_
>  
>  void red_channel_pipes_add_type(RedChannel *channel, int pipe_item_type)
>  {
> -    g_list_foreach(channel->clients, red_channel_client_pipe_add_type_proxy,
> +    g_list_foreach(channel->priv->clients,
> red_channel_client_pipe_add_type_proxy,
>                     GINT_TO_POINTER(pipe_item_type));
>  }
>  
> @@ -435,12 +546,12 @@ static void
> red_channel_client_pipe_add_empty_msg_proxy(gpointer data, gpointer
>  
>  void red_channel_pipes_add_empty_msg(RedChannel *channel, int msg_type)
>  {
> -    g_list_foreach(channel->clients,
> red_channel_client_pipe_add_empty_msg_proxy, GINT_TO_POINTER(msg_type));
> +    g_list_foreach(channel->priv->clients,
> red_channel_client_pipe_add_empty_msg_proxy, GINT_TO_POINTER(msg_type));
>  }
>  
>  int red_channel_is_connected(RedChannel *channel)
>  {
> -    return channel && channel->clients;
> +    return channel && channel->priv->clients;
>  }
>  
>  void red_channel_remove_client(RedChannel *channel, RedChannelClient *rcc)
> @@ -448,19 +559,19 @@ void red_channel_remove_client(RedChannel *channel,
> RedChannelClient *rcc)
>      GList *link;
>      g_return_if_fail(channel == red_channel_client_get_channel(rcc));
>  
> -    if (!pthread_equal(pthread_self(), channel->thread_id)) {
> +    if (!pthread_equal(pthread_self(), channel->priv->thread_id)) {
>          spice_warning("channel type %d id %d - "
>                        "channel->thread_id (0x%lx) != pthread_self (0x%lx)."
>                        "If one of the threads is != io-thread && !=
>                        vcpu-thread, "
>                        "this might be a BUG",
> -                      channel->type, channel->id,
> -                      channel->thread_id, pthread_self());
> +                      channel->priv->type, channel->priv->id,
> +                      channel->priv->thread_id, pthread_self());
>      }
>      spice_return_if_fail(channel);
> -    link = g_list_find(channel->clients, rcc);
> +    link = g_list_find(channel->priv->clients, rcc);
>      spice_return_if_fail(link != NULL);
>  
> -    channel->clients = g_list_remove_link(channel->clients, link);
> +    channel->priv->clients = g_list_remove_link(channel->priv->clients,
> link);
>      // TODO: should we set rcc->channel to NULL???
>  }
>  
> @@ -474,17 +585,35 @@ void red_client_remove_channel(RedChannelClient *rcc)
>  
>  void red_channel_disconnect(RedChannel *channel)
>  {
> -    g_list_foreach(channel->clients, (GFunc)red_channel_client_disconnect,
> NULL);
> +    g_list_foreach(channel->priv->clients,
> (GFunc)red_channel_client_disconnect, NULL);
> +}
> +
> +void red_channel_connect(RedChannel *channel, RedClient *client,
> +                         RedsStream *stream, int migration, int
> num_common_caps,
> +                         uint32_t *common_caps, int num_caps, uint32_t
> *caps)
> +{
> +    channel->priv->client_cbs.connect(channel, client, stream, migration,
> +                                      num_common_caps, common_caps,
> num_caps,
> +                                      caps);
>  }
>  
>  void red_channel_apply_clients(RedChannel *channel, channel_client_callback
>  cb)
>  {
> -    g_list_foreach(channel->clients, (GFunc)cb, NULL);
> +    g_list_foreach(channel->priv->clients, (GFunc)cb, NULL);
>  }
>  
>  void red_channel_apply_clients_data(RedChannel *channel,
>  channel_client_callback_data cb, void *data)
>  {
> -    g_list_foreach(channel->clients, (GFunc)cb, data);
> +    g_list_foreach(channel->priv->clients, (GFunc)cb, data);
> +}
> +
> +GList *red_channel_get_clients(RedChannel *channel)
> +{
> +    return channel->priv->clients;
> +}
> +guint red_channel_get_n_clients(RedChannel *channel)
> +{
> +    return g_list_length(channel->priv->clients);
>  }
>  
>  int red_channel_all_blocked(RedChannel *channel)
> @@ -492,10 +621,10 @@ int red_channel_all_blocked(RedChannel *channel)
>      GList *link;
>      RedChannelClient *rcc;
>  
> -    if (!channel || !channel->clients) {
> +    if (!channel || !channel->priv->clients) {
>          return FALSE;
>      }
> -    for (link = channel->clients; link != NULL; link = link->next) {
> +    for (link = channel->priv->clients; link != NULL; link = link->next) {
>          rcc = link->data;
>          if (!red_channel_client_is_blocked(rcc)) {
>              return FALSE;
> @@ -509,7 +638,7 @@ int red_channel_any_blocked(RedChannel *channel)
>      GList *link;
>      RedChannelClient *rcc;
>  
> -    for (link = channel->clients; link != NULL; link = link->next) {
> +    for (link = channel->priv->clients; link != NULL; link = link->next) {
>          rcc = link->data;
>          if (red_channel_client_is_blocked(rcc)) {
>              return TRUE;
> @@ -523,10 +652,10 @@ int red_channel_get_first_socket(RedChannel *channel)
>      RedChannelClient *rcc;
>      RedsStream *stream;
>  
> -    if (!channel || !channel->clients) {
> +    if (!channel || !channel->priv->clients) {
>          return -1;
>      }
> -    rcc = channel->clients->data;
> +    rcc = channel->priv->clients->data;
>      stream = red_channel_client_get_stream(rcc);
>  
>      return stream->socket;
> @@ -537,7 +666,7 @@ int red_channel_no_item_being_sent(RedChannel *channel)
>      GList *link;
>      RedChannelClient *rcc;
>  
> -    for (link = channel->clients; link != NULL; link = link->next) {
> +    for (link = channel->priv->clients; link != NULL; link = link->next) {
>          rcc = link->data;
>          if (!red_channel_client_no_item_being_sent(rcc)) {
>              return FALSE;
> @@ -617,7 +746,7 @@ void red_client_migrate(RedClient *client)
>          rcc = link->data;
>          channel = red_channel_client_get_channel(rcc);
>          if (red_channel_client_is_connected(rcc)) {
> -            channel->client_cbs.migrate(rcc);
> +            channel->priv->client_cbs.migrate(rcc);
>          }
>          link = next;
>      }
> @@ -650,7 +779,7 @@ void red_client_destroy(RedClient *client)
>          // to wait for disconnection)
>          // TODO: should we go back to async. For this we need to use
>          // ref count for channel clients.
> -        channel->client_cbs.disconnect(rcc);
> +        channel->priv->client_cbs.disconnect(rcc);
>          spice_assert(red_channel_client_pipe_is_empty(rcc));
>          spice_assert(red_channel_client_no_item_being_sent(rcc));
>          red_channel_client_destroy(rcc);
> @@ -670,7 +799,7 @@ RedChannelClient *red_client_get_channel(RedClient
> *client, int type, int id)
>          RedChannel *channel;
>          rcc = link->data;
>          channel = red_channel_client_get_channel(rcc);
> -        if (channel->type == type && channel->id == id) {
> +        if (channel->priv->type == type && channel->priv->id == id) {
>              ret = rcc;
>              break;
>          }
> @@ -763,7 +892,7 @@ static int red_channel_pipes_create_batch(RedChannel
> *channel,
>      spice_assert(creator != NULL);
>      spice_assert(pipe_add != NULL);
>  
> -    link = channel->clients;
> +    link = channel->priv->clients;
>      while (link != NULL) {
>          next = link->next;
>          rcc = link->data;
> @@ -806,7 +935,7 @@ uint32_t red_channel_max_pipe_size(RedChannel *channel)
>      RedChannelClient *rcc;
>      uint32_t pipe_size = 0;
>  
> -    for (link = channel->clients; link != NULL; link = link->next) {
> +    for (link = channel->priv->clients; link != NULL; link = link->next) {
>          uint32_t new_size;
>          rcc = link->data;
>          new_size = red_channel_client_get_pipe_size(rcc);
> @@ -821,7 +950,7 @@ uint32_t red_channel_min_pipe_size(RedChannel *channel)
>      RedChannelClient *rcc;
>      uint32_t pipe_size = ~0;
>  
> -    for (link = channel->clients; link != NULL; link = link->next) {
> +    for (link = channel->priv->clients; link != NULL; link = link->next) {
>          uint32_t new_size;
>          rcc = link->data;
>          new_size = red_channel_client_get_pipe_size(rcc);
> @@ -836,7 +965,7 @@ uint32_t red_channel_sum_pipes_size(RedChannel *channel)
>      RedChannelClient *rcc;
>      uint32_t sum = 0;
>  
> -    for (link = channel->clients; link != NULL; link = link->next) {
> +    for (link = channel->priv->clients; link != NULL; link = link->next) {
>          rcc = link->data;
>          sum += red_channel_client_get_pipe_size(rcc);
>      }
> @@ -879,5 +1008,116 @@ int red_channel_wait_all_sent(RedChannel *channel,
>  
>  RedsState* red_channel_get_server(RedChannel *channel)
>  {
> -    return channel->reds;
> +    return channel->priv->reds;
> +}
> +
> +SpiceCoreInterfaceInternal* red_channel_get_core_interface(RedChannel
> *channel)
> +{
> +    return channel->priv->core;
> +}
> +
> +int red_channel_config_socket(RedChannel *self, RedChannelClient *rcc)
> +{
> +    RedChannelClass *klass = RED_CHANNEL_GET_CLASS(self);
> +    g_return_val_if_fail(klass->config_socket, FALSE);
> +
> +    return klass->config_socket(rcc);
> +}
> +
> +void red_channel_on_disconnect(RedChannel *self, RedChannelClient *rcc)
> +{
> +    RedChannelClass *klass = RED_CHANNEL_GET_CLASS(self);
> +    g_return_if_fail(klass->on_disconnect);
> +
> +    klass->on_disconnect(rcc);
> +}
> +
> +void red_channel_send_item(RedChannel *self, RedChannelClient *rcc,
> RedPipeItem *item)
> +{
> +    RedChannelClass *klass = RED_CHANNEL_GET_CLASS(self);
> +    g_return_if_fail(klass->send_item);
> +
> +    klass->send_item(rcc, item);
> +}
> +
> +void red_channel_hold_item(RedChannel *self, RedChannelClient *rcc,
> RedPipeItem *item)
> +{
> +    RedChannelClass *klass = RED_CHANNEL_GET_CLASS(self);
> +    g_return_if_fail(klass->hold_item);
> +
> +    klass->hold_item(rcc, item);
> +}
> +
> +void red_channel_release_item(RedChannel *self, RedChannelClient *rcc,
> +                              RedPipeItem *item, int item_pushed)
> +{
> +    RedChannelClass *klass = RED_CHANNEL_GET_CLASS(self);
> +    g_return_if_fail(klass->release_item);
> +
> +    klass->release_item(rcc, item, item_pushed);
> +}
> +
> +uint8_t* red_channel_alloc_recv_buf(RedChannel *self, RedChannelClient *rcc,
> +                                    uint16_t type, uint32_t size)
> +{
> +    RedChannelClass *klass = RED_CHANNEL_GET_CLASS(self);
> +    g_return_val_if_fail(klass->alloc_recv_buf, NULL);
> +
> +    return klass->alloc_recv_buf(rcc, type, size);
> +}
> +
> +void red_channel_release_recv_buf(RedChannel *self, RedChannelClient *rcc,
> +                                  uint16_t type, uint32_t size, uint8_t
> *msg)
> +{
> +    RedChannelClass *klass = RED_CHANNEL_GET_CLASS(self);
> +    g_return_if_fail(klass->release_recv_buf);
> +
> +    klass->release_recv_buf(rcc, type, size, msg);
> +}
> +
> +int red_channel_handle_migrate_flush_mark(RedChannel *self, RedChannelClient
> *rcc)
> +{
> +    RedChannelClass *klass = RED_CHANNEL_GET_CLASS(self);
> +    g_return_val_if_fail(klass->handle_migrate_flush_mark, FALSE);
> +
> +    return klass->handle_migrate_flush_mark(rcc);
> +}
> +
> +int red_channel_handle_migrate_data(RedChannel *self, RedChannelClient *rcc,
> +                                    uint32_t size, void *message)
> +{
> +    RedChannelClass *klass = RED_CHANNEL_GET_CLASS(self);
> +    g_return_val_if_fail(klass->handle_migrate_data, FALSE);
> +
> +    return klass->handle_migrate_data(rcc, size, message);
> +}
> +
> +uint64_t red_channel_handle_migrate_data_get_serial(RedChannel *self,
> +                                                    RedChannelClient *rcc,
> +                                                    uint32_t size, void
> *message)
> +{
> +    RedChannelClass *klass = RED_CHANNEL_GET_CLASS(self);
> +    g_return_val_if_fail(klass->handle_migrate_data_get_serial, 0);
> +
> +    return klass->handle_migrate_data_get_serial(rcc, size, message);
> +}
> +
> +IncomingHandlerInterface* red_channel_get_incoming_handler(RedChannel *self)
> +{
> +    return &self->priv->incoming_cb;
> +}
> +
> +OutgoingHandlerInterface* red_channel_get_outgoing_handler(RedChannel *self)
> +{
> +    return &self->priv->outgoing_cb;
> +}
> +
> +void red_channel_reset_thread_id(RedChannel *self)
> +{
> +    self->priv->thread_id = pthread_self();
> +}
> +
> +RedChannelCapabilities* red_channel_get_local_capabilities(RedChannel *self)
> +{
> +    return &self->priv->local_caps;
>  }
> diff --git a/server/red-channel.h b/server/red-channel.h
> index 5c1d555..1b8abce 100644
> --- a/server/red-channel.h
> +++ b/server/red-channel.h
> @@ -36,9 +36,10 @@
>  #include "red-pipe-item.h"
>  #include "red-channel-client.h"
>  
> -/* Red Channel interface */
> +#include <glib-object.h>
> +
> +G_BEGIN_DECLS
>  
> -typedef struct RedChannel RedChannel;
>  typedef struct RedClient RedClient;
>  
>  typedef uint8_t *(*channel_alloc_msg_recv_buf_proc)(RedChannelClient
>  *channel,
> @@ -71,13 +72,53 @@ typedef void (*channel_client_connect_proc)(RedChannel
> *channel, RedClient *clie
>  typedef void (*channel_client_disconnect_proc)(RedChannelClient *base);
>  typedef void (*channel_client_migrate_proc)(RedChannelClient *base);
>  
> -// TODO: add ASSERTS for thread_id  in client and channel calls
> -//
> +
>  /*
> - * callbacks that are triggered from channel client stream events.
> - * They are called from the thread that listen to the stream events.
> + * callbacks that are triggered from client events.
> + * They should be called from the thread that handles the RedClient
>   */
>  typedef struct {
> +    channel_client_connect_proc connect;
> +    channel_client_disconnect_proc disconnect;
> +    channel_client_migrate_proc migrate;
> +} ClientCbs;
> +
> +int test_capability(const uint32_t *caps, int num_caps, uint32_t cap);
> +
> +#define RED_TYPE_CHANNEL red_channel_get_type()
> +
> +#define RED_CHANNEL(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),
> RED_TYPE_CHANNEL, RedChannel))
> +#define RED_CHANNEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),
> RED_TYPE_CHANNEL, RedChannelClass))
> +#define RED_IS_CHANNEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),
> RED_TYPE_CHANNEL))
> +#define RED_IS_CHANNEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),
> RED_TYPE_CHANNEL))
> +#define RED_CHANNEL_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj),
> RED_TYPE_CHANNEL, RedChannelClass))
> +
> +typedef struct RedChannel RedChannel;
> +typedef struct RedChannelClass RedChannelClass;
> +typedef struct RedChannelPrivate RedChannelPrivate;
> +
> +struct RedChannel
> +{
> +    GObject parent;
> +
> +    RedChannelPrivate *priv;
> +};
> +
> +struct RedChannelClass
> +{
> +    GObjectClass parent_class;
> +
> +    /* subclasses must implement either handle_message(), or both parser()
> and
> +     * handle_parsed() */
> +    channel_handle_message_proc handle_message;
> +    spice_parse_channel_func_t parser;
> +    channel_handle_parsed_proc handle_parsed;
> +
> +    // TODO: add ASSERTS for thread_id  in client and channel calls
> +    /*
> +     * callbacks that are triggered from channel client stream events.
> +     * They are called from the thread that listen to the stream events.
> +     */
>      channel_configure_socket_proc config_socket;
>      channel_disconnect_proc on_disconnect;
>      channel_send_pipe_item_proc send_item;
> @@ -88,18 +129,9 @@ typedef struct {
>      channel_handle_migrate_flush_mark_proc handle_migrate_flush_mark;
>      channel_handle_migrate_data_proc handle_migrate_data;
>      channel_handle_migrate_data_get_serial_proc
>      handle_migrate_data_get_serial;
> -} ChannelCbs;
> -
> +};
>  
> -/*
> - * callbacks that are triggered from client events.
> - * They should be called from the thread that handles the RedClient
> - */
> -typedef struct {
> -    channel_client_connect_proc connect;
> -    channel_client_disconnect_proc disconnect;
> -    channel_client_migrate_proc migrate;
> -} ClientCbs;
> +/* Red Channel interface */
>  
>  typedef struct RedChannelCapabilities {
>      int num_common_caps;
> @@ -108,94 +140,20 @@ typedef struct RedChannelCapabilities {
>      uint32_t *caps;
>  } RedChannelCapabilities;
>  
> -int test_capability(const uint32_t *caps, int num_caps, uint32_t cap);
> -
> -typedef struct RedChannelClientLatencyMonitor {
> -    int state;
> -    uint64_t last_pong_time;
> -    SpiceTimer *timer;
> -    uint32_t id;
> -    int tcp_nodelay;
> -    int warmup_was_sent;
> -
> -    int64_t roundtrip;
> -} RedChannelClientLatencyMonitor;
> -
> -typedef struct RedChannelClientConnectivityMonitor {
> -    int state;
> -    uint32_t out_bytes;
> -    uint32_t in_bytes;
> -    uint32_t timeout;
> -    SpiceTimer *timer;
> -} RedChannelClientConnectivityMonitor;
> -
> -struct RedChannel {
> -    uint32_t type;
> -    uint32_t id;
> -
> -    uint32_t refs;
> -
> -    RingItem link; // channels link for reds
> -
> -    const SpiceCoreInterfaceInternal *core;
> -    int handle_acks;
> -
> -    // RedChannel will hold only connected channel clients (logic - when
> pushing pipe item to all channel clients, there
> -    // is no need to go over disconnect clients)
> -    // . While client will hold the channel clients till it is destroyed
> -    // and then it will destroy them as well.
> -    // However RCC still holds a reference to the Channel.
> -    // Maybe replace these logic with ref count?
> -    // TODO: rename to 'connected_clients'?
> -    GList *clients;
> -    uint32_t clients_num;
> -
> -    OutgoingHandlerInterface outgoing_cb;
> -    IncomingHandlerInterface incoming_cb;
> -
> -    ChannelCbs channel_cbs;
> -    ClientCbs client_cbs;
> -
> -    RedChannelCapabilities local_caps;
> -    uint32_t migration_flags;
> -
> -    void *data;
> -
> -    // TODO: when different channel_clients are in different threads from
> Channel -> need to protect!
> -    pthread_t thread_id;
> -    RedsState *reds;
> -#ifdef RED_STATISTICS
> -    StatNodeRef stat;
> -    uint64_t *out_bytes_counter;
> -#endif
> -};
> -
> -#define RED_CHANNEL(Channel) ((RedChannel *)(Channel))
> -
> -/* if one of the callbacks should cause disconnect, use red_channel_shutdown
> and don't
> - * explicitly destroy the channel */
> -RedChannel *red_channel_create(int size,
> -                               RedsState *reds,
> -                               const SpiceCoreInterfaceInternal *core,
> -                               uint32_t type, uint32_t id,
> -                               int handle_acks,
> -                               channel_handle_message_proc handle_message,
> -                               const ChannelCbs *channel_cbs,
> -                               uint32_t migration_flags);
> +GType red_channel_get_type(void) G_GNUC_CONST;
>  
>  /* alternative constructor, meant for marshaller based (inputs,main)
>  channels,
>   * will become default eventually */
> +/*
>  RedChannel *red_channel_create_parser(int size,
>                                        RedsState *reds,
>                                        const SpiceCoreInterfaceInternal
>                                        *core,
>                                        uint32_t type, uint32_t id,
> -                                      int handle_acks,
> +                                      gboolean handle_acks,
>                                        spice_parse_channel_func_t parser,
>                                        channel_handle_parsed_proc
>                                        handle_parsed,
> -                                      const ChannelCbs *channel_cbs,
>                                        uint32_t migration_flags);
> -void red_channel_ref(RedChannel *channel);
> -void red_channel_unref(RedChannel *channel);
> +                                      */
>  void red_channel_add_client(RedChannel *channel, RedChannelClient *rcc);
>  void red_channel_remove_client(RedChannel *channel, RedChannelClient *rcc);
>  
> @@ -206,11 +164,6 @@ void red_channel_register_client_cbs(RedChannel
> *channel, const ClientCbs *clien
>  void red_channel_set_common_cap(RedChannel *channel, uint32_t cap);
>  void red_channel_set_cap(RedChannel *channel, uint32_t cap);
>  
> -// TODO: tmp, for channels that don't use RedChannel yet (e.g., snd
> channel), but
> -// do use the client callbacks. So the channel clients are not connected
> (the channel doesn't
> -// have list of them, but they do have a link to the channel, and the client
> has a list of them)
> -RedChannel *red_channel_create_dummy(int size, RedsState *reds, uint32_t
> type, uint32_t id);
> -
>  int red_channel_is_connected(RedChannel *channel);
>  
>  /* seamless migration is supported for only one client. This routine
> @@ -274,6 +227,9 @@ void red_channel_receive(RedChannel *channel);
>  void red_channel_send(RedChannel *channel);
>  // For red_worker
>  void red_channel_disconnect(RedChannel *channel);
> +void red_channel_connect(RedChannel *channel, RedClient *client,
> +                         RedsStream *stream, int migration, int
> num_common_caps,
> +                         uint32_t *common_caps, int num_caps, uint32_t
> *caps);
>  
>  /* return the sum of all the rcc pipe size */
>  uint32_t red_channel_max_pipe_size(RedChannel *channel);
> @@ -286,8 +242,38 @@ uint32_t red_channel_sum_pipes_size(RedChannel
> *channel);
>  typedef void (*channel_client_callback)(RedChannelClient *rcc);
>  typedef void (*channel_client_callback_data)(RedChannelClient *rcc, void
>  *data);
>  void red_channel_apply_clients(RedChannel *channel, channel_client_callback
>  v);
> -void red_channel_apply_clients_data(RedChannel *channel,
> channel_client_callback_data v, void * data);
> +void red_channel_apply_clients_data(RedChannel *channel,
> channel_client_callback_data v, void *data);
> +GList *red_channel_get_clients(RedChannel *channel);
> +guint red_channel_get_n_clients(RedChannel *channel);
>  struct RedsState* red_channel_get_server(RedChannel *channel);
> +SpiceCoreInterfaceInternal* red_channel_get_core_interface(RedChannel
> *channel);
> +
> +/* channel callback function */
> +int red_channel_config_socket(RedChannel *self, RedChannelClient *rcc);
> +void red_channel_on_disconnect(RedChannel *self, RedChannelClient *rcc);
> +void red_channel_send_item(RedChannel *self, RedChannelClient *rcc,
> RedPipeItem *item);
> +void red_channel_hold_item(RedChannel *self, RedChannelClient *rcc,
> RedPipeItem *item);
> +void red_channel_release_item(RedChannel *channel, RedChannelClient *rcc,
> +                              RedPipeItem *item, int item_pushed);
> +uint8_t* red_channel_alloc_recv_buf(RedChannel *self, RedChannelClient *rcc,
> +                                    uint16_t type, uint32_t size);
> +void red_channel_release_recv_buf(RedChannel *self, RedChannelClient *rcc,
> +                                  uint16_t type, uint32_t size, uint8_t
> *msg);
> +int red_channel_handle_migrate_flush_mark(RedChannel *self, RedChannelClient
> *rcc);
> +int red_channel_handle_migrate_data(RedChannel *self, RedChannelClient *rcc,
> +                                    uint32_t size, void *message);
> +uint64_t red_channel_handle_migrate_data_get_serial(RedChannel *self,
> +                                                    RedChannelClient *rcc,
> +                                                    uint32_t size, void
> *message);
> +void red_channel_reset_thread_id(RedChannel *self);
> +StatNodeRef red_channel_get_stat_node(RedChannel *channel);
> +
> +/* FIXME: do these even need to be in RedChannel? It's really only used in
> + * RedChannelClient. Needs refactoring */
> +IncomingHandlerInterface* red_channel_get_incoming_handler(RedChannel
> *self);
> +OutgoingHandlerInterface* red_channel_get_outgoing_handler(RedChannel
> *self);
> +
> +RedChannelCapabilities* red_channel_get_local_capabilities(RedChannel
> *self);
>  
>  struct RedClient {
>      RedsState *reds;
> @@ -362,4 +348,6 @@ int red_channel_wait_all_sent(RedChannel *channel,
>  
>  #define CHANNEL_BLOCKED_SLEEP_DURATION 10000 //micro
>  
> +G_END_DECLS
> +
>  #endif
> diff --git a/server/red-parse-qxl.h b/server/red-parse-qxl.h
> index 9c30572..5da6916 100644
> --- a/server/red-parse-qxl.h
> +++ b/server/red-parse-qxl.h
> @@ -64,6 +64,8 @@ static inline RedDrawable *red_drawable_ref(RedDrawable
> *drawable)
>      return drawable;
>  }
>  
> +void red_drawable_unref(RedDrawable *red_drawable);
> +
>  typedef struct RedUpdateCmd {
>      QXLReleaseInfoExt release_info_ext;
>      SpiceRect area;
> diff --git a/server/red-qxl.c b/server/red-qxl.c
> index ef39f0e..d255eb6 100644
> --- a/server/red-qxl.c
> +++ b/server/red-qxl.c
> @@ -81,7 +81,7 @@ static void red_qxl_set_display_peer(RedChannel *channel,
> RedClient *client,
>      Dispatcher *dispatcher;
>  
>      spice_debug("%s", "");
> -    dispatcher = (Dispatcher *)channel->data;
> +    dispatcher = (Dispatcher *)g_object_get_data(G_OBJECT(channel),
> "dispatcher");
>      payload.client = client;
>      payload.stream = stream;
>      payload.migration = migration;
> @@ -108,7 +108,7 @@ static void
> red_qxl_disconnect_display_peer(RedChannelClient *rcc)
>          return;
>      }
>  
> -    dispatcher = (Dispatcher *)channel->data;
> +    dispatcher = (Dispatcher *)g_object_get_data(G_OBJECT(channel),
> "dispatcher");
>  
>      spice_printerr("");
>      payload.rcc = rcc;
> @@ -125,11 +125,14 @@ static void red_qxl_display_migrate(RedChannelClient
> *rcc)
>      RedWorkerMessageDisplayMigrate payload;
>      Dispatcher *dispatcher;
>      RedChannel *channel = red_channel_client_get_channel(rcc);
> +    uint32_t type, id;
> +
>      if (!channel) {
>          return;
>      }
> -    dispatcher = (Dispatcher *)channel->data;
> -    spice_printerr("channel type %u id %u", channel->type, channel->id);
> +    g_object_get(channel, "channel-type", &type, "id", &id, NULL);
> +    dispatcher = (Dispatcher *)g_object_get_data(G_OBJECT(channel),
> "dispatcher");
> +    spice_printerr("channel type %u id %u", type, id);
>      payload.rcc = rcc;
>      dispatcher_send_message(dispatcher,
>                              RED_WORKER_MESSAGE_DISPLAY_MIGRATE,
> @@ -142,7 +145,7 @@ static void red_qxl_set_cursor_peer(RedChannel *channel,
> RedClient *client, Reds
>                                      uint32_t *caps)
>  {
>      RedWorkerMessageCursorConnect payload = {0,};
> -    Dispatcher *dispatcher = (Dispatcher *)channel->data;
> +    Dispatcher *dispatcher = (Dispatcher
> *)g_object_get_data(G_OBJECT(channel), "dispatcher");
>      spice_printerr("");
>      payload.client = client;
>      payload.stream = stream;
> @@ -170,7 +173,7 @@ static void
> red_qxl_disconnect_cursor_peer(RedChannelClient *rcc)
>          return;
>      }
>  
> -    dispatcher = (Dispatcher *)channel->data;
> +    dispatcher = (Dispatcher *)g_object_get_data(G_OBJECT(channel),
> "dispatcher");
>      spice_printerr("");
>      payload.rcc = rcc;
>  
> @@ -184,12 +187,14 @@ static void red_qxl_cursor_migrate(RedChannelClient
> *rcc)
>      RedWorkerMessageCursorMigrate payload;
>      Dispatcher *dispatcher;
>      RedChannel *channel = red_channel_client_get_channel(rcc);
> +    uint32_t type, id;
>  
>      if (!channel) {
>          return;
>      }
> -    dispatcher = (Dispatcher *)channel->data;
> -    spice_printerr("channel type %u id %u", channel->type, channel->id);
> +    g_object_get(channel, "channel-type", &type, "id", &id, NULL);
> +    dispatcher = (Dispatcher *)g_object_get_data(G_OBJECT(channel),
> "dispatcher");
> +    spice_printerr("channel type %u id %u", type, id);
>      payload.rcc = rcc;
>      dispatcher_send_message(dispatcher,
>                              RED_WORKER_MESSAGE_CURSOR_MIGRATE,
> diff --git a/server/red-replay-qxl.c b/server/red-replay-qxl.c
> index 281bc7a..a64d438 100644
> --- a/server/red-replay-qxl.c
> +++ b/server/red-replay-qxl.c
> @@ -24,7 +24,7 @@
>  #include <zlib.h>
>  #include <pthread.h>
>  #include "reds.h"
> -#include "red-worker.h"
> +#include "red-qxl.h"
>  #include "red-common.h"
>  #include "memslot.h"
>  #include "red-parse-qxl.h"
> diff --git a/server/red-worker.c b/server/red-worker.c
> index 5be29aa..0d462b5 100644
> --- a/server/red-worker.c
> +++ b/server/red-worker.c
> @@ -23,16 +23,12 @@
>  
>  #include <stdio.h>
>  #include <stdarg.h>
> -#include <fcntl.h>
> -#include <sys/socket.h>
> -#include <netinet/in.h>
>  #include <stdlib.h>
>  #include <errno.h>
>  #include <string.h>
>  #include <unistd.h>
>  #include <poll.h>
>  #include <pthread.h>
> -#include <netinet/tcp.h>
>  #include <openssl/ssl.h>
>  #include <inttypes.h>
>  #include <glib.h>
> @@ -97,33 +93,8 @@ static RedsState* red_worker_get_server(RedWorker
> *worker);
>  
>  static int display_is_connected(RedWorker *worker)
>  {
> -    return (worker->display_channel && red_channel_is_connected(
> -        &worker->display_channel->common.base));
> -}
> -
> -static uint8_t *common_alloc_recv_buf(RedChannelClient *rcc, uint16_t type,
> uint32_t size)
> -{
> -    RedChannel *channel = red_channel_client_get_channel(rcc);
> -    CommonGraphicsChannel *common = SPICE_CONTAINEROF(channel,
> CommonGraphicsChannel, base);
> -
> -    /* SPICE_MSGC_MIGRATE_DATA is the only client message whose size is
> dynamic */
> -    if (type == SPICE_MSGC_MIGRATE_DATA) {
> -        return spice_malloc(size);
> -    }
> -
> -    if (size > CHANNEL_RECEIVE_BUF_SIZE) {
> -        spice_critical("unexpected message size %u (max is %d)", size,
> CHANNEL_RECEIVE_BUF_SIZE);
> -        return NULL;
> -    }
> -    return common->recv_buf;
> -}
> -
> -static void common_release_recv_buf(RedChannelClient *rcc, uint16_t type,
> uint32_t size,
> -                                    uint8_t* msg)
> -{
> -    if (type == SPICE_MSGC_MIGRATE_DATA) {
> -        free(msg);
> -    }
> +    return worker->display_channel &&
> +        red_channel_is_connected(RED_CHANNEL(worker->display_channel));
>  }
>  
>  void red_drawable_unref(RedDrawable *red_drawable)
> @@ -244,7 +215,7 @@ static int red_process_display(RedWorker *worker, int
> *ring_is_empty)
>                                     &update, ext_cmd.cmd.data)) {
>                  break;
>              }
> -            if (!validate_surface(worker->display_channel,
> update.surface_id)) {
> +            if (!display_channel_validate_surface(worker->display_channel,
> update.surface_id)) {
>                  spice_warning("Invalid surface in QXL_CMD_UPDATE");
>              } else {
>                  display_channel_draw(worker->display_channel, &update.area,
>                  update.surface_id);
> @@ -285,7 +256,7 @@ static int red_process_display(RedWorker *worker, int
> *ring_is_empty)
>              spice_error("bad command type");
>          }
>          n++;
> -        if (red_channel_all_blocked(&worker->display_channel->common.base)
> +        if (red_channel_all_blocked(RED_CHANNEL(worker->display_channel))
>              || spice_get_monotonic_time_ns() - start > NSEC_PER_SEC / 100) {
>              worker->event_timeout = 0;
>              return n;
> @@ -398,80 +369,6 @@ static void flush_all_qxl_commands(RedWorker *worker)
>      flush_cursor_commands(worker);
>  }
>  
> -static int common_channel_config_socket(RedChannelClient *rcc)
> -{
> -    RedClient *client = red_channel_client_get_client(rcc);
> -    MainChannelClient *mcc = red_client_get_main(client);
> -    RedsStream *stream = red_channel_client_get_stream(rcc);
> -    CommonGraphicsChannelClient *ccc = COMMON_GRAPHICS_CHANNEL_CLIENT(rcc);
> -    int flags;
> -    int delay_val;
> -    gboolean low_bw;
> -
> -    if ((flags = fcntl(stream->socket, F_GETFL)) == -1) {
> -        spice_warning("accept failed, %s", strerror(errno));
> -        return FALSE;
> -    }
> -
> -    if (fcntl(stream->socket, F_SETFL, flags | O_NONBLOCK) == -1) {
> -        spice_warning("accept failed, %s", strerror(errno));
> -        return FALSE;
> -    }
> -
> -    // TODO - this should be dynamic, not one time at channel creation
> -    low_bw = main_channel_client_is_low_bandwidth(mcc);
> -    common_graphics_channel_client_set_low_bandwidth(ccc, low_bw);
> -    delay_val = low_bw ? 0 : 1;
> -    /* FIXME: Using Nagle's Algorithm can lead to apparent delays, depending
> -     * on the delayed ack timeout on the other side.
> -     * Instead of using Nagle's, we need to implement message buffering on
> -     * the application level.
> -     * see: http://www.stuartcheshire.org/papers/NagleDelayedAck/
> -     */
> -    if (setsockopt(stream->socket, IPPROTO_TCP, TCP_NODELAY, &delay_val,
> -                   sizeof(delay_val)) == -1) {
> -        if (errno != ENOTSUP) {
> -            spice_warning("setsockopt failed, %s", strerror(errno));
> -        }
> -    }
> -    return TRUE;
> -}
> -
> -CommonGraphicsChannel *red_worker_new_channel(RedWorker *worker, int size,
> -                                              const char *name,
> -                                              uint32_t channel_type, int
> migration_flags,
> -                                              ChannelCbs *channel_cbs,
> -                                              channel_handle_parsed_proc
> handle_parsed)
> -{
> -    RedChannel *channel = NULL;
> -    CommonGraphicsChannel *common;
> -
> -    spice_return_val_if_fail(worker, NULL);
> -    spice_return_val_if_fail(channel_cbs, NULL);
> -    spice_return_val_if_fail(!channel_cbs->config_socket, NULL);
> -    spice_return_val_if_fail(!channel_cbs->alloc_recv_buf, NULL);
> -    spice_return_val_if_fail(!channel_cbs->release_recv_buf, NULL);
> -
> -    channel_cbs->config_socket = common_channel_config_socket;
> -    channel_cbs->alloc_recv_buf = common_alloc_recv_buf;
> -    channel_cbs->release_recv_buf = common_release_recv_buf;
> -
> -    channel = red_channel_create_parser(size, red_worker_get_server(worker),
> -                                        &worker->core, channel_type,
> -                                        worker->qxl->id, TRUE /* handle_acks
> */,
> -
> spice_get_client_channel_parser(channel_type,
> NULL),
> -                                        handle_parsed,
> -                                        channel_cbs,
> -                                        migration_flags);
> -    spice_return_val_if_fail(channel, NULL);
> -    red_channel_set_stat_node(channel,
> stat_add_node(red_worker_get_server(worker),
> -                                                     worker->stat, name,
> TRUE));
> -
> -    common = (CommonGraphicsChannel *)channel;
> -    common->qxl = worker->qxl;
> -    return common;
> -}
> -
>  static void guest_set_client_capabilities(RedWorker *worker)
>  {
>      int i;
> @@ -503,7 +400,7 @@ static void guest_set_client_capabilities(RedWorker
> *worker)
>          return;
>      }
>      if ((worker->display_channel == NULL) ||
> -        (RED_CHANNEL(worker->display_channel)->clients_num == 0)) {
> +        (red_channel_get_n_clients(RED_CHANNEL(worker->display_channel)) ==
> 0)) {
>          red_qxl_set_client_capabilities(worker->qxl, FALSE, caps);
>      } else {
>          // Take least common denominator
> @@ -542,7 +439,7 @@ static void cursor_connect(RedWorker *worker, RedClient
> *client, RedsStream *str
>      red_channel_client_ack_zero_messages_window(rcc);
>      red_channel_client_push_set_ack(rcc);
>  
> -    cursor_channel_init(channel, ccc);
> +    cursor_channel_do_init(channel, ccc);
>  }
>  
>  static void handle_dev_update_async(void *opaque, void *payload)
> @@ -608,18 +505,6 @@ static void handle_dev_destroy_surfaces(void *opaque,
> void *payload)
>      cursor_channel_reset(worker->cursor_channel);
>  }
>  
> -static void display_update_monitors_config(DisplayChannel *display,
> -                                           QXLMonitorsConfig *config,
> -                                           uint16_t count, uint16_t
> max_allowed)
> -{
> -
> -    if (display->monitors_config)
> -        monitors_config_unref(display->monitors_config);
> -
> -    display->monitors_config =
> -        monitors_config_new(config->heads, count, max_allowed);
> -}
> -
>  static void red_worker_push_monitors_config(RedWorker *worker)
>  {
>      DisplayChannelClient *dcc;
> @@ -630,21 +515,6 @@ static void red_worker_push_monitors_config(RedWorker
> *worker)
>      }
>  }
>  
> -static void set_monitors_config_to_primary(DisplayChannel *display)
> -{
> -    DrawContext *context = &display->surfaces[0].context;
> -    QXLHead head = { 0, };
> -
> -    spice_return_if_fail(display->surfaces[0].context.canvas);
> -
> -    if (display->monitors_config)
> -        monitors_config_unref(display->monitors_config);
> -
> -    head.width = context->width;
> -    head.height = context->height;
> -    display->monitors_config = monitors_config_new(&head, 1, 1);
> -}
> -
>  static void dev_create_primary_surface(RedWorker *worker, uint32_t
>  surface_id,
>                                         QXLDevSurfaceCreate surface)
>  {
> @@ -675,20 +545,22 @@ static void dev_create_primary_surface(RedWorker
> *worker, uint32_t surface_id,
>  
>      display_channel_create_surface(display, 0, surface.width,
>      surface.height, surface.stride, surface.format,
>                                     line_0, surface.flags &
>                                     QXL_SURF_FLAG_KEEP_DATA, TRUE);
> -    set_monitors_config_to_primary(display);
> +    display_channel_set_monitors_config_to_primary(display);
>  
> -    if (display_is_connected(worker) &&
> !worker->display_channel->common.during_target_migrate) {
> +    if (display_is_connected(worker) &&
> +
> !common_graphics_channel_get_during_target_migrate(COMMON_GRAPHICS_CHANNEL(worker->display_channel)))
> +    {
>          /* guest created primary, so it will (hopefully) send a
>          monitors_config
>           * now, don't send our own temporary one */
>          if (!worker->driver_cap_monitors_config) {
>              red_worker_push_monitors_config(worker);
>          }
> -        red_pipes_add_verb(&worker->display_channel->common.base,
> +        red_pipes_add_verb(RED_CHANNEL(worker->display_channel),
>                             SPICE_MSG_DISPLAY_MARK);
> -        red_channel_push(&worker->display_channel->common.base);
> +        red_channel_push(RED_CHANNEL(worker->display_channel));
>      }
>  
> -    cursor_channel_init(worker->cursor_channel, NULL);
> +    cursor_channel_do_init(worker->cursor_channel, NULL);
>  }
>  
>  static void handle_dev_create_primary_surface(void *opaque, void *payload)
> @@ -703,12 +575,12 @@ static void destroy_primary_surface(RedWorker *worker,
> uint32_t surface_id)
>  {
>      DisplayChannel *display = worker->display_channel;
>  
> -    if (!validate_surface(display, surface_id))
> +    if (!display_channel_validate_surface(display, surface_id))
>          return;
>      spice_warn_if_fail(surface_id == 0);
>  
>      spice_debug(NULL);
> -    if (!display->surfaces[surface_id].context.canvas) {
> +    if (!display_channel_surface_has_canvas(display, surface_id)) {
>          spice_warning("double destroy of primary surface");
>          return;
>      }
> @@ -717,8 +589,10 @@ static void destroy_primary_surface(RedWorker *worker,
> uint32_t surface_id)
>      display_channel_destroy_surface_wait(display, 0);
>      display_channel_surface_unref(display, 0);
>  
> +    /* FIXME: accessing private date only for warning purposes...
>      spice_warn_if_fail(ring_is_empty(&display->streams));
> -    spice_warn_if_fail(!display->surfaces[surface_id].context.canvas);
> +    */
> +    spice_warn_if_fail(!display_channel_surface_has_canvas(display,
> surface_id));
>  
>      cursor_channel_reset(worker->cursor_channel);
>  }
> @@ -784,10 +658,10 @@ static void handle_dev_start(void *opaque, void
> *payload)
>  
>      spice_assert(!worker->running);
>      if (worker->cursor_channel) {
> -
> COMMON_GRAPHICS_CHANNEL(worker->cursor_channel)->during_target_migrate
> = FALSE;
> +
> common_graphics_channel_set_during_target_migrate(COMMON_GRAPHICS_CHANNEL(worker->cursor_channel),
> FALSE);
>      }
>      if (worker->display_channel) {
> -        worker->display_channel->common.during_target_migrate = FALSE;
> +
> common_graphics_channel_set_during_target_migrate(COMMON_GRAPHICS_CHANNEL(worker->display_channel),
> FALSE);
>          display_channel_wait_for_migrate_data(worker->display_channel);
>      }
>      worker->running = TRUE;
> @@ -807,16 +681,18 @@ static void handle_dev_oom(void *opaque, void *payload)
>      RedWorker *worker = opaque;
>      DisplayChannel *display = worker->display_channel;
>  
> -    RedChannel *display_red_channel = &display->common.base;
> +    RedChannel *display_red_channel = RED_CHANNEL(display);
>      int ring_is_empty;
>  
>      spice_return_if_fail(worker->running);
>      // streams? but without streams also leak
> +#if FIXME
>      spice_debug("OOM1 #draw=%u, #glz_draw=%u current %u pipes %u",
>                  display->drawable_count,
>                  display->glz_drawable_count,
>                  display->current_size,
>                  red_channel_sum_pipes_size(display_red_channel));
> +#endif
>      while (red_process_display(worker, &ring_is_empty)) {
>          red_channel_push(display_red_channel);
>      }
> @@ -824,12 +700,14 @@ static void handle_dev_oom(void *opaque, void *payload)
>          display_channel_free_some(worker->display_channel);
>          red_qxl_flush_resources(worker->qxl);
>      }
> +#if FIXME
>      spice_debug("OOM2 #draw=%u, #glz_draw=%u current %u pipes %u",
>                  display->drawable_count,
>                  display->glz_drawable_count,
>                  display->current_size,
>                  red_channel_sum_pipes_size(display_red_channel));
>      red_qxl_clear_pending(worker->qxl->st, RED_DISPATCHER_PENDING_OOM);
> +#endif
>  }
>  
>  static void handle_dev_reset_cursor(void *opaque, void *payload)
> @@ -842,9 +720,7 @@ static void handle_dev_reset_cursor(void *opaque, void
> *payload)
>  static void handle_dev_reset_image_cache(void *opaque, void *payload)
>  {
>      RedWorker *worker = opaque;
> -    DisplayChannel *display = worker->display_channel;
> -
> -    image_cache_reset(&display->image_cache);
> +    display_channel_reset_image_cache(worker->display_channel);
>  }
>  
>  static void handle_dev_destroy_surface_wait_async(void *opaque, void
>  *payload)
> @@ -964,7 +840,7 @@ static void handle_dev_monitors_config_async(void
> *opaque, void *payload)
>          /* TODO: raise guest bug (requires added QXL interface) */
>          return;
>      }
> -    display_update_monitors_config(worker->display_channel,
> dev_monitors_config,
> +    display_channel_update_monitors_config(worker->display_channel,
> dev_monitors_config,
>                                     MIN(count, msg->max_monitors),
>                                     MIN(max_allowed, msg->max_monitors));
>      red_worker_push_monitors_config(worker);
> @@ -1509,17 +1385,28 @@ RedWorker* red_worker_new(QXLInstance *qxl,
>  
>      worker->event_timeout = INF_EVENT_WAIT;
>  
> -    worker->cursor_channel = cursor_channel_new(worker);
> +    worker->cursor_channel = cursor_channel_new(reds, worker->qxl,
> &worker->core);
> +    red_channel_set_stat_node(RED_CHANNEL(worker->cursor_channel),
> +                              stat_add_node(red_worker_get_server(worker),
> +                                            worker->stat,
> +                                            "cursor_channel", TRUE));
>      channel = RED_CHANNEL(worker->cursor_channel);
>      red_channel_register_client_cbs(channel, client_cursor_cbs, dispatcher);
> +    g_object_set_data(G_OBJECT(channel), "dispatcher", dispatcher);
>      reds_register_channel(reds, channel);
>  
>      // TODO: handle seemless migration. Temp, setting migrate to FALSE
> -    worker->display_channel = display_channel_new(reds, worker, FALSE,
> reds_get_streaming_video(reds),
> +    worker->display_channel = display_channel_new(reds, worker->qxl,
> &worker->core,
> +                                                  FALSE,
> reds_get_streaming_video(reds),
>                                                    init_info.n_surfaces);
> +    red_channel_set_stat_node(RED_CHANNEL(worker->display_channel),
> +                              stat_add_node(red_worker_get_server(worker),
> +                                            worker->stat,
> +                                            "display_channel", TRUE));
>  
>      channel = RED_CHANNEL(worker->display_channel);
>      red_channel_register_client_cbs(channel, client_display_cbs,
>      dispatcher);
> +    g_object_set_data(G_OBJECT(channel), "dispatcher", dispatcher);
>      red_channel_set_cap(channel, SPICE_DISPLAY_CAP_MONITORS_CONFIG);
>      red_channel_set_cap(channel, SPICE_DISPLAY_CAP_PREF_COMPRESSION);
>      red_channel_set_cap(channel, SPICE_DISPLAY_CAP_STREAM_REPORT);
> @@ -1536,8 +1423,8 @@ SPICE_GNUC_NORETURN static void *red_worker_main(void
> *arg)
>      spice_assert(MAX_PIPE_SIZE > WIDE_CLIENT_ACK_WINDOW &&
>             MAX_PIPE_SIZE > NARROW_CLIENT_ACK_WINDOW); //ensure wakeup by ack
>             message
>  
> -    RED_CHANNEL(worker->cursor_channel)->thread_id = pthread_self();
> -    RED_CHANNEL(worker->display_channel)->thread_id = pthread_self();
> +    red_channel_reset_thread_id(RED_CHANNEL(worker->cursor_channel));
> +    red_channel_reset_thread_id(RED_CHANNEL(worker->display_channel));
>  
>      GMainLoop *loop = g_main_loop_new(worker->core.main_context, FALSE);
>      g_main_loop_run(loop);
> diff --git a/server/red-worker.h b/server/red-worker.h
> index 501128b..ebc5a97 100644
> --- a/server/red-worker.h
> +++ b/server/red-worker.h
> @@ -25,73 +25,9 @@
>  
>  typedef struct RedWorker RedWorker;
>  
> -#define COMMON_CLIENT_TIMEOUT (NSEC_PER_SEC * 30)
> -
> -#define CHANNEL_RECEIVE_BUF_SIZE 1024
> -typedef struct CommonGraphicsChannel {
> -    RedChannel base; // Must be the first thing
> -
> -    QXLInstance *qxl;
> -    uint8_t recv_buf[CHANNEL_RECEIVE_BUF_SIZE];
> -    uint32_t id_alloc; // bitfield. TODO - use this instead of shift scheme.
> -    int during_target_migrate; /* TRUE when the client that is associated
> with the channel
> -                                  is during migration. Turned off when the
> vm is started.
> -                                  The flag is used to avoid sending messages
> that are artifacts
> -                                  of the transition from stopped vm to
> loaded vm (e.g., recreation
> -                                  of the primary surface) */
> -} CommonGraphicsChannel;
> -
> -#define COMMON_GRAPHICS_CHANNEL(Channel) ((CommonGraphicsChannel*)(Channel))
> -
> -enum {
> -    RED_PIPE_ITEM_TYPE_VERB = RED_PIPE_ITEM_TYPE_CHANNEL_BASE,
> -    RED_PIPE_ITEM_TYPE_INVAL_ONE,
> -
> -    RED_PIPE_ITEM_TYPE_COMMON_LAST
> -};
> -
> -typedef struct RedVerbItem {
> -    RedPipeItem base;
> -    uint16_t verb;
> -} RedVerbItem;
> -
> -static inline void red_marshall_verb(RedChannelClient *rcc, RedVerbItem
> *item)
> -{
> -    red_channel_client_init_send_data(rcc, item->verb, NULL);
> -}
> -
> -static inline void red_pipe_add_verb(RedChannelClient* rcc, uint16_t verb)
> -{
> -    RedVerbItem *item = spice_new(RedVerbItem, 1);
> -
> -    red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_VERB);
> -    item->verb = verb;
> -    red_channel_client_pipe_add(rcc, &item->base);
> -}
> -
> -static inline void red_pipe_add_verb_proxy(RedChannelClient *rcc, gpointer
> data)
> -{
> -    uint16_t verb = GPOINTER_TO_UINT(data);
> -    red_pipe_add_verb(rcc, verb);
> -}
> -
> -
> -static inline void red_pipes_add_verb(RedChannel *channel, uint16_t verb)
> -{
> -    red_channel_apply_clients_data(channel, red_pipe_add_verb_proxy,
> GUINT_TO_POINTER(verb));
> -}
> -
>  RedWorker* red_worker_new(QXLInstance *qxl,
>                            const ClientCbs *client_cursor_cbs,
>                            const ClientCbs *client_display_cbs);
>  bool       red_worker_run(RedWorker *worker);
>  
> -void red_drawable_unref(RedDrawable *red_drawable);
> -
> -CommonGraphicsChannel *red_worker_new_channel(RedWorker *worker, int size,
> -                                              const char *name,
> -                                              uint32_t channel_type, int
> migration_flags,
> -                                              ChannelCbs *channel_cbs,
> -                                              channel_handle_parsed_proc
> handle_parsed);
> -
>  #endif
> diff --git a/server/reds-private.h b/server/reds-private.h
> index 74a251b..4b86d2d 100644
> --- a/server/reds-private.h
> +++ b/server/reds-private.h
> @@ -120,8 +120,7 @@ struct RedsState {
>      Ring mig_target_clients;
>      int num_mig_target_clients;
>  
> -    int num_of_channels;
> -    Ring channels;
> +    GList *channels;
>      int mouse_mode;
>      int is_client_mouse_allowed;
>      int dispatcher_allows_client_mouse;
> diff --git a/server/reds.c b/server/reds.c
> index 9f5551e..27fc5da 100644
> --- a/server/reds.c
> +++ b/server/reds.c
> @@ -463,15 +463,13 @@ void stat_update_value(RedsState *reds, uint32_t value)
>  void reds_register_channel(RedsState *reds, RedChannel *channel)
>  {
>      spice_assert(reds);
> -    ring_add(&reds->channels, &channel->link);
> -    reds->num_of_channels++;
> +    reds->channels = g_list_append(reds->channels, channel);
>  }
>  
>  void reds_unregister_channel(RedsState *reds, RedChannel *channel)
>  {
> -    if (ring_item_is_linked(&channel->link)) {
> -        ring_remove(&channel->link);
> -        reds->num_of_channels--;
> +    if (g_list_find(reds->channels, channel)) {
> +        reds->channels = g_list_remove(reds->channels, channel);
>      } else {
>          spice_warning("not found");
>      }
> @@ -479,11 +477,13 @@ void reds_unregister_channel(RedsState *reds,
> RedChannel *channel)
>  
>  static RedChannel *reds_find_channel(RedsState *reds, uint32_t type,
>  uint32_t id)
>  {
> -    RingItem *now;
> +    GList *l;
>  
> -    RING_FOREACH(now, &reds->channels) {
> -        RedChannel *channel = SPICE_CONTAINEROF(now, RedChannel, link);
> -        if (channel->type == type && channel->id == id) {
> +    for (l = reds->channels; l != NULL; l = l->next) {
> +        RedChannel *channel = l->data;
> +        uint32_t this_type, this_id;
> +        g_object_get(channel, "channel-type", &this_type, "id", &this_id,
> NULL);
> +        if (this_type == type && this_id == id) {
>              return channel;
>          }
>      }
> @@ -552,7 +552,7 @@ static void reds_reset_vdp(RedsState *reds)
>       *  In addition, there used to be a misshandling of AGENT_TOKENS message
>       in spice-gtk: it
>       *  overrides the amount of tokens, instead of adding the given amount.
>       */
> -    if (red_channel_test_remote_cap(&reds->main_channel->base,
> +    if (red_channel_test_remote_cap(RED_CHANNEL(reds->main_channel),
>                                      SPICE_MAIN_CAP_AGENT_CONNECTED_TOKENS))
>                                      {
>          dev->priv->agent_attached = FALSE;
>      } else {
> @@ -743,7 +743,7 @@ static void reds_agent_remove(RedsState *reds)
>      reds->vdagent = NULL;
>      reds_update_mouse_mode(reds);
>      if (reds_main_channel_connected(reds) &&
> -        !red_channel_is_waiting_for_migrate_data(&reds->main_channel->base))
> {
> +
> !red_channel_is_waiting_for_migrate_data(RED_CHANNEL(reds->main_channel)))
> {
>          main_channel_push_agent_disconnected(reds->main_channel);
>      }
>  }
> @@ -995,7 +995,9 @@ SPICE_GNUC_VISIBLE int
> spice_server_get_num_clients(SpiceServer *reds)
>  
>  static int channel_supports_multiple_clients(RedChannel *channel)
>  {
> -    switch (channel->type) {
> +    uint32_t type;
> +    g_object_get(channel, "channel-type", &type, NULL);
> +    switch (type) {
>      case SPICE_CHANNEL_MAIN:
>      case SPICE_CHANNEL_DISPLAY:
>      case SPICE_CHANNEL_CURSOR:
> @@ -1007,23 +1009,25 @@ static int
> channel_supports_multiple_clients(RedChannel *channel)
>  
>  static void reds_fill_channels(RedsState *reds, SpiceMsgChannels
>  *channels_info)
>  {
> -    RingItem *now;
> +    GList *l;
>      int used_channels = 0;
>  
> -    RING_FOREACH(now, &reds->channels) {
> -        RedChannel *channel = SPICE_CONTAINEROF(now, RedChannel, link);
> +    for (l = reds->channels; l != NULL; l = l->next) {
> +        uint32_t type, id;
> +        RedChannel *channel = l->data;
>          if (reds->num_clients > 1 &&
>              !channel_supports_multiple_clients(channel)) {
>              continue;
>          }
> -        channels_info->channels[used_channels].type = channel->type;
> -        channels_info->channels[used_channels].id = channel->id;
> +        g_object_get(channel, "channel-type", &type, "id", &id, NULL);
> +        channels_info->channels[used_channels].type = type;
> +        channels_info->channels[used_channels].id = id;
>          used_channels++;
>      }
>  
>      channels_info->num_of_channels = used_channels;
> -    if (used_channels != reds->num_of_channels) {
> -        spice_warning("sent %d out of %d", used_channels,
> reds->num_of_channels);
> +    if (used_channels != g_list_length(reds->channels)) {
> +        spice_warning("sent %d out of %d", used_channels,
> g_list_length(reds->channels));
>      }
>  }
>  
> @@ -1034,7 +1038,7 @@ SpiceMsgChannels *reds_msg_channels_new(RedsState
> *reds)
>      spice_assert(reds != NULL);
>  
>      channels_info = (SpiceMsgChannels
>      *)spice_malloc(sizeof(SpiceMsgChannels)
> -                            + reds->num_of_channels *
> sizeof(SpiceChannelId));
> +                            + g_list_length(reds->channels) *
> sizeof(SpiceChannelId));
>  
>      reds_fill_channels(reds, channels_info);
>  
> @@ -1546,12 +1550,12 @@ static int reds_send_link_ack(RedsState *reds,
> RedLinkInfo *link)
>              return FALSE;
>          }
>          spice_assert(reds->main_channel);
> -        channel = &reds->main_channel->base;
> +        channel = RED_CHANNEL(reds->main_channel);
>      }
>  
>      reds_channel_init_auth_caps(link, channel); /* make sure common caps are
>      set */
>  
> -    channel_caps = &channel->local_caps;
> +    channel_caps = red_channel_get_local_capabilities(channel);
>      ack.num_common_caps = GUINT32_TO_LE(channel_caps->num_common_caps);
>      ack.num_channel_caps = GUINT32_TO_LE(channel_caps->num_caps);
>      hdr_size += channel_caps->num_common_caps * sizeof(uint32_t);
> @@ -1888,13 +1892,13 @@ static void reds_channel_do_link(RedChannel *channel,
> RedClient *client,
>      spice_assert(stream);
>  
>      caps = (uint32_t *)((uint8_t *)link_msg + link_msg->caps_offset);
> -    channel->client_cbs.connect(channel, client, stream,
> -                                red_client_during_migrate_at_target(client),
> -                                link_msg->num_common_caps,
> -                                link_msg->num_common_caps ? caps : NULL,
> -                                link_msg->num_channel_caps,
> -                                link_msg->num_channel_caps ?
> -                                caps + link_msg->num_common_caps : NULL);
> +    red_channel_connect(channel, client, stream,
> +                        red_client_during_migrate_at_target(client),
> +                        link_msg->num_common_caps,
> +                        link_msg->num_common_caps ? caps : NULL,
> +                        link_msg->num_channel_caps,
> +                        link_msg->num_channel_caps ?
> +                        caps + link_msg->num_common_caps : NULL);
>  }
>  
>  /*
> @@ -3123,7 +3127,7 @@ static RedCharDevice *attach_to_red_agent(RedsState
> *reds, SpiceCharDeviceInstan
>      dev->priv->plug_generation++;
>  
>      if (dev->priv->mig_data ||
> -        red_channel_is_waiting_for_migrate_data(&reds->main_channel->base))
> {
> +
> red_channel_is_waiting_for_migrate_data(RED_CHANNEL(reds->main_channel)))
> {
>          /* Migration in progress (code is running on the destination host):
>           * 1.  Add the client to spice char device, if it was not already
>           added.
>           * 2.a If this (qemu-kvm state load side of migration) happens first
> @@ -3442,7 +3446,6 @@ static int do_spice_init(RedsState *reds,
> SpiceCoreInterface *core_interface)
>      ring_init(&reds->clients);
>      reds->num_clients = 0;
>      reds->main_dispatcher = main_dispatcher_new(reds, reds->core);
> -    ring_init(&reds->channels);
>      ring_init(&reds->mig_target_clients);
>      reds->char_devices = NULL;
>      reds->mig_wait_disconnect_clients = NULL;
> @@ -3986,7 +3989,7 @@ SPICE_GNUC_VISIBLE int
> spice_server_migrate_connect(SpiceServer *reds, const cha
>       * be valid (see reds_reset_vdp for more details).
>       */
>      try_seamless = reds->seamless_migration_enabled &&
> -                   red_channel_test_remote_cap(&reds->main_channel->base,
> +
> red_channel_test_remote_cap(RED_CHANNEL(reds->main_channel),
>                     SPICE_MAIN_CAP_AGENT_CONNECTED_TOKENS);
>      /* main channel will take care of clients that are still during
>      migration (at target)*/
>      if (main_channel_migrate_connect(reds->main_channel,
>      reds->config->mig_spice,
> diff --git a/server/smartcard.c b/server/smartcard.c
> index ec42960..c681d39 100644
> --- a/server/smartcard.c
> +++ b/server/smartcard.c
> @@ -49,6 +49,61 @@
>  // Maximal length of APDU
>  #define APDUBufSize 270
>  
> +#define RED_TYPE_SMARTCARD_CHANNEL red_smartcard_channel_get_type()
> +
> +#define RED_SMARTCARD_CHANNEL(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),
> RED_TYPE_SMARTCARD_CHANNEL, RedSmartcardChannel))
> +#define RED_SMARTCARD_CHANNEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),
> RED_TYPE_SMARTCARD_CHANNEL, RedSmartcardChannelClass))
> +#define RED_IS_SMARTCARD_CHANNEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),
> RED_TYPE_SMARTCARD_CHANNEL))
> +#define RED_IS_SMARTCARD_CHANNEL_CLASS(klass)
> (G_TYPE_CHECK_CLASS_TYPE((klass), RED_TYPE_SMARTCARD_CHANNEL))
> +#define RED_SMARTCARD_CHANNEL_GET_CLASS(obj)
> (G_TYPE_INSTANCE_GET_CLASS((obj), RED_TYPE_SMARTCARD_CHANNEL,
> RedSmartcardChannelClass))
> +
> +typedef struct RedSmartcardChannel RedSmartcardChannel;
> +typedef struct RedSmartcardChannelClass RedSmartcardChannelClass;
> +typedef struct RedSmartcardChannelPrivate RedSmartcardChannelPrivate;
> +
> +struct RedSmartcardChannel
> +{
> +    RedChannel parent;
> +
> +    RedSmartcardChannelPrivate *priv;
> +};
> +
> +struct RedSmartcardChannelClass
> +{
> +    RedChannelClass parent_class;
> +};
> +
> +GType red_smartcard_channel_get_type(void) G_GNUC_CONST;
> +
> +G_DEFINE_TYPE(RedSmartcardChannel, red_smartcard_channel, RED_TYPE_CHANNEL)
> +
> +#define SMARTCARD_CHANNEL_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o),
> RED_TYPE_SMARTCARD_CHANNEL, RedSmartcardChannelPrivate))
> +
> +struct RedSmartcardChannelPrivate
> +{
> +    gpointer padding;
> +};
> +
> +static void
> +red_smartcard_channel_init(RedSmartcardChannel *self)
> +{
> +    self->priv = SMARTCARD_CHANNEL_PRIVATE(self);
> +}
> +
> +RedSmartcardChannel *
> +red_smartcard_channel_new(RedsState *reds)
> +{
> +    return g_object_new(RED_TYPE_SMARTCARD_CHANNEL,
> +                        "spice-server", reds,
> +                        "core-interface", reds_get_core_interface(reds),
> +                        "channel-type", SPICE_CHANNEL_SMARTCARD,
> +                        "id", 0,
> +                        "handle-acks", FALSE /* handle_acks */,
> +                        "migration-flags", (SPICE_MIGRATE_NEED_FLUSH |
> SPICE_MIGRATE_NEED_DATA_TRANSFER),
> +                        NULL);
> +}
> +
> +
>  G_DEFINE_TYPE(RedCharDeviceSmartcard, red_char_device_smartcard,
>  RED_TYPE_CHAR_DEVICE)
>  
>  #define RED_CHAR_DEVICE_SMARTCARD_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE
>  ((o), RED_TYPE_CHAR_DEVICE_SMARTCARD, RedCharDeviceSmartcardPrivate))
> @@ -74,10 +129,6 @@ typedef struct RedMsgItem {
>  static RedMsgItem *smartcard_get_vsc_msg_item(RedChannelClient *rcc,
>  VSCMsgHeader *vheader);
>  static void smartcard_channel_client_pipe_add_push(RedChannelClient *rcc,
>  RedPipeItem *item);
>  
> -typedef struct SmartCardChannel {
> -    RedChannel base;
> -} SmartCardChannel;
> -
>  static struct Readers {
>      uint32_t num;
>      SpiceCharDeviceInstance* sin[SMARTCARD_MAX_READERS];
> @@ -531,43 +582,53 @@ static void smartcard_connect_client(RedChannel
> *channel, RedClient *client,
>      }
>  }
>  
> -SmartCardChannel *g_smartcard_channel;
> -
> -static void smartcard_init(RedsState *reds)
> +static void
> +red_smartcard_channel_constructed(GObject *object)
>  {
> -    ChannelCbs channel_cbs = { NULL, };
> +    RedSmartcardChannel *self = RED_SMARTCARD_CHANNEL(object);
> +    RedsState *reds = red_channel_get_server(RED_CHANNEL(self));
>      ClientCbs client_cbs = { NULL, };
> -    uint32_t migration_flags = SPICE_MIGRATE_NEED_FLUSH |
> SPICE_MIGRATE_NEED_DATA_TRANSFER;
> -
> -    spice_assert(!g_smartcard_channel);
>  
> -    channel_cbs.config_socket = smartcard_channel_client_config_socket;
> -    channel_cbs.on_disconnect = smartcard_channel_client_on_disconnect;
> -    channel_cbs.send_item = smartcard_channel_send_item;
> -    channel_cbs.hold_item = smartcard_channel_hold_pipe_item;
> -    channel_cbs.release_item = smartcard_channel_release_pipe_item;
> -    channel_cbs.alloc_recv_buf = smartcard_channel_client_alloc_msg_rcv_buf;
> -    channel_cbs.release_recv_buf =
> smartcard_channel_client_release_msg_rcv_buf;
> -    channel_cbs.handle_migrate_flush_mark =
> smartcard_channel_client_handle_migrate_flush_mark;
> -    channel_cbs.handle_migrate_data =
> smartcard_channel_client_handle_migrate_data;
> -
> -    g_smartcard_channel =
> (SmartCardChannel*)red_channel_create(sizeof(SmartCardChannel),
> -                                             reds,
> -                                             reds_get_core_interface(reds),
> -                                             SPICE_CHANNEL_SMARTCARD, 0,
> -                                             FALSE /* handle_acks */,
> -
> smartcard_channel_client_handle_message,
> -                                             &channel_cbs,
> -                                             migration_flags);
> -
> -    if (!g_smartcard_channel) {
> -        spice_error("failed to allocate Smartcard Channel");
> -    }
> +    G_OBJECT_CLASS(red_smartcard_channel_parent_class)->constructed(object);
>  
>      client_cbs.connect = smartcard_connect_client;
> -    red_channel_register_client_cbs(&g_smartcard_channel->base, &client_cbs,
> NULL);
> +    red_channel_register_client_cbs(RED_CHANNEL(self), &client_cbs, NULL);
> +
> +    reds_register_channel(reds, RED_CHANNEL(self));
> +}
> +
> +static void
> +red_smartcard_channel_class_init(RedSmartcardChannelClass *klass)
> +{
> +    GObjectClass *object_class = G_OBJECT_CLASS(klass);
> +    RedChannelClass *channel_class = RED_CHANNEL_CLASS(klass);
> +
> +    g_type_class_add_private(klass, sizeof(RedSmartcardChannelPrivate));
> +
> +    object_class->constructed = red_smartcard_channel_constructed;
> +
> +    channel_class->handle_message = smartcard_channel_client_handle_message,
> +
> +    channel_class->config_socket = smartcard_channel_client_config_socket;
> +    channel_class->on_disconnect = smartcard_channel_client_on_disconnect;
> +    channel_class->send_item = smartcard_channel_send_item;
> +    channel_class->hold_item = smartcard_channel_hold_pipe_item;
> +    channel_class->release_item = smartcard_channel_release_pipe_item;
> +    channel_class->alloc_recv_buf =
> smartcard_channel_client_alloc_msg_rcv_buf;
> +    channel_class->release_recv_buf =
> smartcard_channel_client_release_msg_rcv_buf;
> +    channel_class->handle_migrate_flush_mark =
> smartcard_channel_client_handle_migrate_flush_mark;
> +    channel_class->handle_migrate_data =
> smartcard_channel_client_handle_migrate_data;
> +
> +}
> +
> +/* FIXME: remove global */
> +RedSmartcardChannel *g_smartcard_channel;
> +
> +static void smartcard_init(RedsState *reds)
> +{
> +    spice_assert(!g_smartcard_channel);
>  
> -    reds_register_channel(reds, &g_smartcard_channel->base);
> +    g_smartcard_channel = red_smartcard_channel_new(reds);
>  }
>  
>  
> diff --git a/server/sound.c b/server/sound.c
> index e87428f..6982be3 100644
> --- a/server/sound.c
> +++ b/server/sound.c
> @@ -31,6 +31,7 @@
>  
>  #include "spice.h"
>  #include "red-common.h"
> +#include "dummy-channel.h"
>  #include "dummy-channel-client.h"
>  #include "main-channel.h"
>  #include "main-channel-client.h"
> @@ -218,6 +219,7 @@ static void snd_disconnect_channel(SndChannel *channel)
>      SndWorker *worker;
>      RedsState *reds;
>      RedChannel *red_channel;
> +    uint32_t type;
>  
>      if (!channel || !channel->stream) {
>          spice_debug("not connected");
> @@ -225,8 +227,9 @@ static void snd_disconnect_channel(SndChannel *channel)
>      }
>      red_channel = red_channel_client_get_channel(channel->channel_client);
>      reds = snd_channel_get_server(channel);
> +    g_object_get(red_channel, "channel-type", &type, NULL);
>      spice_debug("SndChannel=%p rcc=%p type=%d",
> -                 channel, channel->channel_client, red_channel->type);
> +                 channel, channel->channel_client, type);
>      worker = channel->worker;
>      channel->cleanup(channel);
>      red_channel_client_disconnect(worker->connection->channel_client);
> @@ -999,12 +1002,14 @@ static void
> snd_disconnect_channel_client(RedChannelClient *rcc)
>  {
>      SndWorker *worker;
>      RedChannel *channel = red_channel_client_get_channel(rcc);
> +    uint32_t type;
>  
>      spice_assert(channel);
> -    spice_assert(channel->data);
> -    worker = (SndWorker *)channel->data;
> +    worker = (SndWorker *)g_object_get_data(G_OBJECT(channel),
> "sound-worker");
> +    spice_assert(worker);
> +    g_object_get(channel, "channel-type", &type, NULL);
>  
> -    spice_debug("channel-type=%d", channel->type);
> +    spice_debug("channel-type=%d", type);
>      if (worker->connection) {
>          spice_assert(worker->connection->channel_client == rcc);
>          snd_disconnect_channel(worker->connection);
> @@ -1059,6 +1064,7 @@ SPICE_GNUC_VISIBLE void
> spice_server_playback_start(SpicePlaybackInstance *sin)
>      sin->st->worker.active = 1;
>      if (!channel)
>          return;
> +
>      spice_assert(!playback_channel->base.active);
>      reds_disable_mm_time(snd_channel_get_server(channel));
>      playback_channel->base.active = TRUE;
> @@ -1078,6 +1084,7 @@ SPICE_GNUC_VISIBLE void
> spice_server_playback_stop(SpicePlaybackInstance *sin)
>      sin->st->worker.active = 0;
>      if (!channel)
>          return;
> +
>      spice_assert(playback_channel->base.active);
>      reds_enable_mm_time(snd_channel_get_server(channel));
>      playback_channel->base.active = FALSE;
> @@ -1146,7 +1153,9 @@ void snd_set_playback_latency(RedClient *client,
> uint32_t latency)
>      SndWorker *now = workers;
>  
>      for (; now; now = now->next) {
> -        if (now->base_channel->type == SPICE_CHANNEL_PLAYBACK &&
> now->connection &&
> +        uint32_t type;
> +        g_object_get(now->base_channel, "channel-type", &type, NULL);
> +        if (type == SPICE_CHANNEL_PLAYBACK && now->connection &&
>              red_channel_client_get_client(now->connection->channel_client)
>              == client) {
>  
>              if
>              (red_channel_client_test_remote_cap(now->connection->channel_client,
> @@ -1214,7 +1223,7 @@ static void snd_set_playback_peer(RedChannel *channel,
> RedClient *client, RedsSt
>                                    int migration, int num_common_caps,
>                                    uint32_t *common_caps,
>                                    int num_caps, uint32_t *caps)
>  {
> -    SndWorker *worker = channel->data;
> +    SndWorker *worker = g_object_get_data(G_OBJECT(channel),
> "sound-worker");
>      PlaybackChannel *playback_channel;
>      SpicePlaybackState *st = SPICE_CONTAINEROF(worker, SpicePlaybackState,
>      worker);
>  
> @@ -1243,7 +1252,7 @@ static void snd_set_playback_peer(RedChannel *channel,
> RedClient *client, RedsSt
>                                            SPICE_PLAYBACK_CAP_CELT_0_5_1);
>      int client_can_opus =
>      red_channel_client_test_remote_cap(playback_channel->base.channel_client,
>                                            SPICE_PLAYBACK_CAP_OPUS);
> -    int playback_compression =
> reds_config_get_playback_compression(channel->reds);
> +    int playback_compression =
> reds_config_get_playback_compression(red_channel_get_server(channel));
>      int desired_mode = snd_desired_audio_mode(playback_compression,
>      st->frequency,
>                                                client_can_celt,
>                                                client_can_opus);
>      playback_channel->mode = SPICE_AUDIO_DATA_MODE_RAW;
> @@ -1272,8 +1281,8 @@ static void
> snd_record_migrate_channel_client(RedChannelClient *rcc)
>  
>      spice_debug(NULL);
>      spice_assert(channel);
> -    spice_assert(channel->data);
> -    worker = (SndWorker *)channel->data;
> +    worker = (SndWorker *)g_object_get_data(G_OBJECT(channel),
> "sound-worker");
> +    spice_assert(worker);
>  
>      if (worker->connection) {
>          spice_assert(worker->connection->channel_client == rcc);
> @@ -1463,7 +1472,7 @@ static void snd_set_record_peer(RedChannel *channel,
> RedClient *client, RedsStre
>                                  int migration, int num_common_caps, uint32_t
>                                  *common_caps,
>                                  int num_caps, uint32_t *caps)
>  {
> -    SndWorker *worker = channel->data;
> +    SndWorker *worker = g_object_get_data(G_OBJECT(channel),
> "sound-worker");
>      RecordChannel *record_channel;
>      SpiceRecordState *st = SPICE_CONTAINEROF(worker, SpiceRecordState,
>      worker);
>  
> @@ -1501,8 +1510,8 @@ static void
> snd_playback_migrate_channel_client(RedChannelClient *rcc)
>      RedChannel *channel = red_channel_client_get_channel(rcc);
>  
>      spice_assert(channel);
> -    spice_assert(channel->data);
> -    worker = (SndWorker *)channel->data;
> +    worker = (SndWorker *)g_object_get_data(G_OBJECT(channel),
> "sound-worker");
> +    spice_assert(worker);
>      spice_debug(NULL);
>  
>      if (worker->connection) {
> @@ -1543,8 +1552,9 @@ void snd_attach_playback(RedsState *reds,
> SpicePlaybackInstance *sin)
>      sin->st->frequency = SND_CODEC_CELT_PLAYBACK_FREQ; /* Default to the
>      legacy rate */
>  
>      // TODO: Make RedChannel base of worker? instead of assigning it to
>      channel->data
> -    channel = red_channel_create_dummy(sizeof(RedChannel), reds,
> SPICE_CHANNEL_PLAYBACK, 0);
> +    channel = dummy_channel_new(reds, SPICE_CHANNEL_PLAYBACK, 0);
>  
> +    g_object_set_data(G_OBJECT(channel), "sound-worker", playback_worker);
>      client_cbs.connect = snd_set_playback_peer;
>      client_cbs.disconnect = snd_disconnect_channel_client;
>      client_cbs.migrate = snd_playback_migrate_channel_client;
> @@ -1572,8 +1582,9 @@ void snd_attach_record(RedsState *reds,
> SpiceRecordInstance *sin)
>      sin->st->frequency = SND_CODEC_CELT_PLAYBACK_FREQ; /* Default to the
>      legacy rate */
>  
>      // TODO: Make RedChannel base of worker? instead of assigning it to
>      channel->data
> -    channel = red_channel_create_dummy(sizeof(RedChannel), reds,
> SPICE_CHANNEL_RECORD, 0);
> +    channel = dummy_channel_new(reds, SPICE_CHANNEL_RECORD, 0);
>  
> +    g_object_set_data(G_OBJECT(channel), "sound-worker", record_worker);
>      client_cbs.connect = snd_set_record_peer;
>      client_cbs.disconnect = snd_disconnect_channel_client;
>      client_cbs.migrate = snd_record_migrate_channel_client;
> @@ -1629,7 +1640,9 @@ void snd_set_playback_compression(int on)
>      SndWorker *now = workers;
>  
>      for (; now; now = now->next) {
> -        if (now->base_channel->type == SPICE_CHANNEL_PLAYBACK &&
> now->connection) {
> +        uint32_t type;
> +        g_object_get(now->base_channel, "channel-type", &type, NULL);
> +        if (type == SPICE_CHANNEL_PLAYBACK && now->connection) {
>              PlaybackChannel* playback = (PlaybackChannel*)now->connection;
>              SpicePlaybackState *st = SPICE_CONTAINEROF(now,
>              SpicePlaybackState, worker);
>              int client_can_celt =
>              red_channel_client_test_remote_cap(playback->base.channel_client,
> diff --git a/server/spicevmc.c b/server/spicevmc.c
> index 0b37b4a..6441542 100644
> --- a/server/spicevmc.c
> +++ b/server/spicevmc.c
> @@ -52,16 +52,6 @@ typedef struct RedVmcPipeItem {
>      uint32_t buf_used;
>  } RedVmcPipeItem;
>  
> -typedef struct SpiceVmcState {
> -    RedChannel channel; /* Must be the first item */
> -    RedChannelClient *rcc;
> -    RedCharDevice *chardev;
> -    SpiceCharDeviceInstance *chardev_sin;
> -    RedVmcPipeItem *pipe_item;
> -    RedCharDeviceWriteBuffer *recv_from_client_buf;
> -    uint8_t port_opened;
> -} SpiceVmcState;
> -
>  #define RED_TYPE_CHAR_DEVICE_SPICEVMC red_char_device_spicevmc_get_type()
>  
>  #define RED_CHAR_DEVICE_SPICEVMC(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),
>  RED_TYPE_CHAR_DEVICE_SPICEVMC, RedCharDeviceSpiceVmc))
> @@ -89,6 +79,133 @@ static RedCharDevice
> *red_char_device_spicevmc_new(SpiceCharDeviceInstance *sin,
>  
>  G_DEFINE_TYPE(RedCharDeviceSpiceVmc, red_char_device_spicevmc,
>  RED_TYPE_CHAR_DEVICE)
>  
> +#define RED_CHAR_DEVICE_SPICEVMC_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE
> ((o), RED_TYPE_CHAR_DEVICE_SPICEVMC, RedCharDeviceSpiceVmcPrivate))
> +
> +#define SPICE_TYPE_VMC_STATE spice_vmc_state_get_type()
> +
> +#define SPICE_VMC_STATE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),
> SPICE_TYPE_VMC_STATE, SpiceVmcState))
> +#define SPICE_VMC_STATE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),
> SPICE_TYPE_VMC_STATE, SpiceVmcStateClass))
> +#define SPICE_IS_VMC_STATE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),
> SPICE_TYPE_VMC_STATE))
> +#define SPICE_IS_VMC_STATE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass),
> SPICE_TYPE_VMC_STATE))
> +#define SPICE_VMC_STATE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj),
> SPICE_TYPE_VMC_STATE, SpiceVmcStateClass))
> +
> +typedef struct SpiceVmcState SpiceVmcState;
> +typedef struct SpiceVmcStateClass SpiceVmcStateClass;
> +typedef struct SpiceVmcStatePrivate SpiceVmcStatePrivate;
> +
> +struct SpiceVmcState
> +{
> +    RedChannel parent;
> +
> +    SpiceVmcStatePrivate *priv;
> +};
> +
> +struct SpiceVmcStateClass
> +{
> +    RedChannelClass parent_class;
> +};
> +
> +GType spice_vmc_state_get_type(void) G_GNUC_CONST;
> +
> +G_DEFINE_TYPE(SpiceVmcState, spice_vmc_state, RED_TYPE_CHANNEL)
> +
> +#define VMC_STATE_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o),
> SPICE_TYPE_VMC_STATE, SpiceVmcStatePrivate))
> +
> +struct SpiceVmcStatePrivate
> +{
> +    RedChannelClient *rcc;
> +    RedCharDevice *chardev;
> +    SpiceCharDeviceInstance *chardev_sin;
> +    RedVmcPipeItem *pipe_item;
> +    RedCharDeviceWriteBuffer *recv_from_client_buf;
> +    uint8_t port_opened;
> +};
> +
> +enum {
> +    PROP0,
> +    PROP_DEVICE_INSTANCE
> +};
> +
> +static void
> +spice_vmc_state_get_property(GObject *object,
> +                             guint property_id,
> +                             GValue *value,
> +                             GParamSpec *pspec)
> +{
> +    SpiceVmcState *self = SPICE_VMC_STATE(object);
> +
> +    switch (property_id)
> +    {
> +        case PROP_DEVICE_INSTANCE:
> +            g_value_set_pointer(value, self->priv->chardev_sin);
> +            break;
> +        default:
> +            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
> +    }
> +}
> +
> +static void
> +spice_vmc_state_set_property(GObject *object,
> +                             guint property_id,
> +                             const GValue *value,
> +                             GParamSpec *pspec)
> +{
> +    SpiceVmcState *self = SPICE_VMC_STATE(object);
> +
> +    switch (property_id)
> +    {
> +        case PROP_DEVICE_INSTANCE:
> +            self->priv->chardev_sin = g_value_get_pointer(value);
> +            break;
> +        default:
> +            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
> +    }
> +}
> +
> +static void spicevmc_connect(RedChannel *channel, RedClient *client,
> +                             RedsStream *stream, int migration, int
> num_common_caps,
> +                             uint32_t *common_caps, int num_caps, uint32_t
> *caps);
> +
> +static void
> +spice_vmc_state_constructed(GObject *object)
> +{
> +    SpiceVmcState *self = SPICE_VMC_STATE(object);
> +    ClientCbs client_cbs = { NULL, };
> +    RedsState *reds = red_channel_get_server(RED_CHANNEL(self));
> +
> +    G_OBJECT_CLASS(spice_vmc_state_parent_class)->constructed(object);
> +
> +    client_cbs.connect = spicevmc_connect;
> +    red_channel_register_client_cbs(RED_CHANNEL(self), &client_cbs, NULL);
> +
> +    red_channel_init_outgoing_messages_window(RED_CHANNEL(self));
> +
> +    self->priv->chardev =
> red_char_device_spicevmc_new(self->priv->chardev_sin,
> +                                                          reds, self);
> +
> +    reds_register_channel(reds, RED_CHANNEL(self));
> +}
> +
> +static void
> +spice_vmc_state_init(SpiceVmcState *self)
> +{
> +    self->priv = VMC_STATE_PRIVATE(self);
> +}
> +
> +SpiceVmcState *spice_vmc_state_new(RedsState *reds, uint8_t channel_type,
> SpiceCharDeviceInstance *sin)
> +{
> +    static uint8_t id[256] = { 0, };
> +    return g_object_new(SPICE_TYPE_VMC_STATE,
> +                        "spice-server", reds,
> +                        "core-interface", reds_get_core_interface(reds),
> +                        "channel-type", channel_type,
> +                        "id", id[channel_type]++,
> +                        "handle-acks", FALSE,
> +                        "migration-flags", (SPICE_MIGRATE_NEED_FLUSH |
> SPICE_MIGRATE_NEED_DATA_TRANSFER),
> +                        "device-instance", sin,
> +                        NULL);
> +}
> +
>  typedef struct RedPortInitPipeItem {
>      RedPipeItem base;
>      char* name;
> @@ -117,17 +234,17 @@ static RedPipeItem
> *spicevmc_chardev_read_msg_from_dev(SpiceCharDeviceInstance *
>  
>      sif = spice_char_device_get_interface(sin);
>  
> -    if (!state->rcc) {
> +    if (!state->priv->rcc) {
>          return NULL;
>      }
>  
> -    if (!state->pipe_item) {
> +    if (!state->priv->pipe_item) {
>          msg_item = spice_new0(RedVmcPipeItem, 1);
> -        red_pipe_item_init(&msg_item->base,
> RED_PIPE_ITEM_TYPE_SPICEVMC_DATA);
> +        red_pipe_item_init_full(&msg_item->base,
> RED_PIPE_ITEM_TYPE_SPICEVMC_DATA, free);
>      } else {
> -        spice_assert(state->pipe_item->buf_used == 0);
> -        msg_item = state->pipe_item;
> -        state->pipe_item = NULL;
> +        spice_assert(state->priv->pipe_item->buf_used == 0);
> +        msg_item = state->priv->pipe_item;
> +        state->priv->pipe_item = NULL;
>      }
>  
>      n = sif->read(sin, msg_item->buf,
> @@ -137,7 +254,7 @@ static RedPipeItem
> *spicevmc_chardev_read_msg_from_dev(SpiceCharDeviceInstance *
>          msg_item->buf_used = n;
>          return (RedPipeItem *)msg_item;
>      } else {
> -        state->pipe_item = msg_item;
> +        state->priv->pipe_item = msg_item;
>          return NULL;
>      }
>  }
> @@ -149,21 +266,21 @@ static void
> spicevmc_chardev_send_msg_to_client(RedPipeItem *msg,
>      SpiceVmcState *state = opaque;
>      RedVmcPipeItem *vmc_msg = (RedVmcPipeItem *)msg;
>  
> -    spice_assert(red_channel_client_get_client(state->rcc) == client);
> +    spice_assert(red_channel_client_get_client(state->priv->rcc) == client);
>      red_pipe_item_ref(vmc_msg);
> -    red_channel_client_pipe_add_push(state->rcc, (RedPipeItem *)vmc_msg);
> +    red_channel_client_pipe_add_push(state->priv->rcc, (RedPipeItem
> *)vmc_msg);
>  }
>  
>  static void spicevmc_port_send_init(RedChannelClient *rcc)
>  {
>      RedChannel *channel = red_channel_client_get_channel(rcc);
> -    SpiceVmcState *state = SPICE_CONTAINEROF(channel, SpiceVmcState,
> channel);
> -    SpiceCharDeviceInstance *sin = state->chardev_sin;
> +    SpiceVmcState *state = SPICE_VMC_STATE(channel);
> +    SpiceCharDeviceInstance *sin = state->priv->chardev_sin;
>      RedPortInitPipeItem *item = spice_malloc(sizeof(RedPortInitPipeItem));
>  
>      red_pipe_item_init(&item->base, RED_PIPE_ITEM_TYPE_PORT_INIT);
>      item->name = strdup(sin->portname);
> -    item->opened = state->port_opened;
> +    item->opened = state->priv->port_opened;
>      red_channel_client_pipe_add_push(rcc, &item->base);
>  }
>  
> @@ -188,10 +305,10 @@ static void spicevmc_char_dev_remove_client(RedClient
> *client, void *opaque)
>      SpiceVmcState *state = opaque;
>  
>      spice_printerr("vmc state %p, client %p", state, client);
> -    spice_assert(state->rcc &&
> -                 red_channel_client_get_client(state->rcc) == client);
> +    spice_assert(state->priv->rcc &&
> +                 red_channel_client_get_client(state->priv->rcc) == client);
>  
> -    red_channel_client_shutdown(state->rcc);
> +    red_channel_client_shutdown(state->priv->rcc);
>  }
>  
>  static int spicevmc_red_channel_client_config_socket(RedChannelClient *rcc)
> @@ -199,8 +316,10 @@ static int
> spicevmc_red_channel_client_config_socket(RedChannelClient *rcc)
>      int delay_val = 1;
>      RedsStream *stream = red_channel_client_get_stream(rcc);
>      RedChannel *channel = red_channel_client_get_channel(rcc);
> +    uint32_t type;
>  
> -    if (channel->type == SPICE_CHANNEL_USBREDIR) {
> +    g_object_get(channel, "channel-type", &type, NULL);
> +    if (type == SPICE_CHANNEL_USBREDIR) {
>          if (setsockopt(stream->socket, IPPROTO_TCP, TCP_NODELAY,
>                  &delay_val, sizeof(delay_val)) != 0) {
>              if (errno != ENOTSUP && errno != ENOPROTOOPT) {
> @@ -224,19 +343,19 @@ static void
> spicevmc_red_channel_client_on_disconnect(RedChannelClient *rcc)
>          return;
>      }
>  
> -    state = SPICE_CONTAINEROF(channel, SpiceVmcState, channel);
> +    state = SPICE_VMC_STATE(channel);
>  
> -    if (state->recv_from_client_buf) { /* partial message which wasn't
> pushed to device */
> -        red_char_device_write_buffer_release(state->chardev,
> state->recv_from_client_buf);
> -        state->recv_from_client_buf = NULL;
> +    if (state->priv->recv_from_client_buf) { /* partial message which wasn't
> pushed to device */
> +        red_char_device_write_buffer_release(state->priv->chardev,
> state->priv->recv_from_client_buf);
> +        state->priv->recv_from_client_buf = NULL;
>      }
>  
> -    if (state->chardev) {
> -        if (red_char_device_client_exists(state->chardev, client)) {
> -            red_char_device_client_remove(state->chardev, client);
> +    if (state->priv->chardev) {
> +        if (red_char_device_client_exists(state->priv->chardev, client)) {
> +            red_char_device_client_remove(state->priv->chardev, client);
>          } else {
>              spice_printerr("client %p have already been removed from char
>              dev %p",
> -                           client, state->chardev);
> +                           client, state->priv->chardev);
>          }
>      }
>  
> @@ -245,17 +364,17 @@ static void
> spicevmc_red_channel_client_on_disconnect(RedChannelClient *rcc)
>      if (!red_channel_client_is_destroying(rcc))
>          red_channel_client_destroy(rcc);
>  
> -    state->rcc = NULL;
> -    sif = spice_char_device_get_interface(state->chardev_sin);
> +    state->priv->rcc = NULL;
> +    sif = spice_char_device_get_interface(state->priv->chardev_sin);
>      if (sif->state) {
> -        sif->state(state->chardev_sin, 0);
> +        sif->state(state->priv->chardev_sin, 0);
>      }
>  }
>  
>  static SpiceVmcState *spicevmc_red_channel_client_get_state(RedChannelClient
>  *rcc)
>  {
>      RedChannel *channel = red_channel_client_get_channel(rcc);
> -    return SPICE_CONTAINEROF(channel, SpiceVmcState, channel);
> +    return SPICE_VMC_STATE(channel);
>  }
>  
>  static int
>  spicevmc_channel_client_handle_migrate_flush_mark(RedChannelClient *rcc)
> @@ -283,7 +402,7 @@ static int
> spicevmc_channel_client_handle_migrate_data(RedChannelClient *rcc,
>          spice_error("bad header");
>          return FALSE;
>      }
> -    return red_char_device_restore(state->chardev, &mig_data->base);
> +    return red_char_device_restore(state->priv->chardev, &mig_data->base);
>  }
>  
>  static int spicevmc_red_channel_client_handle_message(RedChannelClient *rcc,
> @@ -295,14 +414,14 @@ static int
> spicevmc_red_channel_client_handle_message(RedChannelClient *rcc,
>      SpiceCharDeviceInterface *sif;
>  
>      state = spicevmc_red_channel_client_get_state(rcc);
> -    sif = spice_char_device_get_interface(state->chardev_sin);
> +    sif = spice_char_device_get_interface(state->priv->chardev_sin);
>  
>      switch (type) {
>      case SPICE_MSGC_SPICEVMC_DATA:
> -        spice_assert(state->recv_from_client_buf->buf == msg);
> -        state->recv_from_client_buf->buf_used = size;
> -        red_char_device_write_buffer_add(state->chardev,
> state->recv_from_client_buf);
> -        state->recv_from_client_buf = NULL;
> +        spice_assert(state->priv->recv_from_client_buf->buf == msg);
> +        state->priv->recv_from_client_buf->buf_used = size;
> +        red_char_device_write_buffer_add(state->priv->chardev,
> state->priv->recv_from_client_buf);
> +        state->priv->recv_from_client_buf = NULL;
>          break;
>      case SPICE_MSGC_PORT_EVENT:
>          if (size != sizeof(uint8_t)) {
> @@ -310,7 +429,7 @@ static int
> spicevmc_red_channel_client_handle_message(RedChannelClient *rcc,
>              return FALSE;
>          }
>          if (sif->base.minor_version >= 2 && sif->event != NULL)
> -            sif->event(state->chardev_sin, *msg);
> +            sif->event(state->priv->chardev_sin, *msg);
>          break;
>      default:
>          return red_channel_client_handle_message(rcc, size, type, msg);
> @@ -327,20 +446,20 @@ static uint8_t
> *spicevmc_red_channel_alloc_msg_rcv_buf(RedChannelClient *rcc,
>      RedChannel *channel = red_channel_client_get_channel(rcc);
>      RedClient *client = red_channel_client_get_client(rcc);
>  
> -    state = SPICE_CONTAINEROF(channel, SpiceVmcState, channel);
> +    state = SPICE_VMC_STATE(channel);
>  
>      switch (type) {
>      case SPICE_MSGC_SPICEVMC_DATA:
> -        assert(!state->recv_from_client_buf);
> +        assert(!state->priv->recv_from_client_buf);
>  
> -        state->recv_from_client_buf =
> red_char_device_write_buffer_get(state->chardev,
> -
> client,
> -
> size);
> -        if (!state->recv_from_client_buf) {
> +        state->priv->recv_from_client_buf =
> red_char_device_write_buffer_get(state->priv->chardev,
> +
> client,
> +
> size);
> +        if (!state->priv->recv_from_client_buf) {
>              spice_error("failed to allocate write buffer");
>              return NULL;
>          }
> -        return state->recv_from_client_buf->buf;
> +        return state->priv->recv_from_client_buf->buf;
>  
>      default:
>          return spice_malloc(size);
> @@ -356,13 +475,14 @@ static void
> spicevmc_red_channel_release_msg_rcv_buf(RedChannelClient *rcc,
>      SpiceVmcState *state;
>      RedChannel *channel = red_channel_client_get_channel(rcc);
>  
> -    state = SPICE_CONTAINEROF(channel, SpiceVmcState, channel);
> +    state = SPICE_VMC_STATE(channel);
>  
>      switch (type) {
>      case SPICE_MSGC_SPICEVMC_DATA:
> -        if (state->recv_from_client_buf) { /* buffer wasn't pushed to device
> */
> -            red_char_device_write_buffer_release(state->chardev,
> state->recv_from_client_buf);
> -            state->recv_from_client_buf = NULL;
> +        if (state->priv->recv_from_client_buf) { /* buffer wasn't pushed to
> device */
> +            red_char_device_write_buffer_release(state->priv->chardev,
> +
> state->priv->recv_from_client_buf);
> +            state->priv->recv_from_client_buf = NULL;
>          }
>          break;
>      default:
> @@ -393,12 +513,12 @@ static void
> spicevmc_red_channel_send_migrate_data(RedChannelClient *rcc,
>      SpiceVmcState *state;
>      RedChannel *channel = red_channel_client_get_channel(rcc);
>  
> -    state = SPICE_CONTAINEROF(channel, SpiceVmcState, channel);
> +    state = SPICE_VMC_STATE(channel);
>      red_channel_client_init_send_data(rcc, SPICE_MSG_MIGRATE_DATA, item);
>      spice_marshaller_add_uint32(m, SPICE_MIGRATE_DATA_SPICEVMC_MAGIC);
>      spice_marshaller_add_uint32(m, SPICE_MIGRATE_DATA_SPICEVMC_VERSION);
>  
> -    red_char_device_migrate_data_marshall(state->chardev, m);
> +    red_char_device_migrate_data_marshall(state->priv->chardev, m);
>  }
>  
>  static void spicevmc_red_channel_send_port_init(RedChannelClient *rcc,
> @@ -464,6 +584,40 @@ static void
> spicevmc_red_channel_release_pipe_item(RedChannelClient *rcc,
>      }
>  }
>  
> +static void
> +spice_vmc_state_class_init(SpiceVmcStateClass *klass)
> +{
> +    GObjectClass *object_class = G_OBJECT_CLASS(klass);
> +    RedChannelClass *channel_class = RED_CHANNEL_CLASS(klass);
> +
> +    g_type_class_add_private(klass, sizeof(SpiceVmcStatePrivate));
> +
> +    object_class->get_property = spice_vmc_state_get_property;
> +    object_class->set_property = spice_vmc_state_set_property;
> +    object_class->constructed = spice_vmc_state_constructed;
> +
> +    channel_class->handle_message =
> spicevmc_red_channel_client_handle_message;
> +
> +    channel_class->config_socket =
> spicevmc_red_channel_client_config_socket;
> +    channel_class->on_disconnect =
> spicevmc_red_channel_client_on_disconnect;
> +    channel_class->send_item = spicevmc_red_channel_send_item;
> +    channel_class->hold_item = spicevmc_red_channel_hold_pipe_item;
> +    channel_class->release_item = spicevmc_red_channel_release_pipe_item;
> +    channel_class->alloc_recv_buf = spicevmc_red_channel_alloc_msg_rcv_buf;
> +    channel_class->release_recv_buf =
> spicevmc_red_channel_release_msg_rcv_buf;
> +    channel_class->handle_migrate_flush_mark =
> spicevmc_channel_client_handle_migrate_flush_mark;
> +    channel_class->handle_migrate_data =
> spicevmc_channel_client_handle_migrate_data;
> +
> +    g_object_class_install_property(object_class,
> +                                    PROP_DEVICE_INSTANCE,
> +                                    g_param_spec_pointer("device-instance",
> +                                                         "device instance",
> +                                                         "Device instance
> for this channel",
> +                                                         G_PARAM_READWRITE |
> +
> G_PARAM_CONSTRUCT_ONLY
> |
> +
> G_PARAM_STATIC_STRINGS));
> +}
> +
>  static void spicevmc_connect(RedChannel *channel, RedClient *client,
>      RedsStream *stream, int migration, int num_common_caps,
>      uint32_t *common_caps, int num_caps, uint32_t *caps)
> @@ -472,13 +626,15 @@ static void spicevmc_connect(RedChannel *channel,
> RedClient *client,
>      SpiceVmcState *state;
>      SpiceCharDeviceInstance *sin;
>      SpiceCharDeviceInterface *sif;
> +    uint32_t type, id;
>  
> -    state = SPICE_CONTAINEROF(channel, SpiceVmcState, channel);
> -    sin = state->chardev_sin;
> +    state = SPICE_VMC_STATE(channel);
> +    sin = state->priv->chardev_sin;
> +    g_object_get(channel, "channel-type", &type, "id", &id, NULL);
>  
> -    if (state->rcc) {
> +    if (state->priv->rcc) {
>          spice_printerr("channel client %d:%d (%p) already connected,
>          refusing second connection",
> -                       channel->type, channel->id, state->rcc);
> +                       type, id, state->priv->rcc);
>          // TODO: notify client in advance about the in use channel using
>          // SPICE_MSG_MAIN_CHANNEL_IN_USE (for example)
>          reds_stream_free(stream);
> @@ -490,21 +646,21 @@ static void spicevmc_connect(RedChannel *channel,
> RedClient *client,
>      if (!rcc) {
>          return;
>      }
> -    state->rcc = rcc;
> +    state->priv->rcc = rcc;
>      red_channel_client_ack_zero_messages_window(rcc);
>  
>      if (strcmp(sin->subtype, "port") == 0) {
>          spicevmc_port_send_init(rcc);
>      }
>  
> -    if (!red_char_device_client_add(state->chardev, client, FALSE, 0, ~0,
> ~0,
> +    if (!red_char_device_client_add(state->priv->chardev, client, FALSE, 0,
> ~0, ~0,
>                                      red_channel_client_is_waiting_for_migrate_data(rcc)))
>                                      {
>          spice_warning("failed to add client to spicevmc");
>          red_channel_client_disconnect(rcc);
>          return;
>      }
>  
> -    sif = spice_char_device_get_interface(state->chardev_sin);
> +    sif = spice_char_device_get_interface(state->priv->chardev_sin);
>      if (sif->state) {
>          sif->state(sin, 1);
>      }
> @@ -514,37 +670,9 @@ RedCharDevice *spicevmc_device_connect(RedsState *reds,
>                                         SpiceCharDeviceInstance *sin,
>                                         uint8_t channel_type)
>  {
> -    static uint8_t id[256] = { 0, };
> -    SpiceVmcState *state;
> -    ChannelCbs channel_cbs = { NULL, };
> -    ClientCbs client_cbs = { NULL, };
> -
> -    channel_cbs.config_socket = spicevmc_red_channel_client_config_socket;
> -    channel_cbs.on_disconnect = spicevmc_red_channel_client_on_disconnect;
> -    channel_cbs.send_item = spicevmc_red_channel_send_item;
> -    channel_cbs.hold_item = spicevmc_red_channel_hold_pipe_item;
> -    channel_cbs.release_item = spicevmc_red_channel_release_pipe_item;
> -    channel_cbs.alloc_recv_buf = spicevmc_red_channel_alloc_msg_rcv_buf;
> -    channel_cbs.release_recv_buf = spicevmc_red_channel_release_msg_rcv_buf;
> -    channel_cbs.handle_migrate_flush_mark =
> spicevmc_channel_client_handle_migrate_flush_mark;
> -    channel_cbs.handle_migrate_data =
> spicevmc_channel_client_handle_migrate_data;
> -
> -    state = (SpiceVmcState*)red_channel_create(sizeof(SpiceVmcState), reds,
> -                                   reds_get_core_interface(reds),
> channel_type, id[channel_type]++,
> -                                   FALSE /* handle_acks */,
> -
> spicevmc_red_channel_client_handle_message,
> -                                   &channel_cbs,
> -                                   SPICE_MIGRATE_NEED_FLUSH |
> SPICE_MIGRATE_NEED_DATA_TRANSFER);
> -    red_channel_init_outgoing_messages_window(&state->channel);
> -
> -    client_cbs.connect = spicevmc_connect;
> -    red_channel_register_client_cbs(&state->channel, &client_cbs, NULL);
> -
> -    state->chardev = red_char_device_spicevmc_new(sin, reds, state);
> -    state->chardev_sin = sin;
> +    SpiceVmcState *state = spice_vmc_state_new(reds, channel_type, sin);
>  
> -    reds_register_channel(reds, &state->channel);
> -    return state->chardev;
> +    return state->priv->chardev;
>  }
>  
>  /* Must be called from RedClient handling thread. */
> @@ -555,17 +683,18 @@ void spicevmc_device_disconnect(RedsState *reds,
> SpiceCharDeviceInstance *sin)
>      /* FIXME */
>      state = (SpiceVmcState
>      *)red_char_device_opaque_get((RedCharDevice*)sin->st);
>  
> -    if (state->recv_from_client_buf) {
> -        red_char_device_write_buffer_release(state->chardev,
> state->recv_from_client_buf);
> +    if (state->priv->recv_from_client_buf) {
> +        red_char_device_write_buffer_release(state->priv->chardev,
> +
> state->priv->recv_from_client_buf);
>      }
>      /* FIXME */
>      red_char_device_destroy((RedCharDevice*)sin->st);
> -    state->chardev = NULL;
> +    state->priv->chardev = NULL;
>      sin->st = NULL;
>  
> -    reds_unregister_channel(reds, &state->channel);
> -    free(state->pipe_item);
> -    red_channel_destroy(&state->channel);
> +    reds_unregister_channel(reds, RED_CHANNEL(state));
> +    free(state->priv->pipe_item);
> +    red_channel_destroy(RED_CHANNEL(state));
>  }
>  
>  SPICE_GNUC_VISIBLE void spice_server_port_event(SpiceCharDeviceInstance
>  *sin, uint8_t event)
> @@ -580,16 +709,16 @@ SPICE_GNUC_VISIBLE void
> spice_server_port_event(SpiceCharDeviceInstance *sin, ui
>      /* FIXME */
>      state = (SpiceVmcState
>      *)red_char_device_opaque_get((RedCharDevice*)sin->st);
>      if (event == SPICE_PORT_EVENT_OPENED) {
> -        state->port_opened = TRUE;
> +        state->priv->port_opened = TRUE;
>      } else if (event == SPICE_PORT_EVENT_CLOSED) {
> -        state->port_opened = FALSE;
> +        state->priv->port_opened = FALSE;
>      }
>  
> -    if (state->rcc == NULL) {
> +    if (state->priv->rcc == NULL) {
>          return;
>      }
>  
> -    spicevmc_port_send_event(state->rcc, event);
> +    spicevmc_port_send_event(state->priv->rcc, event);
>  }
>  
>  static void
> diff --git a/server/stream.c b/server/stream.c
> index 47a6924..004e886 100644
> --- a/server/stream.c
> +++ b/server/stream.c
> @@ -20,13 +20,14 @@
>  
>  #include "stream.h"
>  #include "display-channel.h"
> +#include "display-channel-private.h"
>  #include "main-channel-client.h"
>  
>  #define FPS_TEST_INTERVAL 1
>  #define FOREACH_STREAMS(display, item)                  \
> -    for (item = ring_get_head(&(display)->streams);     \
> +    for (item = ring_get_head(&(display)->priv->streams);     \
>           item != NULL;                                  \
> -         item = ring_next(&(display)->streams, item))
> +         item = ring_next(&(display)->priv->streams, item))
>  
>  void stream_agent_stats_print(StreamAgent *agent)
>  {
> @@ -72,11 +73,11 @@ void stream_stop(DisplayChannel *display, Stream *stream)
>      spice_return_if_fail(ring_item_is_linked(&stream->link));
>      spice_return_if_fail(!stream->current);
>  
> -    spice_debug("stream %d", get_stream_id(display, stream));
> +    spice_debug("stream %d", display_channel_get_stream_id(display,
> stream));
>      FOREACH_DCC(display, link, next, dcc) {
>          StreamAgent *stream_agent;
>  
> -        stream_agent = dcc_get_stream_agent(dcc, get_stream_id(display,
> stream));
> +        stream_agent = dcc_get_stream_agent(dcc,
> display_channel_get_stream_id(display, stream));
>          region_clear(&stream_agent->vis_region);
>          region_clear(&stream_agent->clip);
>          spice_assert(!red_pipe_item_is_linked(&stream_agent->destroy_item));
> @@ -94,25 +95,25 @@ void stream_stop(DisplayChannel *display, Stream *stream)
>          red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc),
>          &stream_agent->destroy_item);
>          stream_agent_stats_print(stream_agent);
>      }
> -    display->streams_size_total -= stream->width * stream->height;
> +    display->priv->streams_size_total -= stream->width * stream->height;
>      ring_remove(&stream->link);
>      stream_unref(display, stream);
>  }
>  
>  static void stream_free(DisplayChannel *display, Stream *stream)
>  {
> -    stream->next = display->free_streams;
> -    display->free_streams = stream;
> +    stream->next = display->priv->free_streams;
> +    display->priv->free_streams = stream;
>  }
>  
>  void display_channel_init_streams(DisplayChannel *display)
>  {
>      int i;
>  
> -    ring_init(&display->streams);
> -    display->free_streams = NULL;
> +    ring_init(&display->priv->streams);
> +    display->priv->free_streams = NULL;
>      for (i = 0; i < NUM_STREAMS; i++) {
> -        Stream *stream = &display->streams_buf[i];
> +        Stream *stream = &display->priv->streams_buf[i];
>          ring_item_init(&stream->link);
>          stream_free(display, stream);
>      }
> @@ -126,7 +127,7 @@ void stream_unref(DisplayChannel *display, Stream
> *stream)
>      spice_warn_if_fail(!ring_item_is_linked(&stream->link));
>  
>      stream_free(display, stream);
> -    display->stream_count--;
> +    display->priv->stream_count--;
>  }
>  
>  void stream_agent_unref(DisplayChannel *display, StreamAgent *agent)
> @@ -169,7 +170,7 @@ static void update_copy_graduality(DisplayChannel
> *display, Drawable *drawable)
>      SpiceBitmap *bitmap;
>      spice_return_if_fail(drawable->red_drawable->type == QXL_DRAW_COPY);
>  
> -    if (display->stream_video != SPICE_STREAM_VIDEO_FILTER) {
> +    if (display_channel_get_stream_video(display) !=
> SPICE_STREAM_VIDEO_FILTER) {
>          drawable->copy_bitmap_graduality = BITMAP_GRADUAL_INVALID;
>          return;
>      }
> @@ -284,7 +285,7 @@ static void attach_stream(DisplayChannel *display,
> Drawable *drawable, Stream *s
>          StreamAgent *agent;
>          QRegion clip_in_draw_dest;
>  
> -        agent = dcc_get_stream_agent(dcc, get_stream_id(display, stream));
> +        agent = dcc_get_stream_agent(dcc,
> display_channel_get_stream_id(display, stream));
>          region_or(&agent->vis_region, &drawable->tree_item.base.rgn);
>  
>          region_init(&clip_in_draw_dest);
> @@ -335,7 +336,7 @@ static void before_reattach_stream(DisplayChannel
> *display,
>          return;
>      }
>  
> -    index = get_stream_id(display, stream);
> +    index = display_channel_get_stream_id(display, stream);
>      DRAWABLE_FOREACH_DPI_SAFE(stream->current, ring_item, next, dpi) {
>          dcc = dpi->dcc;
>          agent = dcc_get_stream_agent(dcc, index);
> @@ -392,11 +393,11 @@ static void before_reattach_stream(DisplayChannel
> *display,
>  static Stream *display_channel_stream_try_new(DisplayChannel *display)
>  {
>      Stream *stream;
> -    if (!display->free_streams) {
> +    if (!display->priv->free_streams) {
>          return NULL;
>      }
> -    stream = display->free_streams;
> -    display->free_streams = display->free_streams->next;
> +    stream = display->priv->free_streams;
> +    display->priv->free_streams = display->priv->free_streams->next;
>      return stream;
>  }
>  
> @@ -416,7 +417,7 @@ static void display_channel_create_stream(DisplayChannel
> *display, Drawable *dra
>      spice_assert(drawable->red_drawable->type == QXL_DRAW_COPY);
>      src_rect = &drawable->red_drawable->u.copy.src_area;
>  
> -    ring_add(&display->streams, &stream->link);
> +    ring_add(&display->priv->streams, &stream->link);
>      stream->current = drawable;
>      stream->last_time = drawable->creation_time;
>      stream->width = src_rect->right - src_rect->left;
> @@ -438,13 +439,13 @@ static void
> display_channel_create_stream(DisplayChannel *display, Drawable *dra
>      }
>      stream->num_input_frames = 0;
>      stream->input_fps_start_time = drawable->creation_time;
> -    display->streams_size_total += stream->width * stream->height;
> -    display->stream_count++;
> +    display->priv->streams_size_total += stream->width * stream->height;
> +    display->priv->stream_count++;
>      FOREACH_DCC(display, link, next, dcc) {
>          dcc_create_stream(dcc, stream);
>      }
>      spice_debug("stream %d %dx%d (%d, %d) (%d, %d) %u fps",
> -                (int)(stream - display->streams_buf), stream->width,
> +                (int)(stream - display->priv->streams_buf), stream->width,
>                  stream->height, stream->dest_area.left,
>                  stream->dest_area.top,
>                  stream->dest_area.right, stream->dest_area.bottom,
>                  stream->input_fps);
> @@ -520,7 +521,7 @@ void stream_trace_update(DisplayChannel *display,
> Drawable *drawable)
>          }
>      }
>  
> -    trace = display->items_trace;
> +    trace = display->priv->items_trace;
>      trace_end = trace + NUM_TRACE_ITEMS;
>      for (; trace < trace_end; trace++) {
>          if (is_next_stream_frame(display, drawable, trace->width,
>          trace->height,
> @@ -591,7 +592,7 @@ static void
> dcc_update_streams_max_latency(DisplayChannelClient *dcc, StreamAgen
>      }
>  
>      dcc_set_max_stream_latency(dcc, 0);
> -    if (DCC_TO_DC(dcc)->stream_count == 1) {
> +    if (DCC_TO_DC(dcc)->priv->stream_count == 1) {
>          return;
>      }
>      for (i = 0; i < NUM_STREAMS; i++) {
> @@ -650,7 +651,7 @@ static uint64_t get_initial_bit_rate(DisplayChannelClient
> *dcc, Stream *stream)
>      /* dividing the available bandwidth among the active streams, and saving
>       * (1-RED_STREAM_CHANNEL_CAPACITY) of it for other messages */
>      return (RED_STREAM_CHANNEL_CAPACITY * bit_rate *
> -            stream->width * stream->height) /
> DCC_TO_DC(dcc)->streams_size_total;
> +            stream->width * stream->height) /
> DCC_TO_DC(dcc)->priv->streams_size_total;
>  }
>  
>  static uint32_t get_roundtrip_ms(void *opaque)
> @@ -703,7 +704,7 @@ static void update_client_playback_delay(void *opaque,
> uint32_t delay_ms)
>  
>  void dcc_create_stream(DisplayChannelClient *dcc, Stream *stream)
>  {
> -    StreamAgent *agent = dcc_get_stream_agent(dcc,
> get_stream_id(DCC_TO_DC(dcc), stream));
> +    StreamAgent *agent = dcc_get_stream_agent(dcc,
> display_channel_get_stream_id(DCC_TO_DC(dcc), stream));
>  
>      spice_return_if_fail(region_is_empty(&agent->vis_region));
>  
> @@ -741,7 +742,7 @@ void dcc_create_stream(DisplayChannelClient *dcc, Stream
> *stream)
>          agent->report_id = rand();
>          red_pipe_item_init(&report_pipe_item->pipe_item,
>                             RED_PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT);
> -        report_pipe_item->stream_id = get_stream_id(DCC_TO_DC(dcc), stream);
> +        report_pipe_item->stream_id =
> display_channel_get_stream_id(DCC_TO_DC(dcc), stream);
>          red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc),
>          &report_pipe_item->pipe_item);
>      }
>  #ifdef STREAM_STATS
> @@ -782,7 +783,7 @@ static void
> dcc_detach_stream_gracefully(DisplayChannelClient *dcc,
>                                           Drawable *update_area_limit)
>  {
>      DisplayChannel *display = DCC_TO_DC(dcc);
> -    int stream_id = get_stream_id(display, stream);
> +    int stream_id = display_channel_get_stream_id(display, stream);
>      StreamAgent *agent = dcc_get_stream_agent(dcc, stream_id);
>  
>      /* stopping the client from playing older frames at once*/
> @@ -868,7 +869,7 @@ static void detach_stream_gracefully(DisplayChannel
> *display, Stream *stream,
>   */
>  void stream_detach_behind(DisplayChannel *display, QRegion *region, Drawable
>  *drawable)
>  {
> -    Ring *ring = &display->streams;
> +    Ring *ring = &display->priv->streams;
>      RingItem *item = ring_get_head(ring);
>      GList *link, *next;
>      DisplayChannelClient *dcc;
> @@ -880,12 +881,12 @@ void stream_detach_behind(DisplayChannel *display,
> QRegion *region, Drawable *dr
>          item = ring_next(ring, item);
>  
>          FOREACH_DCC(display, link, next, dcc) {
> -            StreamAgent *agent = dcc_get_stream_agent(dcc,
> get_stream_id(display, stream));
> +            StreamAgent *agent = dcc_get_stream_agent(dcc,
> display_channel_get_stream_id(display, stream));
>  
>              if (region_intersects(&agent->vis_region, region)) {
>                  dcc_detach_stream_gracefully(dcc, stream, drawable);
>                  detach = 1;
> -                spice_debug("stream %d", get_stream_id(display, stream));
> +                spice_debug("stream %d",
> display_channel_get_stream_id(display, stream));
>              }
>          }
>          if (detach && stream->current) {
> @@ -904,7 +905,7 @@ void stream_detach_and_stop(DisplayChannel *display)
>      RingItem *stream_item;
>  
>      spice_debug(NULL);
> -    while ((stream_item = ring_get_head(&display->streams))) {
> +    while ((stream_item = ring_get_head(&display->priv->streams))) {
>          Stream *stream = SPICE_CONTAINEROF(stream_item, Stream, link);
>  
>          detach_stream_gracefully(display, stream, NULL);
> @@ -914,7 +915,7 @@ void stream_detach_and_stop(DisplayChannel *display)
>  
>  void stream_timeout(DisplayChannel *display)
>  {
> -    Ring *ring = &display->streams;
> +    Ring *ring = &display->priv->streams;
>      RingItem *item;
>  
>      red_time_t now = spice_get_monotonic_time_ns();
> @@ -937,7 +938,7 @@ void stream_trace_add_drawable(DisplayChannel *display,
> Drawable *item)
>          return;
>      }
>  
> -    trace = &display->items_trace[display->next_item_trace++ &
> ITEMS_TRACE_MASK];
> +    trace = &display->priv->items_trace[display->priv->next_item_trace++ &
> ITEMS_TRACE_MASK];
>      trace->time = item->creation_time;
>      trace->first_frame_time = item->first_frame_time;
>      trace->frames_count = item->frames_count;
> diff --git a/server/stream.h b/server/stream.h
> index 29071f5..f337059 100644
> --- a/server/stream.h
> +++ b/server/stream.h
> @@ -41,9 +41,6 @@
>  #define RED_STREAM_DEFAULT_LOW_START_BIT_RATE (2.5 * 1024 * 1024) // 2.5Mbps
>  #define MAX_FPS 30
>  
> -/* move back to display_channel once struct private */
> -typedef struct DisplayChannel DisplayChannel;
> -
>  typedef struct Stream Stream;
>  
>  typedef struct RedStreamActivateReportItem {

_______________________________________________
Spice-devel mailing list
Spice-devel@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/spice-devel





[Index of Archives]     [Linux ARM Kernel]     [Linux ARM]     [Linux Omap]     [Fedora ARM]     [IETF Annouce]     [Security]     [Bugtraq]     [Linux]     [Linux OMAP]     [Linux MIPS]     [ECOS]     [Asterisk Internet PBX]     [Linux API]     [Monitors]