GNOME.org
 

[evolution-data-server/wip/camel-more-gobject] Seal CamelStream (and its descendants) properties

commit d8557501aca6f4c071296a8a0ad17adaab8990c0
Author: Milan Crha <mcrha redhat com>
Date:   Thu Nov 3 15:25:49 2016 +0100

    Seal CamelStream (and its descendants) properties

 src/camel/camel-data-wrapper.c                  |   70 +++++++++++++++++++++++
 src/camel/camel-data-wrapper.h                  |    8 +++
 src/camel/camel-stream-fs.c                     |   15 ++++-
 src/camel/camel-stream-null.c                   |   30 +++++++++-
 src/camel/camel-stream-null.h                   |    8 ++-
 src/camel/camel-stream-process.c                |   54 ++++++++++--------
 src/camel/camel-stream-process.h                |    5 +-
 src/camel/camel-stream.c                        |    9 ++-
 src/camel/camel-stream.h                        |    2 -
 src/camel/providers/imapx/camel-imapx-server.c  |    8 +--
 src/camel/providers/local/camel-local-summary.c |    8 +--
 src/camel/providers/smtp/camel-smtp-transport.c |   12 +---
 12 files changed, 167 insertions(+), 62 deletions(-)
---
diff --git a/src/camel/camel-data-wrapper.c b/src/camel/camel-data-wrapper.c
index b00bcf4..68c6093 100644
--- a/src/camel/camel-data-wrapper.c
+++ b/src/camel/camel-data-wrapper.c
@@ -29,6 +29,7 @@
 #include "camel-mime-filter-crlf.h"
 #include "camel-stream-filter.h"
 #include "camel-stream-mem.h"
+#include "camel-stream-null.h"
 
 #define d(x)
 
@@ -1544,3 +1545,72 @@ camel_data_wrapper_construct_from_input_stream_finish (CamelDataWrapper *data_wr
        return g_task_propagate_boolean (G_TASK (result), error);
 }
 
+/**
+ * camel_data_wrapper_calculate_size_sync:
+ * @data_wrapper: a #CamelDataWrapper
+ * @cancellable: a #GCancellable, or %NULL
+ * @error: return location for a #GError, or %NULL
+ *
+ * Calculates size of the @data_wrapper by saving it to a null-stream
+ * and returns how many bytes had been written. It's using
+ * camel_data_wrapper_write_to_stream_sync() internally.
+ *
+ * Returns: how many bytes the @data_wrapper would use when saved,
+ *   or -1 on error.
+ *
+ * Since: 3.24
+ **/
+gsize
+camel_data_wrapper_calculate_size_sync (CamelDataWrapper *data_wrapper,
+                                       GCancellable *cancellable,
+                                       GError **error)
+{
+       CamelStream *stream;
+       gsize bytes_written = -1;
+
+       g_return_val_if_fail (CAMEL_IS_DATA_WRAPPER (data_wrapper), -1);
+
+       stream = camel_stream_null_new ();
+
+       if (camel_data_wrapper_write_to_stream_sync (data_wrapper, stream, cancellable, error))
+               bytes_written = camel_stream_null_get_bytes_written (CAMEL_STREAM_NULL (stream));
+
+       g_object_unref (stream);
+
+       return bytes_written;
+}
+
+/**
+ * camel_data_wrapper_calculate_decoded_size_sync:
+ * @data_wrapper: a #CamelDataWrapper
+ * @cancellable: a #GCancellable, or %NULL
+ * @error: return location for a #GError, or %NULL
+ *
+ * Calculates decoded size of the @data_wrapper by saving it to a null-stream
+ * and returns how many bytes had been written. It's using
+ * camel_data_wrapper_decode_to_stream_sync() internally.
+ *
+ * Returns: how many bytes the @data_wrapper would use when saved,
+ *   or -1 on error.
+ *
+ * Since: 3.24
+ **/
+gsize
+camel_data_wrapper_calculate_decoded_size_sync (CamelDataWrapper *data_wrapper,
+                                               GCancellable *cancellable,
+                                               GError **error)
+{
+       CamelStream *stream;
+       gsize bytes_written = -1;
+
+       g_return_val_if_fail (CAMEL_IS_DATA_WRAPPER (data_wrapper), -1);
+
+       stream = camel_stream_null_new ();
+
+       if (camel_data_wrapper_decode_to_stream_sync (data_wrapper, stream, cancellable, error))
+               bytes_written = camel_stream_null_get_bytes_written (CAMEL_STREAM_NULL (stream));
+
+       g_object_unref (stream);
+
+       return bytes_written;
+}
diff --git a/src/camel/camel-data-wrapper.h b/src/camel/camel-data-wrapper.h
index 69f8dcb..34376d9 100644
--- a/src/camel/camel-data-wrapper.h
+++ b/src/camel/camel-data-wrapper.h
@@ -231,6 +231,14 @@ gboolean   camel_data_wrapper_construct_from_input_stream_finish
                                                (CamelDataWrapper *data_wrapper,
                                                 GAsyncResult *result,
                                                 GError **error);
+gsize          camel_data_wrapper_calculate_size_sync
+                                               (CamelDataWrapper *data_wrapper,
+                                                GCancellable *cancellable,
+                                                GError **error);
+gsize          camel_data_wrapper_calculate_decoded_size_sync
+                                               (CamelDataWrapper *data_wrapper,
+                                                GCancellable *cancellable,
+                                                GError **error);
 
 G_END_DECLS
 
diff --git a/src/camel/camel-stream-fs.c b/src/camel/camel-stream-fs.c
index 78045df..49f2fee 100644
--- a/src/camel/camel-stream-fs.c
+++ b/src/camel/camel-stream-fs.c
@@ -39,6 +39,7 @@
        ((obj), CAMEL_TYPE_STREAM_FS, CamelStreamFsPrivate))
 
 struct _CamelStreamFsPrivate {
+       gboolean eos;
        gint fd;        /* file descriptor on the underlying file */
 };
 
@@ -78,7 +79,7 @@ stream_fs_read (CamelStream *stream,
        nread = camel_read (priv->fd, buffer, n, cancellable, error);
 
        if (nread == 0)
-               stream->eos = TRUE;
+               priv->eos = TRUE;
 
        return nread;
 }
@@ -145,6 +146,14 @@ stream_fs_close (CamelStream *stream,
        return 0;
 }
 
+static gboolean
+stream_fs_eos (CamelStream *stream)
+{
+       CamelStreamFs *fs = CAMEL_STREAM_FS (stream);
+
+       return fs->priv->eos;
+}
+
 static goffset
 stream_fs_tell (GSeekable *seekable)
 {
@@ -201,7 +210,7 @@ stream_fs_seek (GSeekable *seekable,
                return FALSE;
        }
 
-       CAMEL_STREAM (seekable)->eos = FALSE;
+       priv->eos = FALSE;
 
        return TRUE;
 }
@@ -242,6 +251,7 @@ camel_stream_fs_class_init (CamelStreamFsClass *class)
        stream_class->write = stream_fs_write;
        stream_class->flush = stream_fs_flush;
        stream_class->close = stream_fs_close;
+       stream_class->eos = stream_fs_eos;
 }
 
 static void
@@ -259,6 +269,7 @@ camel_stream_fs_init (CamelStreamFs *stream)
 {
        stream->priv = CAMEL_STREAM_FS_GET_PRIVATE (stream);
        stream->priv->fd = -1;
+       stream->priv->eos = FALSE;
 }
 
 /**
diff --git a/src/camel/camel-stream-null.c b/src/camel/camel-stream-null.c
index db75989..72aa617 100644
--- a/src/camel/camel-stream-null.c
+++ b/src/camel/camel-stream-null.c
@@ -24,6 +24,10 @@
 
 #include "camel-stream-null.h"
 
+struct _CamelStreamNullPrivate {
+       gsize written;
+};
+
 static void camel_stream_null_seekable_init (GSeekableIface *iface);
 
 G_DEFINE_TYPE_WITH_CODE (CamelStreamNull, camel_stream_null, CAMEL_TYPE_STREAM,
@@ -36,7 +40,7 @@ stream_null_write (CamelStream *stream,
                    GCancellable *cancellable,
                    GError **error)
 {
-       CAMEL_STREAM_NULL (stream)->written += n;
+       CAMEL_STREAM_NULL (stream)->priv->written += n;
 
        return n;
 }
@@ -73,7 +77,7 @@ stream_null_seek (GSeekable *seekable,
                return FALSE;
        }
 
-       CAMEL_STREAM_NULL (seekable)->written = 0;
+       CAMEL_STREAM_NULL (seekable)->priv->written = 0;
 
        return TRUE;
 }
@@ -103,6 +107,8 @@ camel_stream_null_class_init (CamelStreamNullClass *class)
 {
        CamelStreamClass *stream_class;
 
+       g_type_class_add_private (class, sizeof (CamelStreamNullPrivate));
+
        stream_class = CAMEL_STREAM_CLASS (class);
        stream_class->write = stream_null_write;
        stream_class->eos = stream_null_eos;
@@ -121,6 +127,7 @@ camel_stream_null_seekable_init (GSeekableIface *iface)
 static void
 camel_stream_null_init (CamelStreamNull *stream_null)
 {
+       stream_null->priv = G_TYPE_INSTANCE_GET_PRIVATE (stream_null, CAMEL_TYPE_STREAM_NULL, 
CamelStreamNullPrivate);
 }
 
 /**
@@ -129,10 +136,27 @@ camel_stream_null_init (CamelStreamNull *stream_null)
  * Returns a null stream.  A null stream is always at eof, and
  * always returns success for all reads and writes.
  *
- * Returns: a new #CamelStreamNull
+ * Returns: (transfer full): a new #CamelStreamNull
  **/
 CamelStream *
 camel_stream_null_new (void)
 {
        return g_object_new (CAMEL_TYPE_STREAM_NULL, NULL);
 }
+
+/**
+ * camel_stream_null_get_bytes_written:
+ * @stream_null: a #CamelStreamNull
+ *
+ * Returns: how many bytes had been written to the @stream_null since
+ *   it was created or rewind to the beginning.
+ *
+ * Since: 3.24
+ **/
+gsize
+camel_stream_null_get_bytes_written (CamelStreamNull *stream_null)
+{
+       g_return_val_if_fail (CAMEL_IS_STREAM_NULL (stream_null), -1);
+
+       return stream_null->priv->written;
+}
diff --git a/src/camel/camel-stream-null.h b/src/camel/camel-stream-null.h
index 1fdcfde..51b3da5 100644
--- a/src/camel/camel-stream-null.h
+++ b/src/camel/camel-stream-null.h
@@ -49,11 +49,11 @@ G_BEGIN_DECLS
 
 typedef struct _CamelStreamNull CamelStreamNull;
 typedef struct _CamelStreamNullClass CamelStreamNullClass;
+typedef struct _CamelStreamNullPrivate CamelStreamNullPrivate;
 
 struct _CamelStreamNull {
        CamelStream parent;
-
-       gsize written;
+       CamelStreamNullPrivate *priv;
 };
 
 struct _CamelStreamNullClass {
@@ -65,7 +65,9 @@ struct _CamelStreamNullClass {
 
 GType camel_stream_null_get_type (void);
 
-CamelStream *camel_stream_null_new (void);
+CamelStream *  camel_stream_null_new           (void);
+gsize          camel_stream_null_get_bytes_written
+                                               (CamelStreamNull *stream_null);
 
 G_END_DECLS
 
diff --git a/src/camel/camel-stream-process.c b/src/camel/camel-stream-process.c
index c8ab3ac..1f6fa29 100644
--- a/src/camel/camel-stream-process.c
+++ b/src/camel/camel-stream-process.c
@@ -46,6 +46,11 @@
 
 extern gint camel_verbose_debug;
 
+struct _CamelStreamProcessPrivate {
+       gint sockfd;
+       pid_t childpid;
+};
+
 G_DEFINE_TYPE (CamelStreamProcess, camel_stream_process, CAMEL_TYPE_STREAM)
 
 static void
@@ -67,7 +72,7 @@ stream_process_read (CamelStream *stream,
                      GError **error)
 {
        CamelStreamProcess *stream_process = CAMEL_STREAM_PROCESS (stream);
-       gint fd = stream_process->sockfd;
+       gint fd = stream_process->priv->sockfd;
 
        return camel_read (fd, buffer, n, cancellable, error);
 }
@@ -80,7 +85,7 @@ stream_process_write (CamelStream *stream,
                       GError **error)
 {
        CamelStreamProcess *stream_process = CAMEL_STREAM_PROCESS (stream);
-       gint fd = stream_process->sockfd;
+       gint fd = stream_process->priv->sockfd;
 
        return camel_write (fd, buffer, n, cancellable, error);
 }
@@ -96,23 +101,23 @@ stream_process_close (CamelStream *object,
                fprintf (
                        stderr,
                        "Process stream close. sockfd %d, childpid %d\n",
-                       stream->sockfd, stream->childpid);
+                       stream->priv->sockfd, stream->priv->childpid);
 
-       if (stream->sockfd != -1) {
-               close (stream->sockfd);
-               stream->sockfd = -1;
+       if (stream->priv->sockfd != -1) {
+               close (stream->priv->sockfd);
+               stream->priv->sockfd = -1;
        }
 
-       if (stream->childpid) {
+       if (stream->priv->childpid) {
                gint ret, i;
                for (i = 0; i < 4; i++) {
-                       ret = waitpid (stream->childpid, NULL, WNOHANG);
+                       ret = waitpid (stream->priv->childpid, NULL, WNOHANG);
                        if (camel_verbose_debug)
                                fprintf (
                                        stderr,
                                        "waitpid() for pid %d returned %d (errno %d)\n",
-                                       stream->childpid, ret, ret == -1 ? errno : 0);
-                       if (ret == stream->childpid || errno == ECHILD)
+                                       stream->priv->childpid, ret, ret == -1 ? errno : 0);
+                       if (ret == stream->priv->childpid || errno == ECHILD)
                                break;
                        switch (i) {
                        case 0:
@@ -120,16 +125,16 @@ stream_process_close (CamelStream *object,
                                        fprintf (
                                                stderr,
                                                "Sending SIGTERM to pid %d\n",
-                                               stream->childpid);
-                               kill (stream->childpid, SIGTERM);
+                                               stream->priv->childpid);
+                               kill (stream->priv->childpid, SIGTERM);
                                break;
                        case 2:
                                if (camel_verbose_debug)
                                        fprintf (
                                                stderr,
                                                "Sending SIGKILL to pid %d\n",
-                                               stream->childpid);
-                               kill (stream->childpid, SIGKILL);
+                                               stream->priv->childpid);
+                               kill (stream->priv->childpid, SIGKILL);
                                break;
                        case 1:
                        case 3:
@@ -138,7 +143,7 @@ stream_process_close (CamelStream *object,
                        }
                }
 
-               stream->childpid = 0;
+               stream->priv->childpid = 0;
        }
 
        return 0;
@@ -158,6 +163,8 @@ camel_stream_process_class_init (CamelStreamProcessClass *class)
        GObjectClass *object_class;
        CamelStreamClass *stream_class;
 
+       g_type_class_add_private (class, sizeof (CamelStreamProcessPrivate));
+
        object_class = G_OBJECT_CLASS (class);
        object_class->finalize = stream_process_finalize;
 
@@ -171,8 +178,9 @@ camel_stream_process_class_init (CamelStreamProcessClass *class)
 static void
 camel_stream_process_init (CamelStreamProcess *stream)
 {
-       stream->sockfd = -1;
-       stream->childpid = 0;
+       stream->priv = G_TYPE_INSTANCE_GET_PRIVATE (stream, CAMEL_TYPE_STREAM_PROCESS, 
CamelStreamProcessPrivate);
+       stream->priv->sockfd = -1;
+       stream->priv->childpid = 0;
 }
 
 /**
@@ -247,24 +255,24 @@ camel_stream_process_connect (CamelStreamProcess *stream,
        g_return_val_if_fail (CAMEL_IS_STREAM_PROCESS (stream), -1);
        g_return_val_if_fail (command != NULL, -1);
 
-       if (stream->sockfd != -1 || stream->childpid)
+       if (stream->priv->sockfd != -1 || stream->priv->childpid)
                camel_stream_close (CAMEL_STREAM (stream), NULL, NULL);
 
        if (socketpair (AF_UNIX, SOCK_STREAM, 0, sockfds))
                goto fail;
 
-       stream->childpid = fork ();
-       if (!stream->childpid) {
+       stream->priv->childpid = fork ();
+       if (!stream->priv->childpid) {
                do_exec_command (sockfds[1], command, (gchar **) env);
-       } else if (stream->childpid == -1) {
+       } else if (stream->priv->childpid == -1) {
                close (sockfds[0]);
                close (sockfds[1]);
-               stream->sockfd = -1;
+               stream->priv->sockfd = -1;
                goto fail;
        }
 
        close (sockfds[1]);
-       stream->sockfd = sockfds[0];
+       stream->priv->sockfd = sockfds[0];
 
        return 0;
 
diff --git a/src/camel/camel-stream-process.h b/src/camel/camel-stream-process.h
index 4982232..b0de6fb 100644
--- a/src/camel/camel-stream-process.h
+++ b/src/camel/camel-stream-process.h
@@ -49,12 +49,11 @@ G_BEGIN_DECLS
 
 typedef struct _CamelStreamProcess CamelStreamProcess;
 typedef struct _CamelStreamProcessClass CamelStreamProcessClass;
+typedef struct _CamelStreamProcessPrivate CamelStreamProcessPrivate;
 
 struct _CamelStreamProcess {
        CamelStream parent;
-
-       gint sockfd;
-       pid_t childpid;
+       CamelStreamProcessPrivate *priv;
 };
 
 struct _CamelStreamProcessClass {
diff --git a/src/camel/camel-stream.c b/src/camel/camel-stream.c
index 8204b0e..5d43f02 100644
--- a/src/camel/camel-stream.c
+++ b/src/camel/camel-stream.c
@@ -33,6 +33,7 @@
 struct _CamelStreamPrivate {
        GIOStream *base_stream;
        GMutex base_stream_lock;
+       gboolean eos;
 };
 
 enum {
@@ -135,7 +136,7 @@ stream_read (CamelStream *stream,
                g_object_unref (base_stream);
        }
 
-       stream->eos = n_bytes_read <= 0;
+       stream->priv->eos = n_bytes_read <= 0;
 
        return n_bytes_read;
 }
@@ -157,7 +158,7 @@ stream_write (CamelStream *stream,
                gsize n_written = 0;
 
                output_stream = g_io_stream_get_output_stream (base_stream);
-               stream->eos = FALSE;
+               stream->priv->eos = FALSE;
 
                if (g_output_stream_write_all (output_stream, buffer, n, &n_written, cancellable, error))
                        n_bytes_written = (gssize) n_written;
@@ -219,7 +220,7 @@ stream_flush (CamelStream *stream,
 static gboolean
 stream_eos (CamelStream *stream)
 {
-       return stream->eos;
+       return stream->priv->eos;
 }
 
 static goffset
@@ -278,7 +279,7 @@ stream_seek (GSeekable *seekable,
        base_stream = camel_stream_ref_base_stream (stream);
 
        if (G_IS_SEEKABLE (base_stream)) {
-               stream->eos = FALSE;
+               stream->priv->eos = FALSE;
                success = g_seekable_seek (
                        G_SEEKABLE (base_stream),
                        offset, type, cancellable, error);
diff --git a/src/camel/camel-stream.h b/src/camel/camel-stream.h
index 05d6c89..1bfdbeb 100644
--- a/src/camel/camel-stream.h
+++ b/src/camel/camel-stream.h
@@ -58,8 +58,6 @@ typedef struct _CamelStreamPrivate CamelStreamPrivate;
 struct _CamelStream {
        GObject parent;
        CamelStreamPrivate *priv;
-
-       gboolean eos;
 };
 
 struct _CamelStreamClass {
diff --git a/src/camel/providers/imapx/camel-imapx-server.c b/src/camel/providers/imapx/camel-imapx-server.c
index bdf51b3..a765eab 100644
--- a/src/camel/providers/imapx/camel-imapx-server.c
+++ b/src/camel/providers/imapx/camel-imapx-server.c
@@ -4607,13 +4607,7 @@ camel_imapx_server_append_message_sync (CamelIMAPXServer *is,
        }
 
        if (!camel_message_info_get_size (info)) {
-               CamelStreamNull *sn = (CamelStreamNull *) camel_stream_null_new ();
-
-               camel_data_wrapper_write_to_stream_sync (
-                       CAMEL_DATA_WRAPPER (message),
-                       CAMEL_STREAM (sn), NULL, NULL);
-               camel_message_info_set_size (info, sn->written);
-               g_object_unref (sn);
+               camel_message_info_set_size (info, camel_data_wrapper_calculate_size_sync (CAMEL_DATA_WRAPPER 
(message), NULL, NULL));
        }
 
        g_free (uid);
diff --git a/src/camel/providers/local/camel-local-summary.c b/src/camel/providers/local/camel-local-summary.c
index 92c9016..f70ddbf 100644
--- a/src/camel/providers/local/camel-local-summary.c
+++ b/src/camel/providers/local/camel-local-summary.c
@@ -529,13 +529,7 @@ local_summary_add (CamelLocalSummary *cls,
 
        /* we need to calculate the size ourselves */
        if (camel_message_info_get_size (mi) == 0) {
-               CamelStreamNull *sn = (CamelStreamNull *) camel_stream_null_new ();
-
-               camel_data_wrapper_write_to_stream_sync (
-                       (CamelDataWrapper *) msg,
-                       (CamelStream *) sn, NULL, NULL);
-               camel_message_info_set_size (mi, sn->written);
-               g_object_unref (sn);
+               camel_message_info_set_size (mi, camel_data_wrapper_calculate_size_sync (CAMEL_DATA_WRAPPER 
(msg), NULL, NULL));
        }
 
        camel_message_info_set_flags (mi, CAMEL_MESSAGE_FOLDER_NOXEV, 0);
diff --git a/src/camel/providers/smtp/camel-smtp-transport.c b/src/camel/providers/smtp/camel-smtp-transport.c
index 1a555c3..03e2466 100644
--- a/src/camel/providers/smtp/camel-smtp-transport.c
+++ b/src/camel/providers/smtp/camel-smtp-transport.c
@@ -1644,7 +1644,7 @@ smtp_data (CamelSmtpTransport *transport,
        CamelStream *filtered_stream;
        gchar *cmdbuf, *respbuf = NULL;
        CamelMimeFilter *filter;
-       CamelStreamNull *null;
+       gsize bytes_written;
        gint ret;
 
        /* If the server doesn't support 8BITMIME, set our required encoding to be 7bit */
@@ -1714,22 +1714,18 @@ smtp_data (CamelSmtpTransport *transport,
        }
 
        /* find out how large the message is... */
-       null = CAMEL_STREAM_NULL (camel_stream_null_new ());
-       camel_data_wrapper_write_to_stream_sync (
-               CAMEL_DATA_WRAPPER (message),
-               CAMEL_STREAM (null), NULL, NULL);
+       bytes_written = camel_data_wrapper_calculate_size_sync (CAMEL_DATA_WRAPPER (message), NULL, NULL);
 
        /* Set the upload timeout to an equal of 512 bytes per second */
-       smtp_maybe_update_socket_timeout (ostream, null->written / 512);
+       smtp_maybe_update_socket_timeout (ostream, bytes_written / 512);
 
        filtered_stream = camel_stream_filter_new (ostream);
 
        /* setup progress reporting for message sending... */
-       filter = camel_mime_filter_progress_new (cancellable, null->written);
+       filter = camel_mime_filter_progress_new (cancellable, bytes_written);
        camel_stream_filter_add (
                CAMEL_STREAM_FILTER (filtered_stream), filter);
        g_object_unref (filter);
-       g_object_unref (null);
 
        /* setup LF->CRLF conversion */
        filter = camel_mime_filter_crlf_new (
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]