Fix the docs and do some minor clean up for PurpleQueuedOutputStream

Testing Done:
Built the docs and verified all of symbols were now documented.

Reviewed at https://reviews.imfreedom.org/r/1908/

1 files changed, 44 insertions, 57 deletions

diff --git a/libpurple/queuedoutputstream.c b/libpurple/queuedoutputstream.c
index 49a42a4b3a..bdc0ab4e48 100644
--- a/libpurple/queuedoutputstream.c
+++ b/libpurple/queuedoutputstream.c
@@ -1,10 +1,6 @@
 /*
- *
- * purple
- *
- * Purple is the legal property of its developers, whose names are too numerous
- * to list here.  Please refer to the COPYRIGHT file distributed with this
- * source distribution.
+ * Purple - Internet Messaging Library
+ * Copyright (C) Pidgin Developers <devel@pidgin.im>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -17,8 +13,7 @@
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
+ * along with this program; if not, see <https://www.gnu.org/licenses/>.
  */
 
 #include "queuedoutputstream.h"
@@ -42,7 +37,8 @@ static void purple_queued_output_stream_start_push_bytes_async(GTask *task);
 
 static void
 purple_queued_output_stream_push_bytes_async_cb(GObject *source,
-		GAsyncResult *res, gpointer user_data)
+                                                GAsyncResult *res,
+                                                gpointer user_data)
 {
 	GTask *task = G_TASK(user_data);
 	PurpleQueuedOutputStream *stream = g_task_get_source_object(task);
@@ -52,7 +48,7 @@ purple_queued_output_stream_push_bytes_async_cb(GObject *source,
 	GError *error = NULL;
 
 	written = g_output_stream_write_bytes_finish(G_OUTPUT_STREAM(source),
-			res, &error);
+	                                             res, &error);
 
 	bytes = g_task_get_task_data(task);
 	size = g_bytes_get_size(bytes);
@@ -64,8 +60,7 @@ purple_queued_output_stream_push_bytes_async_cb(GObject *source,
 	} else if (size > written) {
 		/* Partial write, prepare to send remaining data */
 		bytes = g_bytes_new_from_bytes(bytes, written, size - written);
-		g_task_set_task_data(task, bytes,
-				(GDestroyNotify)g_bytes_unref);
+		g_task_set_task_data(task, bytes, (GDestroyNotify)g_bytes_unref);
 	} else {
 		/* Full write, this task is finished */
 		g_task_return_boolean(task, TRUE);
@@ -93,29 +88,26 @@ purple_queued_output_stream_push_bytes_async_cb(GObject *source,
 }
 
 static void
-purple_queued_output_stream_start_push_bytes_async(GTask *task)
-{
+purple_queued_output_stream_start_push_bytes_async(GTask *task) {
 	PurpleQueuedOutputStream *stream = g_task_get_source_object(task);
-	GOutputStream *base_stream;
+	GOutputStream *base_stream = NULL;
+	GFilterOutputStream *filtered = NULL;
 
-	base_stream = g_filter_output_stream_get_base_stream(
-			G_FILTER_OUTPUT_STREAM(stream));
+	filtered = G_FILTER_OUTPUT_STREAM(stream);
+	base_stream = g_filter_output_stream_get_base_stream(filtered);
 
-	g_output_stream_write_bytes_async(base_stream,
-			g_task_get_task_data(task),
-			g_task_get_priority(task),
-			g_task_get_cancellable(task),
-			purple_queued_output_stream_push_bytes_async_cb,
-			task);
+	g_output_stream_write_bytes_async(base_stream, g_task_get_task_data(task),
+	                                  g_task_get_priority(task),
+	                                  g_task_get_cancellable(task),
+	                                  purple_queued_output_stream_push_bytes_async_cb,
+	                                  task);
 }
 
 /******************************************************************************
  * GObject Implementation
  *****************************************************************************/
-
 static void
-purple_queued_output_stream_dispose(GObject *object)
-{
+purple_queued_output_stream_dispose(GObject *object) {
 	PurpleQueuedOutputStream *stream = PURPLE_QUEUED_OUTPUT_STREAM(object);
 
 	g_clear_pointer(&stream->queue, g_async_queue_unref);
@@ -124,16 +116,14 @@ purple_queued_output_stream_dispose(GObject *object)
 }
 
 static void
-purple_queued_output_stream_class_init(PurpleQueuedOutputStreamClass *klass)
-{
+purple_queued_output_stream_class_init(PurpleQueuedOutputStreamClass *klass) {
 	GObjectClass *obj_class = G_OBJECT_CLASS(klass);
 
 	obj_class->dispose = purple_queued_output_stream_dispose;
 }
 
 static void
-purple_queued_output_stream_init(PurpleQueuedOutputStream *stream)
-{
+purple_queued_output_stream_init(PurpleQueuedOutputStream *stream) {
 	stream->queue = g_async_queue_new_full((GDestroyNotify)g_bytes_unref);
 	stream->pending_queued = FALSE;
 }
@@ -141,25 +131,22 @@ purple_queued_output_stream_init(PurpleQueuedOutputStream *stream)
 /******************************************************************************
  * Public API
  *****************************************************************************/
-
 PurpleQueuedOutputStream *
-purple_queued_output_stream_new(GOutputStream *base_stream)
-{
-	PurpleQueuedOutputStream *stream;
-
+purple_queued_output_stream_new(GOutputStream *base_stream) {
 	g_return_val_if_fail(G_IS_OUTPUT_STREAM(base_stream), NULL);
 
-	stream = g_object_new(PURPLE_TYPE_QUEUED_OUTPUT_STREAM,
-			"base-stream", base_stream,
-			NULL);
-
-	return stream;
+	return g_object_new(
+		PURPLE_TYPE_QUEUED_OUTPUT_STREAM,
+		"base-stream", base_stream,
+		NULL);
 }
 
 void
 purple_queued_output_stream_push_bytes_async(PurpleQueuedOutputStream *stream,
-		GBytes *bytes, int io_priority, GCancellable *cancellable,
-		GAsyncReadyCallback callback, gpointer user_data)
+                                             GBytes *bytes, int io_priority,
+                                             GCancellable *cancellable,
+                                             GAsyncReadyCallback callback,
+                                             gpointer user_data)
 {
 	GTask *task;
 	gboolean set_pending;
@@ -170,20 +157,19 @@ purple_queued_output_stream_push_bytes_async(PurpleQueuedOutputStream *stream,
 
 	task = g_task_new(stream, cancellable, callback, user_data);
 	g_task_set_task_data(task, g_bytes_ref(bytes),
-			(GDestroyNotify)g_bytes_unref);
-	g_task_set_source_tag(task,
-			purple_queued_output_stream_push_bytes_async);
+	                     (GDestroyNotify)g_bytes_unref);
+	g_task_set_source_tag(task, purple_queued_output_stream_push_bytes_async);
 	g_task_set_priority(task, io_priority);
 
-	set_pending = g_output_stream_set_pending(
-			G_OUTPUT_STREAM(stream), &error);
+	set_pending = g_output_stream_set_pending(G_OUTPUT_STREAM(stream), &error);
 
 	/* Since we're allowing queuing requests without blocking,
 	 * it's not an error to be pending while processing queued operations.
 	 */
-	if (!set_pending && (!g_error_matches(error,
-			G_IO_ERROR, G_IO_ERROR_PENDING) ||
-			!stream->pending_queued)) {
+	if(!set_pending &&
+	   (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_PENDING) ||
+	    !stream->pending_queued))
+	{
 		g_task_return_error(task, error);
 		g_object_unref(task);
 		return;
@@ -192,7 +178,7 @@ purple_queued_output_stream_push_bytes_async(PurpleQueuedOutputStream *stream,
 	g_clear_error(&error);
 	stream->pending_queued = TRUE;
 
-	if (set_pending) {
+	if(set_pending) {
 		/* Start processing if there were no pending operations */
 		purple_queued_output_stream_start_push_bytes_async(task);
 	} else {
@@ -203,26 +189,27 @@ purple_queued_output_stream_push_bytes_async(PurpleQueuedOutputStream *stream,
 
 gboolean
 purple_queued_output_stream_push_bytes_finish(PurpleQueuedOutputStream *stream,
-		GAsyncResult *result, GError **error)
+                                              GAsyncResult *result,
+                                              GError **error)
 {
 	g_return_val_if_fail(PURPLE_IS_QUEUED_OUTPUT_STREAM(stream), FALSE);
 	g_return_val_if_fail(g_task_is_valid(result, stream), FALSE);
 	g_return_val_if_fail(g_async_result_is_tagged(result,
-			purple_queued_output_stream_push_bytes_async), FALSE);
+	                                              purple_queued_output_stream_push_bytes_async),
+	                     FALSE);
 
 	return g_task_propagate_boolean(G_TASK(result), error);
 }
 
 void
-purple_queued_output_stream_clear_queue(PurpleQueuedOutputStream *stream)
-{
+purple_queued_output_stream_clear_queue(PurpleQueuedOutputStream *stream) {
 	GTask *task;
 
 	g_return_if_fail(PURPLE_IS_QUEUED_OUTPUT_STREAM(stream));
 
-	while ((task = g_async_queue_try_pop(stream->queue)) != NULL) {
+	while((task = g_async_queue_try_pop(stream->queue)) != NULL) {
 		g_task_return_new_error(task, G_IO_ERROR, G_IO_ERROR_CANCELLED,
-				"PurpleQueuedOutputStream queue cleared");
+		                        "PurpleQueuedOutputStream queue cleared");
 		g_object_unref(task);
 	}
 }