[PATCH spice-gtk 1/2] main: remove SpiceFileTransferTaskPrivate

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

 



The struct is already private

Signed-off-by: Marc-André Lureau <marcandre.lureau@xxxxxxxxx>
---
 src/channel-main.c             | 227 +++++++++++++++++++----------------------
 src/spice-file-transfer-task.h |   1 -
 2 files changed, 107 insertions(+), 121 deletions(-)

diff --git a/src/channel-main.c b/src/channel-main.c
index b91daa5..c9bc668 100644
--- a/src/channel-main.c
+++ b/src/channel-main.c
@@ -81,30 +81,6 @@ struct _SpiceFileTransferTask
 {
     GObject parent;
 
-    SpiceFileTransferTaskPrivate *priv;
-};
-
-/**
- * SpiceFileTransferTaskClass:
- * @parent_class: Parent class.
- *
- * Class structure for #SpiceFileTransferTask.
- */
-struct _SpiceFileTransferTaskClass
-{
-    GObjectClass parent_class;
-};
-
-G_DEFINE_TYPE(SpiceFileTransferTask, spice_file_transfer_task, G_TYPE_OBJECT)
-
-#define FILE_TRANSFER_TASK_PRIVATE(o) \
-        (G_TYPE_INSTANCE_GET_PRIVATE((o), SPICE_TYPE_FILE_TRANSFER_TASK, SpiceFileTransferTaskPrivate))
-
-#define FILE_XFER_CHUNK_SIZE (VD_AGENT_MAX_DATA_SIZE * 32)
-struct _SpiceFileTransferTaskPrivate
-
-/* private */
-{
     uint32_t                       id;
     gboolean                       pending;
     GFile                          *file;
@@ -124,6 +100,21 @@ struct _SpiceFileTransferTaskPrivate
     GError                         *error;
 };
 
+/**
+ * SpiceFileTransferTaskClass:
+ * @parent_class: Parent class.
+ *
+ * Class structure for #SpiceFileTransferTask.
+ */
+struct _SpiceFileTransferTaskClass
+{
+    GObjectClass parent_class;
+};
+
+G_DEFINE_TYPE(SpiceFileTransferTask, spice_file_transfer_task, G_TYPE_OBJECT)
+
+#define FILE_XFER_CHUNK_SIZE (VD_AGENT_MAX_DATA_SIZE * 32)
+
 enum {
     PROP_TASK_ID = 1,
     PROP_TASK_CHANNEL,
@@ -1837,23 +1828,23 @@ static void file_xfer_close_cb(GObject      *object,
 
     /* Notify to user that files have been transferred or something error
        happened. */
-    task = g_task_new(self->priv->channel,
-                      self->priv->cancellable,
-                      self->priv->callback,
-                      self->priv->user_data);
+    task = g_task_new(self->channel,
+                      self->cancellable,
+                      self->callback,
+                      self->user_data);
 
-    if (self->priv->error) {
-        g_task_return_error(task, self->priv->error);
+    if (self->error) {
+        g_task_return_error(task, self->error);
     } else {
         g_task_return_boolean(task, TRUE);
         if (spice_util_get_debug()) {
             gint64 now = g_get_monotonic_time();
-            gchar *basename = g_file_get_basename(self->priv->file);
-            double seconds = (double) (now - self->priv->start_time) / G_TIME_SPAN_SECOND;
-            gchar *file_size_str = g_format_size(self->priv->file_size);
-            gchar *transfer_speed_str = g_format_size(self->priv->file_size / seconds);
+            gchar *basename = g_file_get_basename(self->file);
+            double seconds = (double) (now - self->start_time) / G_TIME_SPAN_SECOND;
+            gchar *file_size_str = g_format_size(self->file_size);
+            gchar *transfer_speed_str = g_format_size(self->file_size / seconds);
 
-            g_warn_if_fail(self->priv->read_bytes == self->priv->file_size);
+            g_warn_if_fail(self->read_bytes == self->file_size);
             SPICE_DEBUG("transferred file %s of %s size in %.1f seconds (%s/s)",
                         basename, file_size_str, seconds, transfer_speed_str);
 
@@ -1875,9 +1866,9 @@ static void file_xfer_data_flushed_cb(GObject *source_object,
     SpiceMainChannel *channel = (SpiceMainChannel *)source_object;
     GError *error = NULL;
 
-    self->priv->pending = FALSE;
+    self->pending = FALSE;
     file_xfer_flush_finish(channel, res, &error);
-    if (error || self->priv->error) {
+    if (error || self->error) {
         spice_file_transfer_task_completed(self, error);
         return;
     }
@@ -1886,19 +1877,19 @@ static void file_xfer_data_flushed_cb(GObject *source_object,
         const GTimeSpan interval = 20 * G_TIME_SPAN_SECOND;
         gint64 now = g_get_monotonic_time();
 
-        if (interval < now - self->priv->last_update) {
-            gchar *basename = g_file_get_basename(self->priv->file);
-            self->priv->last_update = now;
+        if (interval < now - self->last_update) {
+            gchar *basename = g_file_get_basename(self->file);
+            self->last_update = now;
             SPICE_DEBUG("transferred %.2f%% of the file %s",
-                        100.0 * self->priv->read_bytes / self->priv->file_size, basename);
+                        100.0 * self->read_bytes / self->file_size, basename);
             g_free(basename);
         }
     }
 
-    if (self->priv->progress_callback) {
+    if (self->progress_callback) {
         goffset read = 0;
         goffset total = 0;
-        SpiceMainChannel *main_channel = self->priv->channel;
+        SpiceMainChannel *main_channel = self->channel;
         GHashTableIter iter;
         gpointer key, value;
 
@@ -1908,11 +1899,11 @@ static void file_xfer_data_flushed_cb(GObject *source_object,
         g_hash_table_iter_init(&iter, main_channel->priv->file_xfer_tasks);
         while (g_hash_table_iter_next(&iter, &key, &value)) {
             SpiceFileTransferTask *t = (SpiceFileTransferTask *)value;
-            read += t->priv->read_bytes;
-            total += t->priv->file_size;
+            read += t->read_bytes;
+            total += t->file_size;
         }
 
-        self->priv->progress_callback(read, total, self->priv->progress_callback_data);
+        self->progress_callback(read, total, self->progress_callback_data);
     }
 
     /* Read more data */
@@ -1922,13 +1913,13 @@ static void file_xfer_data_flushed_cb(GObject *source_object,
 static void file_xfer_queue(SpiceFileTransferTask *self, int data_size)
 {
     VDAgentFileXferDataMessage msg;
-    SpiceMainChannel *channel = SPICE_MAIN_CHANNEL(self->priv->channel);
+    SpiceMainChannel *channel = SPICE_MAIN_CHANNEL(self->channel);
 
-    msg.id = self->priv->id;
+    msg.id = self->id;
     msg.size = data_size;
     agent_msg_queue_many(channel, VD_AGENT_FILE_XFER_DATA,
                          &msg, sizeof(msg),
-                         self->priv->buffer, data_size, NULL);
+                         self->buffer, data_size, NULL);
     spice_channel_wakeup(SPICE_CHANNEL(channel), FALSE);
 }
 
@@ -1938,30 +1929,30 @@ static void file_xfer_read_cb(GObject *source_object,
                               gpointer user_data)
 {
     SpiceFileTransferTask *self = user_data;
-    SpiceMainChannel *channel = self->priv->channel;
+    SpiceMainChannel *channel = self->channel;
     gssize count;
     GError *error = NULL;
 
-    self->priv->pending = FALSE;
-    count = g_input_stream_read_finish(G_INPUT_STREAM(self->priv->file_stream),
+    self->pending = FALSE;
+    count = g_input_stream_read_finish(G_INPUT_STREAM(self->file_stream),
                                        res, &error);
     /* Check for pending earlier errors */
-    if (self->priv->error) {
+    if (self->error) {
         spice_file_transfer_task_completed(self, error);
         return;
     }
 
-    if (count > 0 || self->priv->file_size == 0) {
-        self->priv->read_bytes += count;
+    if (count > 0 || self->file_size == 0) {
+        self->read_bytes += count;
         g_object_notify(G_OBJECT(self), "progress");
         file_xfer_queue(self, count);
         if (count == 0)
             return;
-        file_xfer_flush_async(channel, self->priv->cancellable,
+        file_xfer_flush_async(channel, self->cancellable,
                               file_xfer_data_flushed_cb, self);
-        self->priv->pending = TRUE;
+        self->pending = TRUE;
     } else if (error) {
-        spice_channel_wakeup(SPICE_CHANNEL(self->priv->channel), FALSE);
+        spice_channel_wakeup(SPICE_CHANNEL(self->channel), FALSE);
         spice_file_transfer_task_completed(self, error);
     }
     /* else EOF, do nothing (wait for VD_AGENT_FILE_XFER_STATUS from agent) */
@@ -1970,14 +1961,14 @@ static void file_xfer_read_cb(GObject *source_object,
 /* coroutine context */
 static void file_xfer_continue_read(SpiceFileTransferTask *self)
 {
-    g_input_stream_read_async(G_INPUT_STREAM(self->priv->file_stream),
-                              self->priv->buffer,
+    g_input_stream_read_async(G_INPUT_STREAM(self->file_stream),
+                              self->buffer,
                               FILE_XFER_CHUNK_SIZE,
                               G_PRIORITY_DEFAULT,
-                              self->priv->cancellable,
+                              self->cancellable,
                               file_xfer_read_cb,
                               self);
-    self->priv->pending = TRUE;
+    self->pending = TRUE;
 }
 
 /* coroutine context */
@@ -1998,7 +1989,7 @@ static void file_xfer_handle_status(SpiceMainChannel *channel,
 
     switch (msg->result) {
     case VD_AGENT_FILE_XFER_STATUS_CAN_SEND_DATA:
-        if (task->priv->pending) {
+        if (task->pending) {
             error = g_error_new(SPICE_CLIENT_ERROR, SPICE_CLIENT_ERROR_FAILED,
                            "transfer received CAN_SEND_DATA in pending state");
             break;
@@ -2014,7 +2005,7 @@ static void file_xfer_handle_status(SpiceMainChannel *channel,
                             "some errors occurred in the spice agent");
         break;
     case VD_AGENT_FILE_XFER_STATUS_SUCCESS:
-        if (task->priv->pending)
+        if (task->pending)
             error = g_error_new(SPICE_CLIENT_ERROR, SPICE_CLIENT_ERROR_FAILED,
                                 "transfer received success in pending state");
         break;
@@ -2975,42 +2966,42 @@ static void spice_file_transfer_task_completed(SpiceFileTransferTask *self,
                                                GError *error)
 {
     /* In case of multiple errors we only report the first error */
-    if (self->priv->error)
+    if (self->error)
         g_clear_error(&error);
     if (error) {
-        gchar *path = g_file_get_path(self->priv->file);
+        gchar *path = g_file_get_path(self->file);
         SPICE_DEBUG("File %s xfer failed: %s",
                     path, error->message);
         g_free(path);
-        self->priv->error = error;
+        self->error = error;
     }
 
-    if (self->priv->error) {
+    if (self->error) {
         VDAgentFileXferStatusMessage msg = {
-            .id = self->priv->id,
-            .result = self->priv->error->code == G_IO_ERROR_CANCELLED ?
+            .id = self->id,
+            .result = self->error->code == G_IO_ERROR_CANCELLED ?
                     VD_AGENT_FILE_XFER_STATUS_CANCELLED : VD_AGENT_FILE_XFER_STATUS_ERROR,
         };
-        agent_msg_queue_many(self->priv->channel, VD_AGENT_FILE_XFER_STATUS,
+        agent_msg_queue_many(self->channel, VD_AGENT_FILE_XFER_STATUS,
                              &msg, sizeof(msg), NULL);
     }
 
-    if (self->priv->pending)
+    if (self->pending)
         return;
 
-    if (!self->priv->file_stream) {
+    if (!self->file_stream) {
         file_xfer_close_cb(NULL, NULL, self);
         goto signal;
     }
 
-    g_input_stream_close_async(G_INPUT_STREAM(self->priv->file_stream),
+    g_input_stream_close_async(G_INPUT_STREAM(self->file_stream),
                                G_PRIORITY_DEFAULT,
-                               self->priv->cancellable,
+                               self->cancellable,
                                file_xfer_close_cb,
                                self);
-    self->priv->pending = TRUE;
+    self->pending = TRUE;
 signal:
-    g_signal_emit(self, task_signals[SIGNAL_FINISHED], 0, self->priv->error);
+    g_signal_emit(self, task_signals[SIGNAL_FINISHED], 0, self->error);
 }
 
 
@@ -3026,12 +3017,12 @@ static void file_xfer_info_async_cb(GObject *obj, GAsyncResult *res, gpointer da
     gchar *string;
     SpiceFileTransferTask *self = SPICE_FILE_TRANSFER_TASK(data);
 
-    self->priv->pending = FALSE;
+    self->pending = FALSE;
     info = g_file_query_info_finish(file, res, &error);
-    if (error || self->priv->error)
+    if (error || self->error)
         goto failed;
 
-    self->priv->file_size =
+    self->file_size =
         g_file_info_get_attribute_uint64(info, G_FILE_ATTRIBUTE_STANDARD_SIZE);
     g_object_notify(G_OBJECT(self), "progress");
     keyfile = g_key_file_new();
@@ -3041,7 +3032,7 @@ static void file_xfer_info_async_cb(GObject *obj, GAsyncResult *res, gpointer da
     g_key_file_set_string(keyfile, "vdagent-file-xfer", "name", basename);
     g_free(basename);
     /* File size */
-    g_key_file_set_uint64(keyfile, "vdagent-file-xfer", "size", self->priv->file_size);
+    g_key_file_set_uint64(keyfile, "vdagent-file-xfer", "size", self->file_size);
 
     /* Save keyfile content to memory. TODO: more file attributions
        need to be sent to guest */
@@ -3051,12 +3042,12 @@ static void file_xfer_info_async_cb(GObject *obj, GAsyncResult *res, gpointer da
         goto failed;
 
     /* Create file-xfer start message */
-    msg.id = self->priv->id;
-    agent_msg_queue_many(self->priv->channel, VD_AGENT_FILE_XFER_START,
+    msg.id = self->id;
+    agent_msg_queue_many(self->channel, VD_AGENT_FILE_XFER_START,
                          &msg, sizeof(msg),
                          string, data_len + 1, NULL);
     g_free(string);
-    spice_channel_wakeup(SPICE_CHANNEL(self->priv->channel), FALSE);
+    spice_channel_wakeup(SPICE_CHANNEL(self->channel), FALSE);
     return;
 
 failed:
@@ -3069,21 +3060,21 @@ static void file_xfer_read_async_cb(GObject *obj, GAsyncResult *res, gpointer da
     SpiceFileTransferTask *self = SPICE_FILE_TRANSFER_TASK(data);
     GError *error = NULL;
 
-    self->priv->pending = FALSE;
-    self->priv->file_stream = g_file_read_finish(file, res, &error);
-    if (error || self->priv->error) {
+    self->pending = FALSE;
+    self->file_stream = g_file_read_finish(file, res, &error);
+    if (error || self->error) {
         spice_file_transfer_task_completed(self, error);
         return;
     }
 
-    g_file_query_info_async(self->priv->file,
+    g_file_query_info_async(self->file,
                             G_FILE_ATTRIBUTE_STANDARD_SIZE,
                             G_FILE_QUERY_INFO_NONE,
                             G_PRIORITY_DEFAULT,
-                            self->priv->cancellable,
+                            self->cancellable,
                             file_xfer_info_async_cb,
                             self);
-    self->priv->pending = TRUE;
+    self->pending = TRUE;
 }
 
 static SpiceFileTransferTask *spice_file_transfer_task_new(SpiceMainChannel *channel,
@@ -3095,7 +3086,7 @@ static void task_finished(SpiceFileTransferTask *task,
                           gpointer data)
 {
     SpiceMainChannel *channel = SPICE_MAIN_CHANNEL(data);
-    g_hash_table_remove(channel->priv->file_xfer_tasks, GUINT_TO_POINTER(task->priv->id));
+    g_hash_table_remove(channel->priv->file_xfer_tasks, GUINT_TO_POINTER(task->id));
 }
 
 static void file_xfer_send_start_msg_async(SpiceMainChannel *channel,
@@ -3120,16 +3111,15 @@ static void file_xfer_send_start_msg_async(SpiceMainChannel *channel,
             task_cancellable = g_cancellable_new();
 
         task = spice_file_transfer_task_new(channel, files[i], task_cancellable);
-        task->priv->flags = flags;
-        task->priv->progress_callback = progress_callback;
-        task->priv->progress_callback_data = progress_callback_data;
-        task->priv->callback = callback;
-        task->priv->user_data = user_data;
-
-        CHANNEL_DEBUG(channel, "Insert a xfer task:%d to task list",
-                      task->priv->id);
+        task->flags = flags;
+        task->progress_callback = progress_callback;
+        task->progress_callback_data = progress_callback_data;
+        task->callback = callback;
+        task->user_data = user_data;
+
+        CHANNEL_DEBUG(channel, "Insert a xfer task:%d to task list", task->id);
         g_hash_table_insert(c->file_xfer_tasks,
-                            GUINT_TO_POINTER(task->priv->id),
+                            GUINT_TO_POINTER(task->id),
                             task);
         g_signal_connect(task, "finished", G_CALLBACK(task_finished), channel);
         g_signal_emit(channel, signals[SPICE_MAIN_NEW_FILE_TRANSFER], 0, task);
@@ -3139,7 +3129,7 @@ static void file_xfer_send_start_msg_async(SpiceMainChannel *channel,
                           cancellable,
                           file_xfer_read_async_cb,
                           g_object_ref(task));
-        task->priv->pending = TRUE;
+        task->pending = TRUE;
 
         /* if we created a per-task cancellable above, free it */
         if (!cancellable)
@@ -3252,10 +3242,10 @@ spice_file_transfer_task_get_property(GObject *object,
     switch (property_id)
     {
         case PROP_TASK_ID:
-            g_value_set_uint(value, self->priv->id);
+            g_value_set_uint(value, self->id);
             break;
         case PROP_TASK_FILE:
-            g_value_set_object(value, self->priv->file);
+            g_value_set_object(value, self->file);
             break;
         case PROP_TASK_PROGRESS:
             g_value_set_double(value, spice_file_transfer_task_get_progress(self));
@@ -3276,16 +3266,16 @@ spice_file_transfer_task_set_property(GObject *object,
     switch (property_id)
     {
         case PROP_TASK_ID:
-            self->priv->id = g_value_get_uint(value);
+            self->id = g_value_get_uint(value);
             break;
         case PROP_TASK_FILE:
-            self->priv->file = g_value_dup_object(value);
+            self->file = g_value_dup_object(value);
             break;
         case PROP_TASK_CHANNEL:
-            self->priv->channel = g_value_dup_object(value);
+            self->channel = g_value_dup_object(value);
             break;
         case PROP_TASK_CANCELLABLE:
-            self->priv->cancellable = g_value_dup_object(value);
+            self->cancellable = g_value_dup_object(value);
             break;
         default:
             G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
@@ -3297,7 +3287,7 @@ spice_file_transfer_task_dispose(GObject *object)
 {
     SpiceFileTransferTask *self = SPICE_FILE_TRANSFER_TASK(object);
 
-    g_clear_object(&self->priv->file);
+    g_clear_object(&self->file);
 
     G_OBJECT_CLASS(spice_file_transfer_task_parent_class)->dispose(object);
 }
@@ -3307,7 +3297,7 @@ spice_file_transfer_task_finalize(GObject *object)
 {
     SpiceFileTransferTask *self = SPICE_FILE_TRANSFER_TASK(object);
 
-    g_free(self->priv->buffer);
+    g_free(self->buffer);
 
     G_OBJECT_CLASS(spice_file_transfer_task_parent_class)->finalize(object);
 }
@@ -3318,9 +3308,9 @@ spice_file_transfer_task_constructed(GObject *object)
     SpiceFileTransferTask *self = SPICE_FILE_TRANSFER_TASK(object);
 
     if (spice_util_get_debug()) {
-        gchar *basename = g_file_get_basename(self->priv->file);
-        self->priv->start_time = g_get_monotonic_time();
-        self->priv->last_update = self->priv->start_time;
+        gchar *basename = g_file_get_basename(self->file);
+        self->start_time = g_get_monotonic_time();
+        self->last_update = self->start_time;
 
         SPICE_DEBUG("transfer of file %s has started", basename);
         g_free(basename);
@@ -3332,8 +3322,6 @@ spice_file_transfer_task_class_init(SpiceFileTransferTaskClass *klass)
 {
     GObjectClass *object_class = G_OBJECT_CLASS(klass);
 
-    g_type_class_add_private(klass, sizeof(SpiceFileTransferTaskPrivate));
-
     object_class->get_property = spice_file_transfer_task_get_property;
     object_class->set_property = spice_file_transfer_task_set_property;
     object_class->finalize = spice_file_transfer_task_finalize;
@@ -3439,8 +3427,7 @@ spice_file_transfer_task_class_init(SpiceFileTransferTaskClass *klass)
 static void
 spice_file_transfer_task_init(SpiceFileTransferTask *self)
 {
-    self->priv = FILE_TRANSFER_TASK_PRIVATE(self);
-    self->priv->buffer = g_malloc0(FILE_XFER_CHUNK_SIZE);
+    self->buffer = g_malloc0(FILE_XFER_CHUNK_SIZE);
 }
 
 static SpiceFileTransferTask *
@@ -3469,10 +3456,10 @@ spice_file_transfer_task_new(SpiceMainChannel *channel, GFile *file, GCancellabl
  **/
 double spice_file_transfer_task_get_progress(SpiceFileTransferTask *self)
 {
-    if (self->priv->file_size == 0)
+    if (self->file_size == 0)
         return 0.0;
 
-    return (double)self->priv->read_bytes / self->priv->file_size;
+    return (double)self->read_bytes / self->file_size;
 }
 
 /**
@@ -3488,7 +3475,7 @@ double spice_file_transfer_task_get_progress(SpiceFileTransferTask *self)
  **/
 void spice_file_transfer_task_cancel(SpiceFileTransferTask *self)
 {
-    g_cancellable_cancel(self->priv->cancellable);
+    g_cancellable_cancel(self->cancellable);
 }
 
 /**
@@ -3503,5 +3490,5 @@ void spice_file_transfer_task_cancel(SpiceFileTransferTask *self)
  **/
 char* spice_file_transfer_task_get_filename(SpiceFileTransferTask *self)
 {
-    return g_file_get_basename(self->priv->file);
+    return g_file_get_basename(self->file);
 }
diff --git a/src/spice-file-transfer-task.h b/src/spice-file-transfer-task.h
index 389668e..4f179fb 100644
--- a/src/spice-file-transfer-task.h
+++ b/src/spice-file-transfer-task.h
@@ -38,7 +38,6 @@ G_BEGIN_DECLS
 
 typedef struct _SpiceFileTransferTask SpiceFileTransferTask;
 typedef struct _SpiceFileTransferTaskClass SpiceFileTransferTaskClass;
-typedef struct _SpiceFileTransferTaskPrivate SpiceFileTransferTaskPrivate;
 
 GType spice_file_transfer_task_get_type(void) G_GNUC_CONST;
 
-- 
2.7.4

_______________________________________________
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]