stream-device: Get rid of 'sin' use

1 files changed, 27 insertions, 29 deletions

diff --git a/server/red-stream-device.c b/server/red-stream-device.c
index 7cd3743f..cfb03f24 100644
--- a/server/red-stream-device.c
+++ b/server/red-stream-device.c
@@ -63,14 +63,12 @@ static StreamDevice *stream_device_new(SpiceCharDeviceInstance *sin, RedsState *
 
 G_DEFINE_TYPE(StreamDevice, stream_device, RED_TYPE_CHAR_DEVICE)
 
-typedef bool StreamMsgHandler(StreamDevice *dev, SpiceCharDeviceInstance *sin)
-    SPICE_GNUC_WARN_UNUSED_RESULT;
+typedef bool StreamMsgHandler(StreamDevice *dev) SPICE_GNUC_WARN_UNUSED_RESULT;
 
 static StreamMsgHandler handle_msg_format, handle_msg_device_display_info, handle_msg_data,
     handle_msg_cursor_set, handle_msg_cursor_move, handle_msg_capabilities;
 
-static bool handle_msg_invalid(StreamDevice *dev, SpiceCharDeviceInstance *sin,
-                               const char *error_msg) SPICE_GNUC_WARN_UNUSED_RESULT;
+static bool handle_msg_invalid(StreamDevice *dev, const char *error_msg) SPICE_GNUC_WARN_UNUSED_RESULT;
 
 RECORDER(stream_device_data, 32, "Stream device data packet");
 
@@ -94,7 +92,7 @@ fill_dev_hdr(StreamDevHeader *hdr, StreamMsgType msg_type, uint32_t msg_size)
 }
 
 static bool
-stream_device_partial_read(StreamDevice *dev, SpiceCharDeviceInstance *sin)
+stream_device_partial_read(StreamDevice *dev)
 {
     int n;
     bool handled = false;
@@ -142,40 +140,40 @@ stream_device_partial_read(StreamDevice *dev, SpiceCharDeviceInstance *sin)
     switch ((StreamMsgType) dev->hdr.type) {
     case STREAM_TYPE_FORMAT:
         if (dev->hdr.size != sizeof(StreamMsgFormat)) {
-            handled = handle_msg_invalid(dev, sin, "Wrong size for StreamMsgFormat");
+            handled = handle_msg_invalid(dev, "Wrong size for StreamMsgFormat");
         } else {
-            handled = handle_msg_format(dev, sin);
+            handled = handle_msg_format(dev);
         }
         break;
     case STREAM_TYPE_DEVICE_DISPLAY_INFO:
         if (dev->hdr.size > sizeof(StreamMsgDeviceDisplayInfo) + MAX_DEVICE_ADDRESS_LEN) {
-            handled = handle_msg_invalid(dev, sin, "StreamMsgDeviceDisplayInfo too large");
+            handled = handle_msg_invalid(dev, "StreamMsgDeviceDisplayInfo too large");
         } else {
-            handled = handle_msg_device_display_info(dev, sin);
+            handled = handle_msg_device_display_info(dev);
         }
         break;
     case STREAM_TYPE_DATA:
         if (dev->hdr.size > 32*1024*1024) {
-            handled = handle_msg_invalid(dev, sin, "STREAM_DATA too large");
+            handled = handle_msg_invalid(dev, "STREAM_DATA too large");
         } else {
-            handled = handle_msg_data(dev, sin);
+            handled = handle_msg_data(dev);
         }
         break;
     case STREAM_TYPE_CURSOR_SET:
-        handled = handle_msg_cursor_set(dev, sin);
+        handled = handle_msg_cursor_set(dev);
         break;
     case STREAM_TYPE_CURSOR_MOVE:
         if (dev->hdr.size != sizeof(StreamMsgCursorMove)) {
-            handled = handle_msg_invalid(dev, sin, "Wrong size for StreamMsgCursorMove");
+            handled = handle_msg_invalid(dev, "Wrong size for StreamMsgCursorMove");
         } else {
-            handled = handle_msg_cursor_move(dev, sin);
+            handled = handle_msg_cursor_move(dev);
         }
         break;
     case STREAM_TYPE_CAPABILITIES:
-        handled = handle_msg_capabilities(dev, sin);
+        handled = handle_msg_capabilities(dev);
         break;
     default:
-        handled = handle_msg_invalid(dev, sin, "Invalid message type");
+        handled = handle_msg_invalid(dev, "Invalid message type");
         break;
     }
 
@@ -210,14 +208,14 @@ stream_device_read_msg_from_dev(RedCharDevice *self, SpiceCharDeviceInstance *si
 {
     StreamDevice *dev = STREAM_DEVICE(self);
 
-    while (stream_device_partial_read(dev, sin)) {
+    while (stream_device_partial_read(dev)) {
         continue;
     }
     return NULL;
 }
 
 static bool
-handle_msg_invalid(StreamDevice *dev, SpiceCharDeviceInstance *sin, const char *error_msg)
+handle_msg_invalid(StreamDevice *dev, const char *error_msg)
 {
     static const char default_error_msg[] = "Protocol error";
 
@@ -253,7 +251,7 @@ handle_msg_invalid(StreamDevice *dev, SpiceCharDeviceInstance *sin, const char *
 }
 
 static bool
-handle_msg_format(StreamDevice *dev, SpiceCharDeviceInstance *sin)
+handle_msg_format(StreamDevice *dev)
 {
     if (spice_extra_checks) {
         spice_assert(dev->hdr_pos >= sizeof(StreamDevHeader));
@@ -262,7 +260,7 @@ handle_msg_format(StreamDevice *dev, SpiceCharDeviceInstance *sin)
 
     int n = spice_char_device_read(RED_CHAR_DEVICE(dev), dev->msg->buf + dev->msg_pos, sizeof(StreamMsgFormat) - dev->msg_pos);
     if (n < 0) {
-        return handle_msg_invalid(dev, sin, NULL);
+        return handle_msg_invalid(dev, NULL);
     }
 
     dev->msg_pos += n;
@@ -278,7 +276,7 @@ handle_msg_format(StreamDevice *dev, SpiceCharDeviceInstance *sin)
 }
 
 static bool
-handle_msg_device_display_info(StreamDevice *dev, SpiceCharDeviceInstance *sin)
+handle_msg_device_display_info(StreamDevice *dev)
 {
     if (spice_extra_checks) {
         spice_assert(dev->hdr_pos >= sizeof(StreamDevHeader));
@@ -345,7 +343,7 @@ handle_msg_device_display_info(StreamDevice *dev, SpiceCharDeviceInstance *sin)
 }
 
 static bool
-handle_msg_capabilities(StreamDevice *dev, SpiceCharDeviceInstance *sin)
+handle_msg_capabilities(StreamDevice *dev)
 {
     if (spice_extra_checks) {
         spice_assert(dev->hdr_pos >= sizeof(StreamDevHeader));
@@ -353,12 +351,12 @@ handle_msg_capabilities(StreamDevice *dev, SpiceCharDeviceInstance *sin)
     }
 
     if (dev->hdr.size > STREAM_MSG_CAPABILITIES_MAX_BYTES) {
-        return handle_msg_invalid(dev, sin, "Wrong size for StreamMsgCapabilities");
+        return handle_msg_invalid(dev, "Wrong size for StreamMsgCapabilities");
     }
 
     int n = spice_char_device_read(RED_CHAR_DEVICE(dev), dev->msg->buf + dev->msg_pos, dev->hdr.size - dev->msg_pos);
     if (n < 0) {
-        return handle_msg_invalid(dev, sin, NULL);
+        return handle_msg_invalid(dev, NULL);
     }
 
     dev->msg_pos += n;
@@ -376,7 +374,7 @@ handle_msg_capabilities(StreamDevice *dev, SpiceCharDeviceInstance *sin)
 }
 
 static bool
-handle_msg_data(StreamDevice *dev, SpiceCharDeviceInstance *sin)
+handle_msg_data(StreamDevice *dev)
 {
     int n;
 
@@ -491,7 +489,7 @@ stream_msg_cursor_set_to_cursor_cmd(const StreamMsgCursorSet *msg, size_t msg_si
 }
 
 static bool
-handle_msg_cursor_set(StreamDevice *dev, SpiceCharDeviceInstance *sin)
+handle_msg_cursor_set(StreamDevice *dev)
 {
     // Calculate the maximum size required to send the pixel data for a cursor that is the
     // maximum size using the format that requires the largest number of bits per pixel
@@ -504,7 +502,7 @@ handle_msg_cursor_set(StreamDevice *dev, SpiceCharDeviceInstance *sin)
     if (dev->hdr.size < sizeof(StreamMsgCursorSet) || dev->hdr.size > max_cursor_set_size) {
         // we could skip the message but on the other hand the guest
         // is buggy in any case
-        return handle_msg_invalid(dev, sin, "Cursor size is invalid");
+        return handle_msg_invalid(dev, "Cursor size is invalid");
     }
 
     // read part of the message till we get all
@@ -524,7 +522,7 @@ handle_msg_cursor_set(StreamDevice *dev, SpiceCharDeviceInstance *sin)
     // transform the message to a cursor command and process it
     RedCursorCmd *cmd = stream_msg_cursor_set_to_cursor_cmd(&dev->msg->cursor_set, dev->msg_pos);
     if (!cmd) {
-        return handle_msg_invalid(dev, sin, NULL);
+        return handle_msg_invalid(dev, NULL);
     }
     cursor_channel_process_cmd(dev->cursor_channel, cmd);
 
@@ -532,7 +530,7 @@ handle_msg_cursor_set(StreamDevice *dev, SpiceCharDeviceInstance *sin)
 }
 
 static bool
-handle_msg_cursor_move(StreamDevice *dev, SpiceCharDeviceInstance *sin)
+handle_msg_cursor_move(StreamDevice *dev)
 {
     int n = spice_char_device_read(RED_CHAR_DEVICE(dev), dev->msg->buf + dev->msg_pos, dev->hdr.size - dev->msg_pos);
     if (n <= 0) {