[Spice-devel] [PATCH 06/14] Rename PipeItem to RedPipeItem
Frediano Ziglio
fziglio at redhat.com
Wed Apr 27 14:41:59 UTC 2016
>
> These changes (this patch and the next patch) are pretty mechanical, so the
> main
> question is whether anybody objects to this much code churn. Any objections?
>
>
Probably in a few dozen of patches will rename again all these stuff again
but for the time being I think it's coherent.
Acked-by: Frediano Ziglio <fziglio at redhat.com>
I think the ack was delayed (at least mine was) by dependencies on previous
ones.
Frediano
>
> On Thu, 2016-04-21 at 16:43 -0500, Jonathon Jongsma wrote:
> > Following internal type naming conventions
> > ---
> > No changes since last patch
> >
> > server/cache-item.h | 2 +-
> > server/cache-item.tmpl.c | 2 +-
> > server/char-device.c | 22 +++++------
> > server/char-device.h | 6 +--
> > server/cursor-channel.c | 22 +++++------
> > server/dcc-send.c | 22 +++++------
> > server/dcc.c | 58 ++++++++++++++---------------
> > server/dcc.h | 22 +++++------
> > server/display-channel.c | 10 ++---
> > server/display-channel.h | 8 ++--
> > server/inputs-channel.c | 20 +++++-----
> > server/main-channel.c | 97
> > ++++++++++++++++++++++++-----------------------
> > -
> > server/red-channel.c | 55 +++++++++++++--------------
> > server/red-channel.h | 30 +++++++--------
> > server/red-pipe-item.c | 14 +++----
> > server/red-pipe-item.h | 14 +++----
> > server/red-worker.h | 4 +-
> > server/reds.c | 26 ++++++-------
> > server/smartcard.c | 42 +++++++++++----------
> > server/spicevmc.c | 41 ++++++++++----------
> > server/stream.c | 16 ++++----
> > server/stream.h | 8 ++--
> > 22 files changed, 273 insertions(+), 268 deletions(-)
> >
> > diff --git a/server/cache-item.h b/server/cache-item.h
> > index 7dfb1af..90c82d3 100644
> > --- a/server/cache-item.h
> > +++ b/server/cache-item.h
> > @@ -25,7 +25,7 @@ typedef struct CacheItem CacheItem;
> >
> > struct CacheItem {
> > union {
> > - PipeItem pipe_data;
> > + RedPipeItem pipe_data;
> > struct {
> > RingItem lru_link;
> > CacheItem *next;
> > diff --git a/server/cache-item.tmpl.c b/server/cache-item.tmpl.c
> > index 23b0bc1..d63e576 100644
> > --- a/server/cache-item.tmpl.c
> > +++ b/server/cache-item.tmpl.c
> > @@ -81,7 +81,7 @@ static void FUNC_NAME(remove)(CHANNELCLIENT
> > *channel_client,
> > CacheItem *item)
> > channel_client->VAR_NAME(items)--;
> > channel_client->VAR_NAME(available) += item->size;
> >
> > - pipe_item_init(&item->u.pipe_data, PIPE_ITEM_TYPE_INVAL_ONE);
> > + red_pipe_item_init(&item->u.pipe_data, PIPE_ITEM_TYPE_INVAL_ONE);
> > red_channel_client_pipe_add_tail_and_push(&channel_client->common.base,
> > &item->u.pipe_data); // for now
> > }
> >
> > diff --git a/server/char-device.c b/server/char-device.c
> > index 8cdf326..fc1d692 100644
> > --- a/server/char-device.c
> > +++ b/server/char-device.c
> > @@ -104,7 +104,7 @@ static guint signals[RED_CHAR_DEVICE_LAST_SIGNAL];
> > static void red_char_device_write_buffer_unref(RedCharDeviceWriteBuffer
> > *write_buf);
> > static void red_char_device_write_retry(void *opaque);
> >
> > -static PipeItem *
> > +static RedPipeItem *
> > red_char_device_read_one_msg_from_device(RedCharDevice *dev)
> > {
> > RedCharDeviceClass *klass = RED_CHAR_DEVICE_GET_CLASS(dev);
> > @@ -114,7 +114,7 @@ red_char_device_read_one_msg_from_device(RedCharDevice
> > *dev)
> >
> > static void
> > red_char_device_send_msg_to_client(RedCharDevice *dev,
> > - PipeItem *msg,
> > + RedPipeItem *msg,
> > RedClient *client)
> > {
> > RedCharDeviceClass *klass = RED_CHAR_DEVICE_GET_CLASS(dev);
> > @@ -188,7 +188,7 @@ static void red_char_device_client_free(RedCharDevice
> > *dev,
> > dev_client->wait_for_tokens_timer = NULL;
> > }
> >
> > - g_queue_free_full(dev_client->send_queue, pipe_item_unref);
> > + g_queue_free_full(dev_client->send_queue, red_pipe_item_unref);
> >
> > /* remove write buffers that are associated with the client */
> > spice_debug("write_queue_is_empty %d", ring_is_empty(&dev->priv
> > ->write_queue) && !dev->priv->cur_write_buf);
> > @@ -276,7 +276,7 @@ static uint64_t
> > red_char_device_max_send_tokens(RedCharDevice *dev)
> > }
> >
> > static void red_char_device_add_msg_to_client_queue(RedCharDeviceClient
> > *dev_client,
> > - PipeItem *msg)
> > + RedPipeItem *msg)
> > {
> > RedCharDevice *dev = dev_client->dev;
> >
> > @@ -285,7 +285,7 @@ static void
> > red_char_device_add_msg_to_client_queue(RedCharDeviceClient *dev_cli
> > return;
> > }
> >
> > - pipe_item_ref(msg);
> > + red_pipe_item_ref(msg);
> > g_queue_push_head(dev_client->send_queue, msg);
> > if (!dev_client->wait_for_tokens_started) {
> > reds_core_timer_start(dev->priv->reds, dev_client
> > ->wait_for_tokens_timer,
> > @@ -295,7 +295,7 @@ static void
> > red_char_device_add_msg_to_client_queue(RedCharDeviceClient *dev_cli
> > }
> >
> > static void red_char_device_send_msg_to_clients(RedCharDevice *dev,
> > - PipeItem *msg)
> > + RedPipeItem *msg)
> > {
> > RingItem *item, *next;
> >
> > @@ -341,7 +341,7 @@ static int
> > red_char_device_read_from_device(RedCharDevice
> > *dev)
> > * All messages will be discarded if no client is attached to the
> > device
> > */
> > while ((max_send_tokens || ring_is_empty(&dev->priv->clients)) && dev
> > ->priv->running) {
> > - PipeItem *msg;
> > + RedPipeItem *msg;
> >
> > msg = red_char_device_read_one_msg_from_device(dev);
> > if (!msg) {
> > @@ -354,7 +354,7 @@ static int
> > red_char_device_read_from_device(RedCharDevice
> > *dev)
> > }
> > did_read = TRUE;
> > red_char_device_send_msg_to_clients(dev, msg);
> > - pipe_item_unref(msg);
> > + red_pipe_item_unref(msg);
> > max_send_tokens--;
> > }
> > dev->priv->during_read_from_device = 0;
> > @@ -369,12 +369,12 @@ static void
> > red_char_device_client_send_queue_push(RedCharDeviceClient *dev_clie
> > {
> > while (!g_queue_is_empty(dev_client->send_queue) &&
> > red_char_device_can_send_to_client(dev_client)) {
> > - PipeItem *msg = g_queue_pop_tail(dev_client->send_queue);
> > + RedPipeItem *msg = g_queue_pop_tail(dev_client->send_queue);
> > g_assert(msg != NULL);
> > dev_client->num_send_tokens--;
> > red_char_device_send_msg_to_client(dev_client->dev, msg,
> > dev_client->client);
> > - pipe_item_unref(msg);
> > + red_pipe_item_unref(msg);
> > }
> > }
> >
> > @@ -854,7 +854,7 @@ void red_char_device_reset(RedCharDevice *dev)
> > dev_client = SPICE_CONTAINEROF(client_item, RedCharDeviceClient,
> > link);
> > spice_debug("send_queue_empty %d", g_queue_is_empty(dev_client
> > ->send_queue));
> > dev_client->num_send_tokens += g_queue_get_length(dev_client
> > ->send_queue);
> > - g_queue_foreach(dev_client->send_queue, (GFunc)pipe_item_unref,
> > NULL);
> > + g_queue_foreach(dev_client->send_queue,
> > (GFunc)red_pipe_item_unref,
> > NULL);
> > g_queue_clear(dev_client->send_queue);
> > }
> > red_char_device_reset_dev_instance(dev, NULL);
> > diff --git a/server/char-device.h b/server/char-device.h
> > index c18ce66..75ec344 100644
> > --- a/server/char-device.h
> > +++ b/server/char-device.h
> > @@ -56,10 +56,10 @@ struct RedCharDeviceClass
> >
> > /* reads from the device till reaching a msg that should be sent to
> > the
> > client,
> > * or till the reading fails */
> > - PipeItem* (*read_one_msg_from_device)(SpiceCharDeviceInstance *sin,
> > - void *opaque);
> > + RedPipeItem* (*read_one_msg_from_device)(SpiceCharDeviceInstance *sin,
> > + void *opaque);
> > /* after this call, the message is unreferenced */
> > - void (*send_msg_to_client)(PipeItem *msg,
> > + void (*send_msg_to_client)(RedPipeItem *msg,
> > RedClient *client,
> > void *opaque);
> >
> > diff --git a/server/cursor-channel.c b/server/cursor-channel.c
> > index 7d5ac6a..e2bb706 100644
> > --- a/server/cursor-channel.c
> > +++ b/server/cursor-channel.c
> > @@ -46,7 +46,7 @@ typedef struct CursorItem {
> > G_STATIC_ASSERT(sizeof(CursorItem) <= QXL_CURSUR_DEVICE_DATA_SIZE);
> >
> > typedef struct CursorPipeItem {
> > - PipeItem base;
> > + RedPipeItem base;
> > CursorItem *cursor_item;
> > int refs;
> > } CursorPipeItem;
> > @@ -132,11 +132,11 @@ static void cursor_set_item(CursorChannel *cursor,
> > CursorItem *item)
> > cursor->item = item ? cursor_item_ref(item) : NULL;
> > }
> >
> > -static PipeItem *new_cursor_pipe_item(RedChannelClient *rcc, void *data,
> > int
> > num)
> > +static RedPipeItem *new_cursor_pipe_item(RedChannelClient *rcc, void
> > *data,
> > int num)
> > {
> > CursorPipeItem *item = spice_malloc0(sizeof(CursorPipeItem));
> >
> > - pipe_item_init(&item->base, PIPE_ITEM_TYPE_CURSOR);
> > + red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_CURSOR);
> > item->refs = 1;
> > item->cursor_item = data;
> > item->cursor_item->refs++;
> > @@ -212,7 +212,7 @@ static void put_cursor_pipe_item(CursorChannelClient
> > *ccc,
> > CursorPipeItem *pipe_
> > return;
> > }
> >
> > - spice_assert(!pipe_item_is_linked(&pipe_item->base));
> > + spice_assert(!red_pipe_item_is_linked(&pipe_item->base));
> >
> > cursor_item_unref(pipe_item->cursor_item);
> > free(pipe_item);
> > @@ -229,7 +229,7 @@ static void
> > cursor_channel_client_on_disconnect(RedChannelClient *rcc)
> > // TODO: share code between before/after_push since most of the items need
> > the same
> > // release
> > static void
> > cursor_channel_client_release_item_before_push(CursorChannelClient *ccc,
> > - PipeItem *item)
> > + RedPipeItem
> > *item)
> > {
> > switch (item->type) {
> > case PIPE_ITEM_TYPE_CURSOR: {
> > @@ -249,7 +249,7 @@ static void
> > cursor_channel_client_release_item_before_push(CursorChannelClient *
> > }
> >
> > static void
> > cursor_channel_client_release_item_after_push(CursorChannelClient
> > *ccc,
> > - PipeItem *item)
> > + RedPipeItem
> > *item)
> > {
> > switch (item->type) {
> > case PIPE_ITEM_TYPE_CURSOR: {
> > @@ -263,7 +263,7 @@ static void
> > cursor_channel_client_release_item_after_push(CursorChannelClient *c
> > }
> >
> > static void red_marshall_cursor_init(RedChannelClient *rcc,
> > SpiceMarshaller
> > *base_marshaller,
> > - PipeItem *pipe_item)
> > + RedPipeItem *pipe_item)
> > {
> > CursorChannel *cursor_channel;
> > CursorChannelClient *ccc = RCC_TO_CCC(rcc);
> > @@ -290,7 +290,7 @@ static void cursor_marshall(RedChannelClient *rcc,
> > CursorChannel *cursor_channel = SPICE_CONTAINEROF(rcc->channel,
> > CursorChannel, common.base);
> > CursorChannelClient *ccc = RCC_TO_CCC(rcc);
> > CursorItem *item = cursor_pipe_item->cursor_item;
> > - PipeItem *pipe_item = &cursor_pipe_item->base;
> > + RedPipeItem *pipe_item = &cursor_pipe_item->base;
> > RedCursorCmd *cmd;
> >
> > spice_return_if_fail(cursor_channel);
> > @@ -348,7 +348,7 @@ static inline void red_marshall_inval(RedChannelClient
> > *rcc,
> > spice_marshall_msg_cursor_inval_one(base_marshaller, &inval_one);
> > }
> >
> > -static void cursor_channel_send_item(RedChannelClient *rcc, PipeItem
> > *pipe_item)
> > +static void cursor_channel_send_item(RedChannelClient *rcc, RedPipeItem
> > *pipe_item)
> > {
> > SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
> > CursorChannelClient *ccc = RCC_TO_CCC(rcc);
> > @@ -389,7 +389,7 @@ static CursorPipeItem
> > *cursor_pipe_item_ref(CursorPipeItem
> > *item)
> > }
> >
> >
> > -static void cursor_channel_hold_pipe_item(RedChannelClient *rcc, PipeItem
> > *item)
> > +static void cursor_channel_hold_pipe_item(RedChannelClient *rcc,
> > RedPipeItem
> > *item)
> > {
> > CursorPipeItem *cursor_pipe_item;
> >
> > @@ -399,7 +399,7 @@ static void
> > cursor_channel_hold_pipe_item(RedChannelClient
> > *rcc, PipeItem *item)
> > cursor_pipe_item_ref(cursor_pipe_item);
> > }
> >
> > -static void cursor_channel_release_item(RedChannelClient *rcc, PipeItem
> > *item, int item_pushed)
> > +static void cursor_channel_release_item(RedChannelClient *rcc, RedPipeItem
> > *item, int item_pushed)
> > {
> > CursorChannelClient *ccc = RCC_TO_CCC(rcc);
> >
> > diff --git a/server/dcc-send.c b/server/dcc-send.c
> > index b8d1157..799d5df 100644
> > --- a/server/dcc-send.c
> > +++ b/server/dcc-send.c
> > @@ -186,9 +186,9 @@ static int is_brush_lossy(RedChannelClient *rcc,
> > SpiceBrush *brush,
> > }
> > }
> >
> > -static PipeItem *dcc_get_tail(DisplayChannelClient *dcc)
> > +static RedPipeItem *dcc_get_tail(DisplayChannelClient *dcc)
> > {
> > - return (PipeItem*)ring_get_tail(&RED_CHANNEL_CLIENT(dcc)->pipe);
> > + return (RedPipeItem*)ring_get_tail(&RED_CHANNEL_CLIENT(dcc)->pipe);
> > }
> >
> > static void red_display_add_image_to_pixmap_cache(RedChannelClient *rcc,
> > @@ -596,15 +596,15 @@ static int
> > pipe_rendered_drawables_intersect_with_areas(DisplayChannelClient *dc
> > SpiceRect
> > *surface_areas[],
> > int num_surfaces)
> > {
> > - PipeItem *pipe_item;
> > + RedPipeItem *pipe_item;
> > Ring *pipe;
> >
> > spice_assert(num_surfaces);
> > pipe = &RED_CHANNEL_CLIENT(dcc)->pipe;
> >
> > - for (pipe_item = (PipeItem *)ring_get_head(pipe);
> > + for (pipe_item = (RedPipeItem *)ring_get_head(pipe);
> > pipe_item;
> > - pipe_item = (PipeItem *)ring_next(pipe, &pipe_item->link))
> > + pipe_item = (RedPipeItem *)ring_next(pipe, &pipe_item->link))
> > {
> > Drawable *drawable;
> >
> > @@ -685,7 +685,7 @@ static void
> > red_pipe_replace_rendered_drawables_with_images(DisplayChannelClient
> > int resent_surface_ids[MAX_PIPE_SIZE];
> > SpiceRect resent_areas[MAX_PIPE_SIZE]; // not pointers since drawables
> > may be released
> > int num_resent;
> > - PipeItem *pipe_item;
> > + RedPipeItem *pipe_item;
> > Ring *pipe;
> >
> > resent_surface_ids[0] = first_surface_id;
> > @@ -695,9 +695,9 @@ static void
> > red_pipe_replace_rendered_drawables_with_images(DisplayChannelClient
> > pipe = &RED_CHANNEL_CLIENT(dcc)->pipe;
> >
> > // going from the oldest to the newest
> > - for (pipe_item = (PipeItem *)ring_get_tail(pipe);
> > + for (pipe_item = (RedPipeItem *)ring_get_tail(pipe);
> > pipe_item;
> > - pipe_item = (PipeItem *)ring_prev(pipe, &pipe_item->link)) {
> > + pipe_item = (RedPipeItem *)ring_prev(pipe, &pipe_item->link)) {
> > Drawable *drawable;
> > DrawablePipeItem *dpi;
> > ImageItem *image;
> > @@ -2301,7 +2301,7 @@ static void
> > marshall_stream_activate_report(RedChannelClient *rcc,
> >
> > static void marshall_gl_scanout(RedChannelClient *rcc,
> > SpiceMarshaller *m,
> > - PipeItem *item)
> > + RedPipeItem *item)
> > {
> > DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
> > DisplayChannel *display_channel = DCC_TO_DC(dcc);
> > @@ -2317,7 +2317,7 @@ static void marshall_gl_scanout(RedChannelClient
> > *rcc,
> >
> > static void marshall_gl_draw(RedChannelClient *rcc,
> > SpiceMarshaller *m,
> > - PipeItem *item)
> > + RedPipeItem *item)
> > {
> > GlDrawItem *p = SPICE_CONTAINEROF(item, GlDrawItem, base);
> >
> > @@ -2360,7 +2360,7 @@ static void reset_send_data(DisplayChannelClient
> > *dcc)
> > memset(dcc->send_data.free_list.sync, 0, sizeof(dcc
> > ->send_data.free_list.sync));
> > }
> >
> > -void dcc_send_item(DisplayChannelClient *dcc, PipeItem *pipe_item)
> > +void dcc_send_item(DisplayChannelClient *dcc, RedPipeItem *pipe_item)
> > {
> > RedChannelClient *rcc = RED_CHANNEL_CLIENT(dcc);
> > SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
> > diff --git a/server/dcc.c b/server/dcc.c
> > index 09a1fca..a74ffe1 100644
> > --- a/server/dcc.c
> > +++ b/server/dcc.c
> > @@ -38,7 +38,7 @@ static SurfaceCreateItem
> > *surface_create_item_new(RedChannel* channel,
> > create->surface_create.flags = flags;
> > create->surface_create.format = format;
> >
> > - pipe_item_init(&create->pipe_item, PIPE_ITEM_TYPE_CREATE_SURFACE);
> > + red_pipe_item_init(&create->pipe_item, PIPE_ITEM_TYPE_CREATE_SURFACE);
> > return create;
> > }
> >
> > @@ -64,7 +64,7 @@ int
> > dcc_clear_surface_drawables_from_pipe(DisplayChannelClient *dcc, int
> > surface
> > int wait_if_used)
> > {
> > Ring *ring;
> > - PipeItem *item;
> > + RedPipeItem *item;
> > int x;
> > RedChannelClient *rcc;
> >
> > @@ -74,8 +74,8 @@ int
> > dcc_clear_surface_drawables_from_pipe(DisplayChannelClient *dcc, int
> > surface
> >
> > rcc = RED_CHANNEL_CLIENT(dcc);
> > ring = &rcc->pipe;
> > - item = (PipeItem *) ring;
> > - while ((item = (PipeItem *)ring_next(ring, (RingItem *)item))) {
> > + item = (RedPipeItem *) ring;
> > + while ((item = (RedPipeItem *)ring_next(ring, (RingItem *)item))) {
> > Drawable *drawable;
> > DrawablePipeItem *dpi = NULL;
> > int depend_found = FALSE;
> > @@ -90,11 +90,11 @@ int
> > dcc_clear_surface_drawables_from_pipe(DisplayChannelClient *dcc, int
> > surface
> > }
> >
> > if (drawable->surface_id == surface_id) {
> > - PipeItem *tmp_item = item;
> > - item = (PipeItem *)ring_prev(ring, (RingItem *)item);
> > + RedPipeItem *tmp_item = item;
> > + item = (RedPipeItem *)ring_prev(ring, (RingItem *)item);
> > red_channel_client_pipe_remove_and_release(rcc, tmp_item);
> > if (!item) {
> > - item = (PipeItem *)ring;
> > + item = (RedPipeItem *)ring;
> > }
> > continue;
> > }
> > @@ -163,7 +163,7 @@ void dcc_create_surface(DisplayChannelClient *dcc, int
> > surface_id)
> >
> > // adding the pipe item after pos. If pos == NULL, adding to head.
> > ImageItem *dcc_add_surface_area_image(DisplayChannelClient *dcc, int
> > surface_id,
> > - SpiceRect *area, PipeItem *pos, int
> > can_lossy)
> > + SpiceRect *area, RedPipeItem *pos,
> > int
> > can_lossy)
> > {
> > DisplayChannel *display = DCC_TO_DC(dcc);
> > RedSurface *surface = &display->surfaces[surface_id];
> > @@ -184,7 +184,7 @@ ImageItem
> > *dcc_add_surface_area_image(DisplayChannelClient
> > *dcc, int surface_id,
> >
> > item = (ImageItem *)spice_malloc_n_m(height, stride,
> > sizeof(ImageItem));
> >
> > - pipe_item_init(&item->base, PIPE_ITEM_TYPE_IMAGE);
> > + red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_IMAGE);
> >
> > item->surface_id = surface_id;
> > item->image_format =
> > @@ -274,7 +274,7 @@ static void
> > add_drawable_surface_images(DisplayChannelClient *dcc, Drawable *dra
> > dcc_push_surface_image(dcc, drawable->surface_id);
> > }
> >
> > -void drawable_pipe_item_free(PipeItem *item)
> > +void drawable_pipe_item_free(RedPipeItem *item)
> > {
> > DrawablePipeItem *dpi = SPICE_CONTAINEROF(item, DrawablePipeItem,
> > dpi_pipe_item);
> > spice_assert(item->refcount == 0);
> > @@ -294,8 +294,8 @@ static DrawablePipeItem
> > *drawable_pipe_item_new(DisplayChannelClient *dcc, Drawa
> > dpi->dcc = dcc;
> > ring_item_init(&dpi->base);
> > ring_add(&drawable->pipes, &dpi->base);
> > - pipe_item_init_full(&dpi->dpi_pipe_item, PIPE_ITEM_TYPE_DRAW,
> > - (GDestroyNotify)drawable_pipe_item_free);
> > + red_pipe_item_init_full(&dpi->dpi_pipe_item, PIPE_ITEM_TYPE_DRAW,
> > + (GDestroyNotify)drawable_pipe_item_free);
> > drawable->refs++;
> > return dpi;
> > }
> > @@ -316,7 +316,7 @@ void dcc_append_drawable(DisplayChannelClient *dcc,
> > Drawable *drawable)
> > red_channel_client_pipe_add_tail_and_push(RED_CHANNEL_CLIENT(dcc),
> > &dpi
> > ->dpi_pipe_item);
> > }
> >
> > -void dcc_add_drawable_after(DisplayChannelClient *dcc, Drawable *drawable,
> > PipeItem *pos)
> > +void dcc_add_drawable_after(DisplayChannelClient *dcc, Drawable *drawable,
> > RedPipeItem *pos)
> > {
> > DrawablePipeItem *dpi = drawable_pipe_item_new(dcc, drawable);
> >
> > @@ -334,8 +334,8 @@ static void dcc_init_stream_agents(DisplayChannelClient
> > *dcc)
> > agent->stream = &display->streams_buf[i];
> > region_init(&agent->vis_region);
> > region_init(&agent->clip);
> > - pipe_item_init(&agent->create_item, PIPE_ITEM_TYPE_STREAM_CREATE);
> > - pipe_item_init(&agent->destroy_item,
> > PIPE_ITEM_TYPE_STREAM_DESTROY);
> > + red_pipe_item_init(&agent->create_item,
> > PIPE_ITEM_TYPE_STREAM_CREATE);
> > + red_pipe_item_init(&agent->destroy_item,
> > PIPE_ITEM_TYPE_STREAM_DESTROY);
> > }
> > dcc->use_mjpeg_encoder_rate_control =
> > red_channel_client_test_remote_cap(RED_CHANNEL_CLIENT(dcc),
> > SPICE_DISPLAY_CAP_STREAM_REPORT);
> > @@ -505,7 +505,7 @@ void dcc_stream_agent_clip(DisplayChannelClient* dcc,
> > StreamAgent *agent)
> > item->rects->num_rects = n_rects;
> > region_ret_rects(&agent->clip, item->rects->rects, n_rects);
> >
> > - red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), (PipeItem
> > *)item);
> > + red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc), (RedPipeItem
> > *)item);
> > }
> >
> > static void monitors_config_item_free(MonitorsConfigItem *item)
> > @@ -522,8 +522,8 @@ static MonitorsConfigItem
> > *monitors_config_item_new(RedChannel* channel,
> > mci = (MonitorsConfigItem *)spice_malloc(sizeof(*mci));
> > mci->monitors_config = monitors_config;
> >
> > - pipe_item_init_full(&mci->pipe_item, PIPE_ITEM_TYPE_MONITORS_CONFIG,
> > - (GDestroyNotify)monitors_config_item_free);
> > + red_pipe_item_init_full(&mci->pipe_item,
> > PIPE_ITEM_TYPE_MONITORS_CONFIG,
> > + (GDestroyNotify)monitors_config_item_free);
> > return mci;
> > }
> >
> > @@ -556,12 +556,12 @@ static SurfaceDestroyItem
> > *surface_destroy_item_new(RedChannel *channel,
> >
> > destroy = spice_malloc(sizeof(SurfaceDestroyItem));
> > destroy->surface_destroy.surface_id = surface_id;
> > - pipe_item_init(&destroy->pipe_item, PIPE_ITEM_TYPE_DESTROY_SURFACE);
> > + red_pipe_item_init(&destroy->pipe_item,
> > PIPE_ITEM_TYPE_DESTROY_SURFACE);
> >
> > return destroy;
> > }
> >
> > -PipeItem *dcc_gl_scanout_item_new(RedChannelClient *rcc, void *data, int
> > num)
> > +RedPipeItem *dcc_gl_scanout_item_new(RedChannelClient *rcc, void *data,
> > int
> > num)
> > {
> > GlScanoutUnixItem *item = spice_new(GlScanoutUnixItem, 1);
> > spice_return_val_if_fail(item != NULL, NULL);
> > @@ -574,12 +574,12 @@ PipeItem *dcc_gl_scanout_item_new(RedChannelClient
> > *rcc,
> > void *data, int num)
> > return NULL;
> > }
> >
> > - pipe_item_init(&item->base, PIPE_ITEM_TYPE_GL_SCANOUT);
> > + red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_GL_SCANOUT);
> >
> > return &item->base;
> > }
> >
> > -PipeItem *dcc_gl_draw_item_new(RedChannelClient *rcc, void *data, int num)
> > +RedPipeItem *dcc_gl_draw_item_new(RedChannelClient *rcc, void *data, int
> > num)
> > {
> > DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
> > const SpiceMsgDisplayGlDraw *draw = data;
> > @@ -594,7 +594,7 @@ PipeItem *dcc_gl_draw_item_new(RedChannelClient *rcc,
> > void
> > *data, int num)
> >
> > dcc->gl_draw_ongoing = TRUE;
> > item->draw = *draw;
> > - pipe_item_init(&item->base, PIPE_ITEM_TYPE_GL_DRAW);
> > + red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_GL_DRAW);
> >
> > return &item->base;
> > }
> > @@ -1589,7 +1589,7 @@ int dcc_handle_migrate_data(DisplayChannelClient
> > *dcc,
> > uint32_t size, void *mess
> > return TRUE;
> > }
> >
> > -static void release_item_after_push(DisplayChannelClient *dcc, PipeItem
> > *item)
> > +static void release_item_after_push(DisplayChannelClient *dcc, RedPipeItem
> > *item)
> > {
> > switch (item->type) {
> > case PIPE_ITEM_TYPE_DRAW:
> > @@ -1597,7 +1597,7 @@ static void
> > release_item_after_push(DisplayChannelClient
> > *dcc, PipeItem *item)
> > case PIPE_ITEM_TYPE_STREAM_CLIP:
> > case PIPE_ITEM_TYPE_MONITORS_CONFIG:
> > case PIPE_ITEM_TYPE_UPGRADE:
> > - pipe_item_unref(item);
> > + red_pipe_item_unref(item);
> > break;
> > case PIPE_ITEM_TYPE_GL_SCANOUT:
> > case PIPE_ITEM_TYPE_GL_DRAW:
> > @@ -1611,7 +1611,7 @@ static void
> > release_item_after_push(DisplayChannelClient
> > *dcc, PipeItem *item)
> >
> > // TODO: share code between before/after_push since most of the items need
> > the same
> > // release
> > -static void release_item_before_push(DisplayChannelClient *dcc, PipeItem
> > *item)
> > +static void release_item_before_push(DisplayChannelClient *dcc,
> > RedPipeItem
> > *item)
> > {
> > DisplayChannel *display = DCC_TO_DC(dcc);
> >
> > @@ -1620,7 +1620,7 @@ static void
> > release_item_before_push(DisplayChannelClient *dcc, PipeItem *item)
> > case PIPE_ITEM_TYPE_DRAW: {
> > DrawablePipeItem *dpi = SPICE_CONTAINEROF(item, DrawablePipeItem,
> > dpi_pipe_item);
> > ring_remove(&dpi->base);
> > - pipe_item_unref(item);
> > + red_pipe_item_unref(item);
> > break;
> > }
> > case PIPE_ITEM_TYPE_STREAM_CREATE: {
> > @@ -1637,7 +1637,7 @@ static void
> > release_item_before_push(DisplayChannelClient *dcc, PipeItem *item)
> > case PIPE_ITEM_TYPE_UPGRADE:
> > case PIPE_ITEM_TYPE_IMAGE:
> > case PIPE_ITEM_TYPE_MONITORS_CONFIG:
> > - pipe_item_unref(item);
> > + red_pipe_item_unref(item);
> > break;
> > case PIPE_ITEM_TYPE_CREATE_SURFACE: {
> > SurfaceCreateItem *surface_create = SPICE_CONTAINEROF(item,
> > SurfaceCreateItem,
> > @@ -1667,7 +1667,7 @@ static void
> > release_item_before_push(DisplayChannelClient *dcc, PipeItem *item)
> > }
> > }
> >
> > -void dcc_release_item(DisplayChannelClient *dcc, PipeItem *item, int
> > item_pushed)
> > +void dcc_release_item(DisplayChannelClient *dcc, RedPipeItem *item, int
> > item_pushed)
> > {
> > if (item_pushed)
> > release_item_after_push(dcc, item);
> > diff --git a/server/dcc.h b/server/dcc.h
> > index e8354e2..52cd22a 100644
> > --- a/server/dcc.h
> > +++ b/server/dcc.h
> > @@ -123,20 +123,20 @@ struct DisplayChannelClient {
> >
> > typedef struct SurfaceCreateItem {
> > SpiceMsgSurfaceCreate surface_create;
> > - PipeItem pipe_item;
> > + RedPipeItem pipe_item;
> > } SurfaceCreateItem;
> >
> > typedef struct GlScanoutUnixItem {
> > - PipeItem base;
> > + RedPipeItem base;
> > } GlScanoutUnixItem;
> >
> > typedef struct GlDrawItem {
> > - PipeItem base;
> > + RedPipeItem base;
> > SpiceMsgDisplayGlDraw draw;
> > } GlDrawItem;
> >
> > typedef struct ImageItem {
> > - PipeItem base;
> > + RedPipeItem base;
> > SpicePoint pos;
> > int width;
> > int height;
> > @@ -151,7 +151,7 @@ typedef struct ImageItem {
> >
> > typedef struct DrawablePipeItem {
> > RingItem base; /* link for a list of pipe items held by Drawable */
> > - PipeItem dpi_pipe_item; /* link for the client's pipe itself */
> > + RedPipeItem dpi_pipe_item; /* link for the client's pipe itself */
> > Drawable *drawable;
> > DisplayChannelClient *dcc;
> > uint8_t refs;
> > @@ -189,7 +189,7 @@ void dcc_push_surface_image
> > (DisplayCha
> > ImageItem * dcc_add_surface_area_image
> > (DisplayChannelClient *dcc,
> > int
> > surface_id,
> >
> > SpiceRect *area,
> > -
> > PipeItem *pos,
> > +
> > RedPipeItem *pos,
> > int
> > can_lossy);
> > void dcc_palette_cache_reset
> > (DisplayChannelClient *dcc);
> > void dcc_palette_cache_palette
> > (DisplayChannelClient *dcc,
> > @@ -203,20 +203,20 @@ void dcc_append_drawable
> > (DisplayCha
> >
> > Drawable *drawable);
> > void dcc_add_drawable_after
> > (DisplayChannelClient *dcc,
> >
> > Drawable *drawable,
> > -
> > PipeItem *pos);
> > +
> > RedPipeItem *pos);
> > void dcc_release_item
> > (DisplayChannelClient *dcc,
> > -
> > PipeItem *item,
> > +
> > RedPipeItem *item,
> > int
> > item_pushed);
> > void dcc_send_item
> > (DisplayChannelClient *dcc,
> > -
> > PipeItem *item);
> > +
> > RedPipeItem *item);
> > int dcc_clear_surface_drawables_from_pipe
> > (DisplayChannelClient *dcc,
> > int
> > surface_id,
> > int
> > wait_if_used);
> > int dcc_drawable_is_in_pipe
> > (DisplayChannelClient *dcc,
> >
> > Drawable *drawable);
> > -PipeItem * dcc_gl_scanout_item_new
> > (RedChannelClient *rcc,
> > +RedPipeItem * dcc_gl_scanout_item_new
> > (RedChannelClient *rcc,
> > void
> > *data, int num);
> > -PipeItem * dcc_gl_draw_item_new
> > (RedChannelClient *rcc,
> > +RedPipeItem * dcc_gl_draw_item_new
> > (RedChannelClient *rcc,
> > void
> > *data, int num);
> >
> > typedef struct compress_send_data_t {
> > diff --git a/server/display-channel.c b/server/display-channel.c
> > index 99a490d..31dccb8 100644
> > --- a/server/display-channel.c
> > +++ b/server/display-channel.c
> > @@ -408,7 +408,7 @@ static void drawable_remove_from_pipes(Drawable
> > *drawable)
> >
> > RING_FOREACH_SAFE(item, next, &drawable->pipes) {
> > dpi = SPICE_CONTAINEROF(item, DrawablePipeItem, base);
> > - if (pipe_item_is_linked(&dpi->dpi_pipe_item)) {
> > + if (red_pipe_item_is_linked(&dpi->dpi_pipe_item)) {
> > red_channel_client_pipe_remove_and_release(RED_CHANNEL_CLIENT(dpi
> > ->dcc),
> > &dpi->dpi_pipe_item);
> > }
> > @@ -1965,12 +1965,12 @@ static void on_disconnect(RedChannelClient *rcc)
> > display->glz_drawable_count);
> > }
> >
> > -static void send_item(RedChannelClient *rcc, PipeItem *item)
> > +static void send_item(RedChannelClient *rcc, RedPipeItem *item)
> > {
> > dcc_send_item(RCC_TO_DCC(rcc), item);
> > }
> >
> > -static void hold_item(RedChannelClient *rcc, PipeItem *item)
> > +static void hold_item(RedChannelClient *rcc, RedPipeItem *item)
> > {
> > spice_return_if_fail(item);
> >
> > @@ -1979,14 +1979,14 @@ static void hold_item(RedChannelClient *rcc,
> > PipeItem
> > *item)
> > case PIPE_ITEM_TYPE_IMAGE:
> > case PIPE_ITEM_TYPE_STREAM_CLIP:
> > case PIPE_ITEM_TYPE_UPGRADE:
> > - pipe_item_ref(item);
> > + red_pipe_item_ref(item);
> > break;
> > default:
> > spice_warn_if_reached();
> > }
> > }
> >
> > -static void release_item(RedChannelClient *rcc, PipeItem *item, int
> > item_pushed)
> > +static void release_item(RedChannelClient *rcc, RedPipeItem *item, int
> > item_pushed)
> > {
> > DisplayChannelClient *dcc = RCC_TO_DCC(rcc);
> >
> > diff --git a/server/display-channel.h b/server/display-channel.h
> > index c10cfe2..c5b67c4 100644
> > --- a/server/display-channel.h
> > +++ b/server/display-channel.h
> > @@ -58,7 +58,7 @@ struct Drawable {
> > RingItem list_link;
> > DrawItem tree_item;
> > Ring pipes;
> > - PipeItem *pipe_item_rest;
> > + RedPipeItem *pipe_item_rest;
> > uint32_t size_pipe_item_rest;
> > RedDrawable *red_drawable;
> >
> > @@ -120,7 +120,7 @@ typedef struct MonitorsConfig {
> > } MonitorsConfig;
> >
> > typedef struct MonitorsConfigItem {
> > - PipeItem pipe_item;
> > + RedPipeItem pipe_item;
> > MonitorsConfig *monitors_config;
> > } MonitorsConfigItem;
> >
> > @@ -242,11 +242,11 @@ static inline int get_stream_id(DisplayChannel
> > *display,
> > Stream *stream)
> >
> > typedef struct SurfaceDestroyItem {
> > SpiceMsgSurfaceDestroy surface_destroy;
> > - PipeItem pipe_item;
> > + RedPipeItem pipe_item;
> > } SurfaceDestroyItem;
> >
> > typedef struct UpgradeItem {
> > - PipeItem base;
> > + RedPipeItem base;
> > Drawable *drawable;
> > SpiceClipRects *rects;
> > } UpgradeItem;
> > diff --git a/server/inputs-channel.c b/server/inputs-channel.c
> > index 45e0a8f..81a8d4a 100644
> > --- a/server/inputs-channel.c
> > +++ b/server/inputs-channel.c
> > @@ -123,16 +123,16 @@ enum {
> > };
> >
> > typedef struct InputsPipeItem {
> > - PipeItem base;
> > + RedPipeItem base;
> > } InputsPipeItem;
> >
> > typedef struct KeyModifiersPipeItem {
> > - PipeItem base;
> > + RedPipeItem base;
> > uint8_t modifiers;
> > } KeyModifiersPipeItem;
> >
> > typedef struct InputsInitPipeItem {
> > - PipeItem base;
> > + RedPipeItem base;
> > uint8_t modifiers;
> > } InputsInitPipeItem;
> >
> > @@ -229,19 +229,19 @@ static uint8_t kbd_get_leds(SpiceKbdInstance *sin)
> > return sif->get_leds(sin);
> > }
> >
> > -static PipeItem *inputs_key_modifiers_item_new(
> > +static RedPipeItem *inputs_key_modifiers_item_new(
> > RedChannelClient *rcc, void *data, int num)
> > {
> > KeyModifiersPipeItem *item =
> > spice_malloc(sizeof(KeyModifiersPipeItem));
> >
> > - pipe_item_init(&item->base, PIPE_ITEM_KEY_MODIFIERS);
> > + red_pipe_item_init(&item->base, PIPE_ITEM_KEY_MODIFIERS);
> > item->modifiers = *(uint8_t *)data;
> > return &item->base;
> > }
> >
> > static void inputs_channel_send_migrate_data(RedChannelClient *rcc,
> > SpiceMarshaller *m,
> > - PipeItem *item)
> > + RedPipeItem *item)
> > {
> > InputsChannelClient *icc = SPICE_CONTAINEROF(rcc, InputsChannelClient,
> > base);
> > InputsChannel *inputs = SPICE_CONTAINEROF(rcc->channel, InputsChannel,
> > base);
> > @@ -255,12 +255,12 @@ static void
> > inputs_channel_send_migrate_data(RedChannelClient *rcc,
> > }
> >
> > static void inputs_channel_release_pipe_item(RedChannelClient *rcc,
> > - PipeItem *base, int item_pushed)
> > + RedPipeItem *base, int item_pushed)
> > {
> > free(base);
> > }
> >
> > -static void inputs_channel_send_item(RedChannelClient *rcc, PipeItem
> > *base)
> > +static void inputs_channel_send_item(RedChannelClient *rcc, RedPipeItem
> > *base)
> > {
> > SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
> >
> > @@ -503,7 +503,7 @@ static void inputs_pipe_add_init(RedChannelClient *rcc)
> > InputsInitPipeItem *item = spice_malloc(sizeof(InputsInitPipeItem));
> > InputsChannel *inputs = SPICE_CONTAINEROF(rcc->channel, InputsChannel,
> > base);
> >
> > - pipe_item_init(&item->base, PIPE_ITEM_INPUTS_INIT);
> > + red_pipe_item_init(&item->base, PIPE_ITEM_INPUTS_INIT);
> > item->modifiers = kbd_get_leds(inputs_channel_get_keyboard(inputs));
> > red_channel_client_pipe_add_push(rcc, &item->base);
> > }
> > @@ -524,7 +524,7 @@ static int
> > inputs_channel_config_socket(RedChannelClient
> > *rcc)
> > return TRUE;
> > }
> >
> > -static void inputs_channel_hold_pipe_item(RedChannelClient *rcc, PipeItem
> > *item)
> > +static void inputs_channel_hold_pipe_item(RedChannelClient *rcc,
> > RedPipeItem
> > *item)
> > {
> > }
> >
> > diff --git a/server/main-channel.c b/server/main-channel.c
> > index a9d0ce1..b904e33 100644
> > --- a/server/main-channel.c
> > +++ b/server/main-channel.c
> > @@ -79,28 +79,28 @@ enum {
> > };
> >
> > typedef struct RefsPipeItem {
> > - PipeItem base;
> > + RedPipeItem base;
> > int *refs;
> > } RefsPipeItem;
> >
> > typedef struct PingPipeItem {
> > - PipeItem base;
> > + RedPipeItem base;
> > int size;
> > } PingPipeItem;
> >
> > typedef struct MouseModePipeItem {
> > - PipeItem base;
> > + RedPipeItem base;
> > int current_mode;
> > int is_client_mouse_allowed;
> > } MouseModePipeItem;
> >
> > typedef struct TokensPipeItem {
> > - PipeItem base;
> > + RedPipeItem base;
> > int tokens;
> > } TokensPipeItem;
> >
> > typedef struct AgentDataPipeItem {
> > - PipeItem base;
> > + RedPipeItem base;
> > uint8_t* data;
> > size_t len;
> > spice_marshaller_item_free_func free_data;
> > @@ -108,7 +108,7 @@ typedef struct AgentDataPipeItem {
> > } AgentDataPipeItem;
> >
> > typedef struct InitPipeItem {
> > - PipeItem base;
> > + RedPipeItem base;
> > int connection_id;
> > int display_channels_hint;
> > int current_mouse_mode;
> > @@ -118,22 +118,22 @@ typedef struct InitPipeItem {
> > } InitPipeItem;
> >
> > typedef struct NamePipeItem {
> > - PipeItem base;
> > + RedPipeItem base;
> > SpiceMsgMainName msg;
> > } NamePipeItem;
> >
> > typedef struct UuidPipeItem {
> > - PipeItem base;
> > + RedPipeItem base;
> > SpiceMsgMainUuid msg;
> > } UuidPipeItem;
> >
> > typedef struct NotifyPipeItem {
> > - PipeItem base;
> > + RedPipeItem base;
> > char *msg;
> > } NotifyPipeItem;
> >
> > typedef struct MultiMediaTimePipeItem {
> > - PipeItem base;
> > + RedPipeItem base;
> > int time;
> > } MultiMediaTimePipeItem;
> >
> > @@ -166,7 +166,7 @@ enum NetTestStage {
> > };
> >
> > static void main_channel_release_pipe_item(RedChannelClient *rcc,
> > - PipeItem *base, int
> > item_pushed);
> > + RedPipeItem *base, int
> > item_pushed);
> >
> > int main_channel_is_connected(MainChannel *main_chan)
> > {
> > @@ -221,42 +221,42 @@ typedef struct MainMouseModeItemInfo {
> > int is_client_mouse_allowed;
> > } MainMouseModeItemInfo;
> >
> > -static PipeItem *main_mouse_mode_item_new(RedChannelClient *rcc, void
> > *data,
> > int num)
> > +static RedPipeItem *main_mouse_mode_item_new(RedChannelClient *rcc, void
> > *data, int num)
> > {
> > MouseModePipeItem *item = spice_malloc(sizeof(MouseModePipeItem));
> > MainMouseModeItemInfo *info = data;
> >
> > - pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_MOUSE_MODE);
> > + red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_MOUSE_MODE);
> > item->current_mode = info->current_mode;
> > item->is_client_mouse_allowed = info->is_client_mouse_allowed;
> > return &item->base;
> > }
> >
> > -static PipeItem *main_ping_item_new(MainChannelClient *mcc, int size)
> > +static RedPipeItem *main_ping_item_new(MainChannelClient *mcc, int size)
> > {
> > PingPipeItem *item = spice_malloc(sizeof(PingPipeItem));
> >
> > - pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_PING);
> > + red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_PING);
> > item->size = size;
> > return &item->base;
> > }
> >
> > -static PipeItem *main_agent_tokens_item_new(RedChannelClient *rcc,
> > uint32_t
> > num_tokens)
> > +static RedPipeItem *main_agent_tokens_item_new(RedChannelClient *rcc,
> > uint32_t num_tokens)
> > {
> > TokensPipeItem *item = spice_malloc(sizeof(TokensPipeItem));
> >
> > - pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN);
> > + red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_AGENT_TOKEN);
> > item->tokens = num_tokens;
> > return &item->base;
> > }
> >
> > -static PipeItem *main_agent_data_item_new(RedChannelClient *rcc, uint8_t*
> > data, size_t len,
> > - spice_marshaller_item_free_func
> > free_data,
> > - void *opaque)
> > +static RedPipeItem *main_agent_data_item_new(RedChannelClient *rcc,
> > uint8_t*
> > data, size_t len,
> > +
> > spice_marshaller_item_free_func
> > free_data,
> > + void *opaque)
> > {
> > AgentDataPipeItem *item = spice_malloc(sizeof(AgentDataPipeItem));
> >
> > - pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_AGENT_DATA);
> > + red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_AGENT_DATA);
> > item->data = data;
> > item->len = len;
> > item->free_data = free_data;
> > @@ -264,14 +264,14 @@ static PipeItem
> > *main_agent_data_item_new(RedChannelClient *rcc, uint8_t* data,
> > return &item->base;
> > }
> >
> > -static PipeItem *main_init_item_new(MainChannelClient *mcc,
> > +static RedPipeItem *main_init_item_new(MainChannelClient *mcc,
> > int connection_id, int display_channels_hint, int current_mouse_mode,
> > int is_client_mouse_allowed, int multi_media_time,
> > int ram_hint)
> > {
> > InitPipeItem *item = spice_malloc(sizeof(InitPipeItem));
> >
> > - pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_INIT);
> > + red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_INIT);
> > item->connection_id = connection_id;
> > item->display_channels_hint = display_channels_hint;
> > item->current_mouse_mode = current_mouse_mode;
> > @@ -281,44 +281,44 @@ static PipeItem *main_init_item_new(MainChannelClient
> > *mcc,
> > return &item->base;
> > }
> >
> > -static PipeItem *main_name_item_new(MainChannelClient *mcc, const char
> > *name)
> > +static RedPipeItem *main_name_item_new(MainChannelClient *mcc, const char
> > *name)
> > {
> > NamePipeItem *item = spice_malloc(sizeof(NamePipeItem) + strlen(name)
> > +
> > 1);
> >
> > - pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_NAME);
> > + red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_NAME);
> > item->msg.name_len = strlen(name) + 1;
> > memcpy(&item->msg.name, name, item->msg.name_len);
> >
> > return &item->base;
> > }
> >
> > -static PipeItem *main_uuid_item_new(MainChannelClient *mcc, const uint8_t
> > uuid[16])
> > +static RedPipeItem *main_uuid_item_new(MainChannelClient *mcc, const
> > uint8_t
> > uuid[16])
> > {
> > UuidPipeItem *item = spice_malloc(sizeof(UuidPipeItem));
> >
> > - pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_UUID);
> > + red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_UUID);
> > memcpy(item->msg.uuid, uuid, sizeof(item->msg.uuid));
> >
> > return &item->base;
> > }
> >
> > -static PipeItem *main_notify_item_new(RedChannelClient *rcc, void *data,
> > int
> > num)
> > +static RedPipeItem *main_notify_item_new(RedChannelClient *rcc, void
> > *data,
> > int num)
> > {
> > NotifyPipeItem *item = spice_malloc(sizeof(NotifyPipeItem));
> > const char *msg = data;
> >
> > - pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_NOTIFY);
> > + red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_NOTIFY);
> > item->msg = spice_strdup(msg);
> > return &item->base;
> > }
> >
> > -static PipeItem *main_multi_media_time_item_new(
> > +static RedPipeItem *main_multi_media_time_item_new(
> > RedChannelClient *rcc, void *data, int num)
> > {
> > MultiMediaTimePipeItem *item, *info = data;
> >
> > item = spice_malloc(sizeof(MultiMediaTimePipeItem));
> > - pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME);
> > + red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_MAIN_MULTI_MEDIA_TIME);
> > item->time = info->time;
> > return &item->base;
> > }
> > @@ -335,7 +335,7 @@ static void
> > main_channel_push_channels(MainChannelClient
> > *mcc)
> >
> > static void main_channel_marshall_channels(RedChannelClient *rcc,
> > SpiceMarshaller *m,
> > - PipeItem *item)
> > + RedPipeItem *item)
> > {
> > SpiceMsgChannels* channels_info;
> >
> > @@ -349,7 +349,7 @@ static void
> > main_channel_marshall_channels(RedChannelClient *rcc,
> >
> > int main_channel_client_push_ping(MainChannelClient *mcc, int size)
> > {
> > - PipeItem *item;
> > + RedPipeItem *item;
> >
> > if (mcc == NULL) {
> > return FALSE;
> > @@ -417,7 +417,7 @@ void main_channel_push_agent_connected(MainChannel
> > *main_chan)
> >
> > static void main_channel_marshall_agent_connected(SpiceMarshaller *m,
> > RedChannelClient *rcc,
> > - PipeItem *item)
> > + RedPipeItem *item)
> > {
> > SpiceMsgMainAgentConnectedTokens connected;
> >
> > @@ -433,7 +433,7 @@ void main_channel_push_agent_disconnected(MainChannel
> > *main_chan)
> >
> > static void main_channel_marshall_agent_disconnected(RedChannelClient
> > *rcc,
> > SpiceMarshaller *m,
> > - PipeItem *item)
> > + RedPipeItem *item)
> > {
> > SpiceMsgMainAgentDisconnect disconnect;
> >
> > @@ -444,7 +444,7 @@ static void
> > main_channel_marshall_agent_disconnected(RedChannelClient *rcc,
> >
> > void main_channel_client_push_agent_tokens(MainChannelClient *mcc,
> > uint32_t
> > num_tokens)
> > {
> > - PipeItem *item = main_agent_tokens_item_new(&mcc->base, num_tokens);
> > + RedPipeItem *item = main_agent_tokens_item_new(&mcc->base,
> > num_tokens);
> >
> > red_channel_client_pipe_add_push(&mcc->base, item);
> > }
> > @@ -462,7 +462,7 @@ static void
> > main_channel_marshall_tokens(RedChannelClient
> > *rcc,
> > void main_channel_client_push_agent_data(MainChannelClient *mcc, uint8_t*
> > data, size_t len,
> > spice_marshaller_item_free_func free_data, void *opaque)
> > {
> > - PipeItem *item;
> > + RedPipeItem *item;
> >
> > item = main_agent_data_item_new(&mcc->base, data, len, free_data,
> > opaque);
> > red_channel_client_pipe_add_push(&mcc->base, item);
> > @@ -482,7 +482,8 @@ static void
> > main_channel_push_migrate_data_item(MainChannel *main_chan)
> > }
> >
> > static void main_channel_marshall_migrate_data_item(RedChannelClient *rcc,
> > - SpiceMarshaller *m,
> > PipeItem *item)
> > + SpiceMarshaller *m,
> > + RedPipeItem *item)
> > {
> > red_channel_client_init_send_data(rcc, SPICE_MSG_MIGRATE_DATA, item);
> > reds_marshall_migrate_data(rcc->channel->reds, m); // TODO: from reds
> > split. ugly separation.
> > @@ -515,7 +516,7 @@ void main_channel_push_init(MainChannelClient *mcc,
> > int is_client_mouse_allowed, int multi_media_time,
> > int ram_hint)
> > {
> > - PipeItem *item;
> > + RedPipeItem *item;
> >
> > item = main_init_item_new(mcc,
> > mcc->connection_id, display_channels_hint,
> > current_mouse_mode,
> > @@ -547,7 +548,7 @@ static void main_channel_marshall_init(RedChannelClient
> > *rcc,
> >
> > void main_channel_push_name(MainChannelClient *mcc, const char *name)
> > {
> > - PipeItem *item;
> > + RedPipeItem *item;
> >
> > if (!red_channel_client_test_remote_cap(&mcc->base,
> > SPICE_MAIN_CAP_NAME_AND_UUID))
> > @@ -559,7 +560,7 @@ void main_channel_push_name(MainChannelClient *mcc,
> > const
> > char *name)
> >
> > void main_channel_push_uuid(MainChannelClient *mcc, const uint8_t
> > uuid[16])
> > {
> > - PipeItem *item;
> > + RedPipeItem *item;
> >
> > if (!red_channel_client_test_remote_cap(&mcc->base,
> > SPICE_MAIN_CAP_NAME_AND_UUID))
> > @@ -571,7 +572,7 @@ void main_channel_push_uuid(MainChannelClient *mcc,
> > const
> > uint8_t uuid[16])
> >
> > void main_channel_client_push_notify(MainChannelClient *mcc, const char
> > *msg)
> > {
> > - PipeItem *item = main_notify_item_new(&mcc->base, (void *)msg, 1);
> > + RedPipeItem *item = main_notify_item_new(&mcc->base, (void *)msg, 1);
> > red_channel_client_pipe_add_push(&mcc->base, item);
> > }
> >
> > @@ -608,7 +609,7 @@ static void
> > main_channel_fill_migrate_dst_info(MainChannel
> > *main_channel,
> > }
> >
> > static void main_channel_marshall_migrate_begin(SpiceMarshaller *m,
> > RedChannelClient *rcc,
> > - PipeItem *item)
> > + RedPipeItem *item)
> > {
> > SpiceMsgMainMigrationBegin migrate;
> > MainChannel *main_ch;
> > @@ -621,7 +622,7 @@ static void
> > main_channel_marshall_migrate_begin(SpiceMarshaller *m, RedChannelCl
> >
> > static void main_channel_marshall_migrate_begin_seamless(SpiceMarshaller
> > *m,
> > RedChannelClient
> > *rcc,
> > - PipeItem *item)
> > + RedPipeItem
> > *item)
> > {
> > SpiceMsgMainMigrateBeginSeamless migrate_seamless;
> > MainChannel *main_ch;
> > @@ -665,7 +666,7 @@ void main_channel_migrate_switch(MainChannel
> > *main_chan,
> > RedsMigSpice *mig_targe
> > }
> >
> > static void main_channel_marshall_migrate_switch(SpiceMarshaller *m,
> > RedChannelClient *rcc,
> > - PipeItem *item)
> > + RedPipeItem *item)
> > {
> > SpiceMsgMainMigrationSwitchHost migrate;
> > MainChannel *main_ch;
> > @@ -698,7 +699,7 @@ static void
> > main_channel_marshall_multi_media_time(RedChannelClient *rcc,
> > spice_marshall_msg_main_multi_media_time(m, &time_mes);
> > }
> >
> > -static void main_channel_send_item(RedChannelClient *rcc, PipeItem *base)
> > +static void main_channel_send_item(RedChannelClient *rcc, RedPipeItem
> > *base)
> > {
> > MainChannelClient *mcc = SPICE_CONTAINEROF(rcc, MainChannelClient,
> > base);
> > SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
> > @@ -783,7 +784,7 @@ static void main_channel_send_item(RedChannelClient
> > *rcc,
> > PipeItem *base)
> > }
> >
> > static void main_channel_release_pipe_item(RedChannelClient *rcc,
> > - PipeItem *base, int item_pushed)
> > + RedPipeItem *base, int item_pushed)
> > {
> > switch (base->type) {
> > case PIPE_ITEM_TYPE_MAIN_AGENT_DATA: {
> > @@ -1022,7 +1023,7 @@ static int
> > main_channel_config_socket(RedChannelClient
> > *rcc)
> > return TRUE;
> > }
> >
> > -static void main_channel_hold_pipe_item(RedChannelClient *rcc, PipeItem
> > *item)
> > +static void main_channel_hold_pipe_item(RedChannelClient *rcc, RedPipeItem
> > *item)
> > {
> > }
> >
> > diff --git a/server/red-channel.c b/server/red-channel.c
> > index 3e036c9..834ddb7 100644
> > --- a/server/red-channel.c
> > +++ b/server/red-channel.c
> > @@ -45,7 +45,7 @@
> > #include "utils.h"
> >
> > typedef struct EmptyMsgPipeItem {
> > - PipeItem base;
> > + RedPipeItem base;
> > int msg;
> > } EmptyMsgPipeItem;
> >
> > @@ -510,7 +510,7 @@ static void
> > red_channel_client_send_migrate(RedChannelClient *rcc)
> > }
> >
> >
> > -static void red_channel_client_send_empty_msg(RedChannelClient *rcc,
> > PipeItem
> > *base)
> > +static void red_channel_client_send_empty_msg(RedChannelClient *rcc,
> > RedPipeItem *base)
> > {
> > EmptyMsgPipeItem *msg_pipe_item = SPICE_CONTAINEROF(base,
> > EmptyMsgPipeItem, base);
> >
> > @@ -557,7 +557,7 @@ static void
> > red_channel_client_send_ping(RedChannelClient
> > *rcc)
> > red_channel_client_begin_send_message(rcc);
> > }
> >
> > -static void red_channel_client_send_item(RedChannelClient *rcc, PipeItem
> > *item)
> > +static void red_channel_client_send_item(RedChannelClient *rcc,
> > RedPipeItem
> > *item)
> > {
> > spice_assert(red_channel_client_no_item_being_sent(rcc));
> > red_channel_client_reset_send_data(rcc);
> > @@ -581,7 +581,7 @@ static void
> > red_channel_client_send_item(RedChannelClient
> > *rcc, PipeItem *item)
> > free(item);
> > }
> >
> > -static void red_channel_client_release_item(RedChannelClient *rcc,
> > PipeItem
> > *item, int item_pushed)
> > +static void red_channel_client_release_item(RedChannelClient *rcc,
> > RedPipeItem *item, int item_pushed)
> > {
> > switch (item->type) {
> > case PIPE_ITEM_TYPE_SET_ACK:
> > @@ -643,7 +643,7 @@ static void red_channel_peer_on_out_msg_done(void
> > *opaque)
> >
> > }
> >
> > -static void red_channel_client_pipe_remove(RedChannelClient *rcc, PipeItem
> > *item)
> > +static void red_channel_client_pipe_remove(RedChannelClient *rcc,
> > RedPipeItem
> > *item)
> > {
> > rcc->pipe_size--;
> > ring_remove(&item->link);
> > @@ -1324,13 +1324,13 @@ static inline int
> > red_channel_client_waiting_for_ack(RedChannelClient *rcc)
> > (rcc->ack_data.messages_window > rcc->ack_data.client_window *
> > 2));
> > }
> >
> > -static inline PipeItem *red_channel_client_pipe_item_get(RedChannelClient
> > *rcc)
> > +static inline RedPipeItem
> > *red_channel_client_pipe_item_get(RedChannelClient
> > *rcc)
> > {
> > - PipeItem *item;
> > + RedPipeItem *item;
> >
> > if (!rcc || rcc->send_data.blocked
> > || red_channel_client_waiting_for_ack(rcc)
> > - || !(item = (PipeItem *)ring_get_tail(&rcc->pipe))) {
> > + || !(item = (RedPipeItem *)ring_get_tail(&rcc->pipe))) {
> > return NULL;
> > }
> > red_channel_client_pipe_remove(rcc, item);
> > @@ -1339,7 +1339,7 @@ static inline PipeItem
> > *red_channel_client_pipe_item_get(RedChannelClient *rcc)
> >
> > void red_channel_client_push(RedChannelClient *rcc)
> > {
> > - PipeItem *pipe_item;
> > + RedPipeItem *pipe_item;
> >
> > if (!rcc->during_send) {
> > rcc->during_send = TRUE;
> > @@ -1589,7 +1589,7 @@ static void red_channel_client_event(int fd, int
> > event,
> > void *data)
> > red_channel_client_unref(rcc);
> > }
> >
> > -void red_channel_client_init_send_data(RedChannelClient *rcc, uint16_t
> > msg_type, PipeItem *item)
> > +void red_channel_client_init_send_data(RedChannelClient *rcc, uint16_t
> > msg_type, RedPipeItem *item)
> > {
> > spice_assert(red_channel_client_no_item_being_sent(rcc));
> > spice_assert(msg_type != 0);
> > @@ -1658,7 +1658,7 @@ void
> > red_channel_client_set_message_serial(RedChannelClient *rcc, uint64_t seria
> > rcc->send_data.serial = serial;
> > }
> >
> > -static inline gboolean client_pipe_add(RedChannelClient *rcc, PipeItem
> > *item,
> > RingItem *pos)
> > +static inline gboolean client_pipe_add(RedChannelClient *rcc, RedPipeItem
> > *item, RingItem *pos)
> > {
> > spice_assert(rcc && item);
> > if (SPICE_UNLIKELY(!red_channel_client_is_connected(rcc))) {
> > @@ -1676,38 +1676,39 @@ static inline gboolean
> > client_pipe_add(RedChannelClient *rcc, PipeItem *item, Ri
> > return TRUE;
> > }
> >
> > -void red_channel_client_pipe_add(RedChannelClient *rcc, PipeItem *item)
> > +void red_channel_client_pipe_add(RedChannelClient *rcc, RedPipeItem *item)
> > {
> >
> > client_pipe_add(rcc, item, &rcc->pipe);
> > }
> >
> > -void red_channel_client_pipe_add_push(RedChannelClient *rcc, PipeItem
> > *item)
> > +void red_channel_client_pipe_add_push(RedChannelClient *rcc, RedPipeItem
> > *item)
> > {
> > red_channel_client_pipe_add(rcc, item);
> > red_channel_client_push(rcc);
> > }
> >
> > void red_channel_client_pipe_add_after(RedChannelClient *rcc,
> > - PipeItem *item, PipeItem *pos)
> > + RedPipeItem *item,
> > + RedPipeItem *pos)
> > {
> > spice_assert(pos);
> > client_pipe_add(rcc, item, &pos->link);
> > }
> >
> > int red_channel_client_pipe_item_is_linked(RedChannelClient *rcc,
> > - PipeItem *item)
> > + RedPipeItem *item)
> > {
> > return ring_item_is_linked(&item->link);
> > }
> >
> > void red_channel_client_pipe_add_tail(RedChannelClient *rcc,
> > - PipeItem *item)
> > + RedPipeItem *item)
> > {
> > client_pipe_add(rcc, item, rcc->pipe.prev);
> > }
> >
> > -void red_channel_client_pipe_add_tail_and_push(RedChannelClient *rcc,
> > PipeItem *item)
> > +void red_channel_client_pipe_add_tail_and_push(RedChannelClient *rcc,
> > RedPipeItem *item)
> > {
> > if (client_pipe_add(rcc, item, rcc->pipe.prev)) {
> > red_channel_client_push(rcc);
> > @@ -1716,9 +1717,9 @@ void
> > red_channel_client_pipe_add_tail_and_push(RedChannelClient *rcc, PipeItem *
> >
> > void red_channel_client_pipe_add_type(RedChannelClient *rcc, int
> > pipe_item_type)
> > {
> > - PipeItem *item = spice_new(PipeItem, 1);
> > + RedPipeItem *item = spice_new(RedPipeItem, 1);
> >
> > - pipe_item_init(item, pipe_item_type);
> > + red_pipe_item_init(item, pipe_item_type);
> > red_channel_client_pipe_add(rcc, item);
> > red_channel_client_push(rcc);
> > }
> > @@ -1738,7 +1739,7 @@ void
> > red_channel_client_pipe_add_empty_msg(RedChannelClient *rcc, int msg_type)
> > {
> > EmptyMsgPipeItem *item = spice_new(EmptyMsgPipeItem, 1);
> >
> > - pipe_item_init(&item->base, PIPE_ITEM_TYPE_EMPTY_MSG);
> > + red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_EMPTY_MSG);
> > item->msg = msg_type;
> > red_channel_client_pipe_add(rcc, &item->base);
> > red_channel_client_push(rcc);
> > @@ -1781,12 +1782,12 @@ void
> > red_channel_client_clear_sent_item(RedChannelClient *rcc)
> >
> > void red_channel_client_pipe_clear(RedChannelClient *rcc)
> > {
> > - PipeItem *item;
> > + RedPipeItem *item;
> >
> > if (rcc) {
> > red_channel_client_clear_sent_item(rcc);
> > }
> > - while ((item = (PipeItem *)ring_get_head(&rcc->pipe))) {
> > + while ((item = (RedPipeItem *)ring_get_head(&rcc->pipe))) {
> > ring_remove(&item->link);
> > red_channel_client_release_item(rcc, item, FALSE);
> > }
> > @@ -2029,7 +2030,7 @@ int
> > red_channel_client_no_item_being_sent(RedChannelClient *rcc)
> > }
> >
> > void red_channel_client_pipe_remove_and_release(RedChannelClient *rcc,
> > - PipeItem *item)
> > + RedPipeItem *item)
> > {
> > red_channel_client_pipe_remove(rcc, item);
> > red_channel_client_release_item(rcc, item, FALSE);
> > @@ -2231,8 +2232,8 @@ int red_client_during_migrate_at_target(RedClient
> > *client)
> > * TODO - inline? macro? right now this is the simplest from code amount
> > */
> >
> > -typedef void (*rcc_item_t)(RedChannelClient *rcc, PipeItem *item);
> > -typedef int (*rcc_item_cond_t)(RedChannelClient *rcc, PipeItem *item);
> > +typedef void (*rcc_item_t)(RedChannelClient *rcc, RedPipeItem *item);
> > +typedef int (*rcc_item_cond_t)(RedChannelClient *rcc, RedPipeItem *item);
> >
> > /**
> > * red_channel_pipes_create_batch:
> > @@ -2249,7 +2250,7 @@ static int red_channel_pipes_create_batch(RedChannel
> > *channel,
> > {
> > RingItem *link, *next;
> > RedChannelClient *rcc;
> > - PipeItem *item;
> > + RedPipeItem *item;
> > int num = 0, n = 0;
> >
> > spice_assert(creator != NULL);
> > @@ -2362,7 +2363,7 @@ int
> > red_channel_client_wait_outgoing_item(RedChannelClient *rcc,
> >
> > /* TODO: more evil sync stuff. anything with the word wait in it's name.
> > */
> > int red_channel_client_wait_pipe_item_sent(RedChannelClient *rcc,
> > - PipeItem *item,
> > + RedPipeItem *item,
> > int64_t timeout)
> > {
> > uint64_t end_time;
> > diff --git a/server/red-channel.h b/server/red-channel.h
> > index 3c762ff..be5ae99 100644
> > --- a/server/red-channel.h
> > +++ b/server/red-channel.h
> > @@ -158,10 +158,10 @@ typedef void
> > (*channel_release_msg_recv_buf_proc)(RedChannelClient *channel,
> > uint16_t type, uint32_t
> > size, uint8_t *msg);
> > typedef void (*channel_disconnect_proc)(RedChannelClient *rcc);
> > typedef int (*channel_configure_socket_proc)(RedChannelClient *rcc);
> > -typedef void (*channel_send_pipe_item_proc)(RedChannelClient *rcc,
> > PipeItem
> > *item);
> > -typedef void (*channel_hold_pipe_item_proc)(RedChannelClient *rcc,
> > PipeItem
> > *item);
> > +typedef void (*channel_send_pipe_item_proc)(RedChannelClient *rcc,
> > RedPipeItem *item);
> > +typedef void (*channel_hold_pipe_item_proc)(RedChannelClient *rcc,
> > RedPipeItem *item);
> > typedef void (*channel_release_pipe_item_proc)(RedChannelClient *rcc,
> > - PipeItem *item, int
> > item_pushed);
> > + RedPipeItem *item, int
> > item_pushed);
> > typedef void (*channel_on_incoming_error_proc)(RedChannelClient *rcc);
> > typedef void (*channel_on_outgoing_error_proc)(RedChannelClient *rcc);
> >
> > @@ -258,7 +258,7 @@ struct RedChannelClient {
> > SpiceMarshaller *marshaller;
> > SpiceDataHeaderOpaque header;
> > uint32_t size;
> > - PipeItem *item;
> > + RedPipeItem *item;
> > int blocked;
> > uint64_t serial;
> > uint64_t last_sent_serial;
> > @@ -266,7 +266,7 @@ struct RedChannelClient {
> > struct {
> > SpiceMarshaller *marshaller;
> > uint8_t *header_data;
> > - PipeItem *item;
> > + RedPipeItem *item;
> > } main;
> >
> > struct {
> > @@ -434,7 +434,7 @@ int red_channel_client_handle_message(RedChannelClient
> > *rcc, uint32_t size,
> > uint16_t type, void *message);
> >
> > /* when preparing send_data: should call init and then use marshaller */
> > -void red_channel_client_init_send_data(RedChannelClient *rcc, uint16_t
> > msg_type, PipeItem *item);
> > +void red_channel_client_init_send_data(RedChannelClient *rcc, uint16_t
> > msg_type, RedPipeItem *item);
> >
> > uint64_t red_channel_client_get_message_serial(RedChannelClient *channel);
> > void red_channel_client_set_message_serial(RedChannelClient *channel,
> > uint64_t);
> > @@ -465,20 +465,20 @@ int
> > red_channel_client_get_roundtrip_ms(RedChannelClient
> > *rcc);
> > void red_channel_client_start_connectivity_monitoring(RedChannelClient
> > *rcc,
> > uint32_t timeout_ms);
> >
> > // TODO: add back the channel_pipe_add functionality - by adding reference
> > counting
> > -// to the PipeItem.
> > +// to the RedPipeItem.
> >
> > // helper to push a new item to all channels
> > -typedef PipeItem *(*new_pipe_item_t)(RedChannelClient *rcc, void *data,
> > int
> > num);
> > +typedef RedPipeItem *(*new_pipe_item_t)(RedChannelClient *rcc, void *data,
> > int num);
> > int red_channel_pipes_new_add_push(RedChannel *channel, new_pipe_item_t
> > creator, void *data);
> > void red_channel_pipes_new_add(RedChannel *channel, new_pipe_item_t
> > creator,
> > void *data);
> > void red_channel_pipes_new_add_tail(RedChannel *channel, new_pipe_item_t
> > creator, void *data);
> >
> > -void red_channel_client_pipe_add_push(RedChannelClient *rcc, PipeItem
> > *item);
> > -void red_channel_client_pipe_add(RedChannelClient *rcc, PipeItem *item);
> > -void red_channel_client_pipe_add_after(RedChannelClient *rcc, PipeItem
> > *item,
> > PipeItem *pos);
> > -int red_channel_client_pipe_item_is_linked(RedChannelClient *rcc, PipeItem
> > *item);
> > -void red_channel_client_pipe_remove_and_release(RedChannelClient *rcc,
> > PipeItem *item);
> > -void red_channel_client_pipe_add_tail_and_push(RedChannelClient *rcc,
> > PipeItem *item);
> > +void red_channel_client_pipe_add_push(RedChannelClient *rcc, RedPipeItem
> > *item);
> > +void red_channel_client_pipe_add(RedChannelClient *rcc, RedPipeItem
> > *item);
> > +void red_channel_client_pipe_add_after(RedChannelClient *rcc, RedPipeItem
> > *item, RedPipeItem *pos);
> > +int red_channel_client_pipe_item_is_linked(RedChannelClient *rcc,
> > RedPipeItem
> > *item);
> > +void red_channel_client_pipe_remove_and_release(RedChannelClient *rcc,
> > RedPipeItem *item);
> > +void red_channel_client_pipe_add_tail_and_push(RedChannelClient *rcc,
> > RedPipeItem *item);
> > /* for types that use this routine -> the pipe item should be freed */
> > void red_channel_client_pipe_add_type(RedChannelClient *rcc, int
> > pipe_item_type);
> > void red_channel_pipes_add_type(RedChannel *channel, int pipe_item_type);
> > @@ -619,7 +619,7 @@ void red_client_migrate(RedClient *client);
> > */
> >
> > int red_channel_client_wait_pipe_item_sent(RedChannelClient *rcc,
> > - PipeItem *item,
> > + RedPipeItem *item,
> > int64_t timeout);
> > int red_channel_client_wait_outgoing_item(RedChannelClient *rcc,
> > int64_t timeout);
> > diff --git a/server/red-pipe-item.c b/server/red-pipe-item.c
> > index 098f1d4..d9c60aa 100644
> > --- a/server/red-pipe-item.c
> > +++ b/server/red-pipe-item.c
> > @@ -20,9 +20,9 @@
> > #include "red-channel.h"
> > #include "red-pipe-item.h"
> >
> > -PipeItem *pipe_item_ref(gpointer object)
> > +RedPipeItem *red_pipe_item_ref(gpointer object)
> > {
> > - PipeItem *item = object;
> > + RedPipeItem *item = object;
> >
> > g_return_val_if_fail(item->refcount > 0, NULL);
> >
> > @@ -31,9 +31,9 @@ PipeItem *pipe_item_ref(gpointer object)
> > return item;
> > }
> >
> > -void pipe_item_unref(gpointer object)
> > +void red_pipe_item_unref(gpointer object)
> > {
> > - PipeItem *item = object;
> > + RedPipeItem *item = object;
> >
> > g_return_if_fail(item->refcount > 0);
> >
> > @@ -42,9 +42,9 @@ void pipe_item_unref(gpointer object)
> > }
> > }
> >
> > -void pipe_item_init_full(PipeItem *item,
> > - gint type,
> > - GDestroyNotify free_func)
> > +void red_pipe_item_init_full(RedPipeItem *item,
> > + gint type,
> > + GDestroyNotify free_func)
> > {
> > ring_item_init(&item->link);
> > item->type = type;
> > diff --git a/server/red-pipe-item.h b/server/red-pipe-item.h
> > index 4333e19..8bb12b7 100644
> > --- a/server/red-pipe-item.h
> > +++ b/server/red-pipe-item.h
> > @@ -28,19 +28,19 @@ typedef struct {
> > int refcount;
> >
> > GDestroyNotify free_func;
> > -} PipeItem;
> > +} RedPipeItem;
> >
> > -void pipe_item_init_full(PipeItem *item, int type, GDestroyNotify
> > free_func);
> > -PipeItem *pipe_item_ref(gpointer item);
> > -void pipe_item_unref(gpointer item);
> > +void red_pipe_item_init_full(RedPipeItem *item, int type, GDestroyNotify
> > free_func);
> > +RedPipeItem *red_pipe_item_ref(gpointer item);
> > +void red_pipe_item_unref(gpointer item);
> >
> > -static inline int pipe_item_is_linked(PipeItem *item)
> > +static inline int red_pipe_item_is_linked(RedPipeItem *item)
> > {
> > return ring_item_is_linked(&item->link);
> > }
> >
> > -static inline void pipe_item_init(PipeItem *item, int type)
> > +static inline void red_pipe_item_init(RedPipeItem *item, int type)
> > {
> > - pipe_item_init_full(item, type, NULL);
> > + red_pipe_item_init_full(item, type, NULL);
> > }
> > #endif
> > diff --git a/server/red-worker.h b/server/red-worker.h
> > index 15cceb8..731afc7 100644
> > --- a/server/red-worker.h
> > +++ b/server/red-worker.h
> > @@ -57,7 +57,7 @@ enum {
> > };
> >
> > typedef struct VerbItem {
> > - PipeItem base;
> > + RedPipeItem base;
> > uint16_t verb;
> > } VerbItem;
> >
> > @@ -70,7 +70,7 @@ static inline void red_pipe_add_verb(RedChannelClient*
> > rcc,
> > uint16_t verb)
> > {
> > VerbItem *item = spice_new(VerbItem, 1);
> >
> > - pipe_item_init(&item->base, PIPE_ITEM_TYPE_VERB);
> > + red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_VERB);
> > item->verb = verb;
> > red_channel_client_pipe_add(rcc, &item->base);
> > }
> > diff --git a/server/reds.c b/server/reds.c
> > index 4e553c3..9dd87d9 100644
> > --- a/server/reds.c
> > +++ b/server/reds.c
> > @@ -167,7 +167,7 @@ struct ChannelSecurityOptions {
> > };
> >
> > typedef struct VDIReadBuf {
> > - PipeItem parent;
> > + RedPipeItem parent;
> > RedCharDeviceVDIPort *dev;
> >
> > int len;
> > @@ -482,7 +482,7 @@ static void reds_reset_vdp(RedsState *reds)
> > dev->priv->receive_len = sizeof(dev->priv->vdi_chunk_header);
> > dev->priv->message_receive_len = 0;
> > if (dev->priv->current_read_buf) {
> > - pipe_item_unref(dev->priv->current_read_buf);
> > + red_pipe_item_unref(dev->priv->current_read_buf);
> > dev->priv->current_read_buf = NULL;
> > }
> > /* Reset read filter to start with clean state when the agent
> > reconnects
> > */
> > @@ -705,7 +705,7 @@ static void vdi_port_read_buf_release(uint8_t *data,
> > void
> > *opaque)
> > {
> > VDIReadBuf *buf = (VDIReadBuf *)opaque;
> >
> > - pipe_item_unref(buf);
> > + red_pipe_item_unref(buf);
> > }
> >
> > /* returns TRUE if the buffer can be forwarded */
> > @@ -744,8 +744,8 @@ static void vdi_read_buf_init(VDIReadBuf *buf)
> > /* Bogus pipe item type, we only need the RingItem and refcounting
> > * from the base class and are not going to use the type
> > */
> > - pipe_item_init_full(&buf->parent, -1,
> > - (GDestroyNotify)vdi_port_read_buf_free);
> > + red_pipe_item_init_full(&buf->parent, -1,
> > + (GDestroyNotify)vdi_port_read_buf_free);
> > }
> >
> > static VDIReadBuf *vdi_port_get_read_buf(RedCharDeviceVDIPort *dev)
> > @@ -782,8 +782,8 @@ static void vdi_port_read_buf_free(VDIReadBuf *buf)
> >
> > /* reads from the device till completes reading a message that is
> > addressed
> > to the client,
> > * or otherwise, when reading from the device fails */
> > -static PipeItem *vdi_port_read_one_msg_from_device(SpiceCharDeviceInstance
> > *sin,
> > - void *opaque)
> > +static RedPipeItem
> > *vdi_port_read_one_msg_from_device(SpiceCharDeviceInstance
> > *sin,
> > + void *opaque)
> > {
> > RedsState *reds;
> > RedCharDeviceVDIPort *dev = RED_CHAR_DEVICE_VDIPORT(sin->st);
> > @@ -843,12 +843,12 @@ static PipeItem
> > *vdi_port_read_one_msg_from_device(SpiceCharDeviceInstance *sin,
> > dev->priv->read_state = VDI_PORT_READ_STATE_GET_BUFF;
> > }
> > if (vdi_port_read_buf_process(reds->agent_dev, dispatch_buf,
> > &error)) {
> > - return (PipeItem *)dispatch_buf;
> > + return (RedPipeItem *)dispatch_buf;
> > } else {
> > if (error) {
> > reds_agent_remove(reds);
> > }
> > - pipe_item_unref(dispatch_buf);
> > + red_pipe_item_unref(dispatch_buf);
> > }
> > }
> > } /* END switch */
> > @@ -857,13 +857,13 @@ static PipeItem
> > *vdi_port_read_one_msg_from_device(SpiceCharDeviceInstance *sin,
> > }
> >
> > /* after calling this, we unref the message, and the ref is in the
> > instance
> > side */
> > -static void vdi_port_send_msg_to_client(PipeItem *msg,
> > +static void vdi_port_send_msg_to_client(RedPipeItem *msg,
> > RedClient *client,
> > void *opaque)
> > {
> > VDIReadBuf *agent_data_buf = (VDIReadBuf *)msg;
> >
> > - pipe_item_ref(agent_data_buf);
> > + red_pipe_item_ref(agent_data_buf);
> > main_channel_client_push_agent_data(red_client_get_main(client),
> > agent_data_buf->data,
> > agent_data_buf->len,
> > @@ -1218,7 +1218,7 @@ void reds_on_main_channel_migrate(RedsState *reds,
> > MainChannelClient *mcc)
> > if (error) {
> > reds_agent_remove(reds);
> > }
> > - pipe_item_unref(read_buf);
> > + red_pipe_item_unref(read_buf);
> > }
> >
> > spice_assert(agent_dev->priv->receive_len);
> > @@ -4301,7 +4301,7 @@ red_char_device_vdi_port_init(RedCharDeviceVDIPort
> > *self)
> > /* This ensures the newly created buffer is placed in the
> > * RedCharDeviceVDIPort::read_bufs queue ready to be reused
> > */
> > - pipe_item_unref(buf);
> > + red_pipe_item_unref(buf);
> > }
> > }
> >
> > diff --git a/server/smartcard.c b/server/smartcard.c
> > index b9b8967..75c5dd2 100644
> > --- a/server/smartcard.c
> > +++ b/server/smartcard.c
> > @@ -83,19 +83,19 @@ enum {
> > };
> >
> > typedef struct ErrorItem {
> > - PipeItem base;
> > + RedPipeItem base;
> > VSCMsgHeader vheader;
> > VSCMsgError error;
> > } ErrorItem;
> >
> > typedef struct MsgItem {
> > - PipeItem base;
> > + RedPipeItem base;
> >
> > VSCMsgHeader* vheader;
> > } MsgItem;
> >
> > static MsgItem *smartcard_get_vsc_msg_item(RedChannelClient *rcc,
> > VSCMsgHeader *vheader);
> > -static void smartcard_channel_client_pipe_add_push(RedChannelClient *rcc,
> > PipeItem *item);
> > +static void smartcard_channel_client_pipe_add_push(RedChannelClient *rcc,
> > RedPipeItem *item);
> >
> > typedef struct SmartCardChannel {
> > RedChannel base;
> > @@ -129,8 +129,8 @@ static void
> > smartcard_read_buf_prepare(RedCharDeviceSmartcard *dev, VSCMsgHeader
> > }
> > }
> >
> > -static PipeItem *smartcard_read_msg_from_device(SpiceCharDeviceInstance
> > *sin,
> > - void *opaque)
> > +static RedPipeItem *smartcard_read_msg_from_device(SpiceCharDeviceInstance
> > *sin,
> > + void *opaque)
> > {
> > RedCharDeviceSmartcard *dev = opaque;
> > SpiceCharDeviceInterface *sif = spice_char_device_get_interface(sin);
> > @@ -160,19 +160,19 @@ static PipeItem
> > *smartcard_read_msg_from_device(SpiceCharDeviceInstance *sin,
> > dev->priv->buf_pos = dev->priv->buf;
> > dev->priv->buf_used = remaining;
> > if (msg_to_client) {
> > - return (PipeItem *)msg_to_client;
> > + return (RedPipeItem *)msg_to_client;
> > }
> > }
> > return NULL;
> > }
> >
> > -static void smartcard_send_msg_to_client(PipeItem *msg,
> > +static void smartcard_send_msg_to_client(RedPipeItem *msg,
> > RedClient *client,
> > void *opaque)
> > {
> > RedCharDeviceSmartcard *dev = opaque;
> > spice_assert(dev->priv->scc && dev->priv->scc->base.client == client);
> > - smartcard_channel_client_pipe_add_push(&dev->priv->scc->base,
> > (PipeItem
> > *)msg);
> > + smartcard_channel_client_pipe_add_push(&dev->priv->scc->base,
> > (RedPipeItem *)msg);
> >
> > }
> >
> > @@ -427,7 +427,7 @@ static void
> > smartcard_channel_release_msg_rcv_buf(RedChannelClient *rcc,
> > }
> >
> > static void smartcard_channel_send_data(RedChannelClient *rcc,
> > SpiceMarshaller *m,
> > - PipeItem *item, VSCMsgHeader
> > *vheader)
> > + RedPipeItem *item, VSCMsgHeader
> > *vheader)
> > {
> > spice_assert(rcc);
> > spice_assert(vheader);
> > @@ -439,7 +439,7 @@ static void
> > smartcard_channel_send_data(RedChannelClient
> > *rcc, SpiceMarshaller *
> > }
> >
> > static void smartcard_channel_send_error(
> > - RedChannelClient *rcc, SpiceMarshaller *m, PipeItem *item)
> > + RedChannelClient *rcc, SpiceMarshaller *m, RedPipeItem *item)
> > {
> > ErrorItem* error_item = (ErrorItem*)item;
> >
> > @@ -447,7 +447,7 @@ static void smartcard_channel_send_error(
> > }
> >
> > static void smartcard_channel_send_msg(RedChannelClient *rcc,
> > - SpiceMarshaller *m, PipeItem *item)
> > + SpiceMarshaller *m, RedPipeItem
> > *item)
> > {
> > MsgItem* msg_item = (MsgItem*)item;
> >
> > @@ -455,7 +455,7 @@ static void smartcard_channel_send_msg(RedChannelClient
> > *rcc,
> > }
> >
> > static void smartcard_channel_send_migrate_data(RedChannelClient *rcc,
> > - SpiceMarshaller *m,
> > PipeItem
> > *item)
> > + SpiceMarshaller *m,
> > RedPipeItem *item)
> > {
> > SmartCardChannelClient *scc;
> > RedCharDeviceSmartcard *dev;
> > @@ -483,7 +483,7 @@ static void
> > smartcard_channel_send_migrate_data(RedChannelClient *rcc,
> > }
> > }
> >
> > -static void smartcard_channel_send_item(RedChannelClient *rcc, PipeItem
> > *item)
> > +static void smartcard_channel_send_item(RedChannelClient *rcc, RedPipeItem
> > *item)
> > {
> > SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
> >
> > @@ -506,10 +506,10 @@ static void
> > smartcard_channel_send_item(RedChannelClient
> > *rcc, PipeItem *item)
> > }
> >
> > static void smartcard_channel_release_pipe_item(RedChannelClient *rcc,
> > - PipeItem *item, int item_pushed)
> > + RedPipeItem *item, int item_pushed)
> > {
> > if (item->type == PIPE_ITEM_TYPE_SMARTCARD_DATA) {
> > - pipe_item_unref(item);
> > + red_pipe_item_unref(item);
> > } else {
> > free(item);
> > }
> > @@ -530,7 +530,8 @@ static void
> > smartcard_channel_on_disconnect(RedChannelClient *rcc)
> > /* this is called from both device input and client input. since the
> > device
> > is
> > * a usb device, the context is still the main thread (kvm_main_loop,
> > timers)
> > * so no mutex is required. */
> > -static void smartcard_channel_client_pipe_add_push(RedChannelClient *rcc,
> > PipeItem *item)
> > +static void smartcard_channel_client_pipe_add_push(RedChannelClient *rcc,
> > + RedPipeItem *item)
> > {
> > red_channel_client_pipe_add_push(rcc, item);
> > }
> > @@ -539,7 +540,7 @@ static void smartcard_push_error(RedChannelClient *rcc,
> > uint32_t reader_id, VSCE
> > {
> > ErrorItem *error_item = spice_new0(ErrorItem, 1);
> >
> > - pipe_item_init(&error_item->base, PIPE_ITEM_TYPE_ERROR);
> > + red_pipe_item_init(&error_item->base, PIPE_ITEM_TYPE_ERROR);
> >
> > error_item->base.type = PIPE_ITEM_TYPE_ERROR;
> > error_item->vheader.reader_id = reader_id;
> > @@ -559,8 +560,8 @@ static MsgItem
> > *smartcard_get_vsc_msg_item(RedChannelClient *rcc, VSCMsgHeader *
> > {
> > MsgItem *msg_item = spice_new0(MsgItem, 1);
> >
> > - pipe_item_init_full(&msg_item->base, PIPE_ITEM_TYPE_SMARTCARD_DATA,
> > - (GDestroyNotify)smartcard_free_vsc_msg_item);
> > + red_pipe_item_init_full(&msg_item->base,
> > PIPE_ITEM_TYPE_SMARTCARD_DATA,
> > + (GDestroyNotify)smartcard_free_vsc_msg_item);
> > msg_item->vheader = vheader;
> > return msg_item;
> > }
> > @@ -747,7 +748,8 @@ static int
> > smartcard_channel_handle_message(RedChannelClient *rcc,
> > return TRUE;
> > }
> >
> > -static void smartcard_channel_hold_pipe_item(RedChannelClient *rcc,
> > PipeItem
> > *item)
> > +static void smartcard_channel_hold_pipe_item(RedChannelClient *rcc,
> > + RedPipeItem *item)
> > {
> > }
> >
> > diff --git a/server/spicevmc.c b/server/spicevmc.c
> > index aa6a0ed..8450f19 100644
> > --- a/server/spicevmc.c
> > +++ b/server/spicevmc.c
> > @@ -43,7 +43,7 @@
> > #define BUF_SIZE (64 * 1024 + 32)
> >
> > typedef struct SpiceVmcPipeItem {
> > - PipeItem base;
> > + RedPipeItem base;
> >
> > /* writes which don't fit this will get split, this is not a problem
> > */
> > uint8_t buf[BUF_SIZE];
> > @@ -88,13 +88,13 @@ static RedCharDevice
> > *red_char_device_spicevmc_new(SpiceCharDeviceInstance *sin,
> > G_DEFINE_TYPE(RedCharDeviceSpiceVmc, red_char_device_spicevmc,
> > RED_TYPE_CHAR_DEVICE)
> >
> > typedef struct PortInitPipeItem {
> > - PipeItem base;
> > + RedPipeItem base;
> > char* name;
> > uint8_t opened;
> > } PortInitPipeItem;
> >
> > typedef struct PortEventPipeItem {
> > - PipeItem base;
> > + RedPipeItem base;
> > uint8_t event;
> > } PortEventPipeItem;
> >
> > @@ -105,8 +105,8 @@ enum {
> > PIPE_ITEM_TYPE_PORT_EVENT,
> > };
> >
> > -static PipeItem
> > *spicevmc_chardev_read_msg_from_dev(SpiceCharDeviceInstance
> > *sin,
> > - void *opaque)
> > +static RedPipeItem
> > *spicevmc_chardev_read_msg_from_dev(SpiceCharDeviceInstance *sin,
> > + void *opaque)
> > {
> > SpiceVmcState *state = opaque;
> > SpiceCharDeviceInterface *sif;
> > @@ -121,7 +121,7 @@ static PipeItem
> > *spicevmc_chardev_read_msg_from_dev(SpiceCharDeviceInstance *sin
> >
> > if (!state->pipe_item) {
> > msg_item = spice_new0(SpiceVmcPipeItem, 1);
> > - pipe_item_init(&msg_item->base, PIPE_ITEM_TYPE_SPICEVMC_DATA);
> > + red_pipe_item_init(&msg_item->base, PIPE_ITEM_TYPE_SPICEVMC_DATA);
> > } else {
> > spice_assert(state->pipe_item->buf_used == 0);
> > msg_item = state->pipe_item;
> > @@ -133,14 +133,14 @@ static PipeItem
> > *spicevmc_chardev_read_msg_from_dev(SpiceCharDeviceInstance *sin
> > if (n > 0) {
> > spice_debug("read from dev %d", n);
> > msg_item->buf_used = n;
> > - return (PipeItem *)msg_item;
> > + return (RedPipeItem *)msg_item;
> > } else {
> > state->pipe_item = msg_item;
> > return NULL;
> > }
> > }
> >
> > -static void spicevmc_chardev_send_msg_to_client(PipeItem *msg,
> > +static void spicevmc_chardev_send_msg_to_client(RedPipeItem *msg,
> > RedClient *client,
> > void *opaque)
> > {
> > @@ -148,8 +148,8 @@ static void
> > spicevmc_chardev_send_msg_to_client(PipeItem
> > *msg,
> > SpiceVmcPipeItem *vmc_msg = (SpiceVmcPipeItem *)msg;
> >
> > spice_assert(state->rcc->client == client);
> > - pipe_item_ref(vmc_msg);
> > - red_channel_client_pipe_add_push(state->rcc, (PipeItem *)vmc_msg);
> > + red_pipe_item_ref(vmc_msg);
> > + red_channel_client_pipe_add_push(state->rcc, (RedPipeItem *)vmc_msg);
> > }
> >
> > static void spicevmc_port_send_init(RedChannelClient *rcc)
> > @@ -158,7 +158,7 @@ static void spicevmc_port_send_init(RedChannelClient
> > *rcc)
> > SpiceCharDeviceInstance *sin = state->chardev_sin;
> > PortInitPipeItem *item = spice_malloc(sizeof(PortInitPipeItem));
> >
> > - pipe_item_init(&item->base, PIPE_ITEM_TYPE_PORT_INIT);
> > + red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_PORT_INIT);
> > item->name = strdup(sin->portname);
> > item->opened = state->port_opened;
> > red_channel_client_pipe_add_push(rcc, &item->base);
> > @@ -168,7 +168,7 @@ static void spicevmc_port_send_event(RedChannelClient
> > *rcc, uint8_t event)
> > {
> > PortEventPipeItem *item = spice_malloc(sizeof(PortEventPipeItem));
> >
> > - pipe_item_init(&item->base, PIPE_ITEM_TYPE_PORT_EVENT);
> > + red_pipe_item_init(&item->base, PIPE_ITEM_TYPE_PORT_EVENT);
> > item->event = event;
> > red_channel_client_pipe_add_push(rcc, &item->base);
> > }
> > @@ -360,14 +360,14 @@ static void
> > spicevmc_red_channel_release_msg_rcv_buf(RedChannelClient *rcc,
> > }
> >
> > static void spicevmc_red_channel_hold_pipe_item(RedChannelClient *rcc,
> > - PipeItem *item)
> > + RedPipeItem *item)
> > {
> > /* NOOP */
> > }
> >
> > static void spicevmc_red_channel_send_data(RedChannelClient *rcc,
> > SpiceMarshaller *m,
> > - PipeItem *item)
> > + RedPipeItem *item)
> > {
> > SpiceVmcPipeItem *i = SPICE_CONTAINEROF(item, SpiceVmcPipeItem, base);
> >
> > @@ -377,7 +377,7 @@ static void
> > spicevmc_red_channel_send_data(RedChannelClient *rcc,
> >
> > static void spicevmc_red_channel_send_migrate_data(RedChannelClient *rcc,
> > SpiceMarshaller *m,
> > - PipeItem *item)
> > + RedPipeItem *item)
> > {
> > SpiceVmcState *state;
> >
> > @@ -391,7 +391,7 @@ static void
> > spicevmc_red_channel_send_migrate_data(RedChannelClient *rcc,
> >
> > static void spicevmc_red_channel_send_port_init(RedChannelClient *rcc,
> > SpiceMarshaller *m,
> > - PipeItem *item)
> > + RedPipeItem *item)
> > {
> > PortInitPipeItem *i = SPICE_CONTAINEROF(item, PortInitPipeItem, base);
> > SpiceMsgPortInit init;
> > @@ -405,7 +405,7 @@ static void
> > spicevmc_red_channel_send_port_init(RedChannelClient *rcc,
> >
> > static void spicevmc_red_channel_send_port_event(RedChannelClient *rcc,
> > SpiceMarshaller *m,
> > - PipeItem *item)
> > + RedPipeItem *item)
> > {
> > PortEventPipeItem *i = SPICE_CONTAINEROF(item, PortEventPipeItem,
> > base);
> > SpiceMsgPortEvent event;
> > @@ -416,7 +416,7 @@ static void
> > spicevmc_red_channel_send_port_event(RedChannelClient *rcc,
> > }
> >
> > static void spicevmc_red_channel_send_item(RedChannelClient *rcc,
> > - PipeItem *item)
> > + RedPipeItem *item)
> > {
> > SpiceMarshaller *m = red_channel_client_get_marshaller(rcc);
> >
> > @@ -442,10 +442,11 @@ static void
> > spicevmc_red_channel_send_item(RedChannelClient *rcc,
> > }
> >
> > static void spicevmc_red_channel_release_pipe_item(RedChannelClient *rcc,
> > - PipeItem *item, int item_pushed)
> > + RedPipeItem *item,
> > + int item_pushed)
> > {
> > if (item->type == PIPE_ITEM_TYPE_SPICEVMC_DATA) {
> > - pipe_item_unref(item);
> > + red_pipe_item_unref(item);
> > } else {
> > free(item);
> > }
> > diff --git a/server/stream.c b/server/stream.c
> > index 22e1004..47f6a99 100644
> > --- a/server/stream.c
> > +++ b/server/stream.c
> > @@ -78,7 +78,7 @@ void stream_stop(DisplayChannel *display, Stream *stream)
> > stream_agent = &dcc->stream_agents[get_stream_id(display,
> > stream)];
> > region_clear(&stream_agent->vis_region);
> > region_clear(&stream_agent->clip);
> > - spice_assert(!pipe_item_is_linked(&stream_agent->destroy_item));
> > +
> > spice_assert(!red_pipe_item_is_linked(&stream_agent->destroy_item));
> > if (stream_agent->mjpeg_encoder && dcc
> > ->use_mjpeg_encoder_rate_control) {
> > uint64_t stream_bit_rate =
> > mjpeg_encoder_get_bit_rate(stream_agent->mjpeg_encoder);
> >
> > @@ -148,8 +148,8 @@ void stream_clip_item_free(StreamClipItem *item)
> > StreamClipItem *stream_clip_item_new(StreamAgent *agent)
> > {
> > StreamClipItem *item = spice_new(StreamClipItem, 1);
> > - pipe_item_init_full((PipeItem *)item, PIPE_ITEM_TYPE_STREAM_CLIP,
> > - (GDestroyNotify)stream_clip_item_free);
> > + red_pipe_item_init_full((RedPipeItem *)item,
> > PIPE_ITEM_TYPE_STREAM_CLIP,
> > + (GDestroyNotify)stream_clip_item_free);
> >
> > item->stream_agent = agent;
> > agent->stream->refs++;
> > @@ -343,7 +343,7 @@ static void before_reattach_stream(DisplayChannel
> > *display,
> > continue;
> > }
> >
> > - if (pipe_item_is_linked(&dpi->dpi_pipe_item)) {
> > + if (red_pipe_item_is_linked(&dpi->dpi_pipe_item)) {
> > #ifdef STREAM_STATS
> > agent->stats.num_drops_pipe++;
> > #endif
> > @@ -734,8 +734,8 @@ void dcc_create_stream(DisplayChannelClient *dcc,
> > Stream
> > *stream)
> > StreamActivateReportItem *report_pipe_item =
> > spice_malloc0(sizeof(*report_pipe_item));
> >
> > agent->report_id = rand();
> > - pipe_item_init(&report_pipe_item->pipe_item,
> > - PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT);
> > + red_pipe_item_init(&report_pipe_item->pipe_item,
> > + PIPE_ITEM_TYPE_STREAM_ACTIVATE_REPORT);
> > report_pipe_item->stream_id = get_stream_id(DCC_TO_DC(dcc),
> > stream);
> > red_channel_client_pipe_add(RED_CHANNEL_CLIENT(dcc),
> > &report_pipe_item->pipe_item);
> > }
> > @@ -808,8 +808,8 @@ static void
> > dcc_detach_stream_gracefully(DisplayChannelClient *dcc,
> > rect_debug(&stream->current->red_drawable->bbox);
> > rcc = RED_CHANNEL_CLIENT(dcc);
> > upgrade_item = spice_new(UpgradeItem, 1);
> > - pipe_item_init_full(&upgrade_item->base, PIPE_ITEM_TYPE_UPGRADE,
> > - (GDestroyNotify)upgrade_item_free);
> > + red_pipe_item_init_full(&upgrade_item->base,
> > PIPE_ITEM_TYPE_UPGRADE,
> > + (GDestroyNotify)upgrade_item_free);
> > upgrade_item->drawable = stream->current;
> > upgrade_item->drawable->refs++;
> > n_rects = pixman_region32_n_rects(&upgrade_item->drawable
> > ->tree_item.base.rgn);
> > diff --git a/server/stream.h b/server/stream.h
> > index c83e3b5..5b59212 100644
> > --- a/server/stream.h
> > +++ b/server/stream.h
> > @@ -47,7 +47,7 @@ typedef struct DisplayChannel DisplayChannel;
> > typedef struct Stream Stream;
> >
> > typedef struct StreamActivateReportItem {
> > - PipeItem pipe_item;
> > + RedPipeItem pipe_item;
> > uint32_t stream_id;
> > } StreamActivateReportItem;
> >
> > @@ -81,8 +81,8 @@ typedef struct StreamAgent {
> > vis_region will contain c2 and also the part of
> > c1/c2 that still
> > displays fragments of the video */
> >
> > - PipeItem create_item;
> > - PipeItem destroy_item;
> > + RedPipeItem create_item;
> > + RedPipeItem destroy_item;
> > Stream *stream;
> > uint64_t last_send_time;
> > MJpegEncoder *mjpeg_encoder;
> > @@ -100,7 +100,7 @@ typedef struct StreamAgent {
> > } StreamAgent;
> >
> > typedef struct StreamClipItem {
> > - PipeItem base;
> > + RedPipeItem base;
> > StreamAgent *stream_agent;
> > int clip_type;
> > SpiceClipRects *rects;
> _______________________________________________
> Spice-devel mailing list
> Spice-devel at lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/spice-devel
>
More information about the Spice-devel
mailing list