/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; coding: utf-8 -*- */

/* gtksourcefilesaver.c

 * This file is part of GtkSourceView

 *

 * Copyright (C) 2005-2007 - Paolo Borelli and Paolo Maggi

 * Copyright (C) 2007 - Steve Frécinaux

 * Copyright (C) 2008 - Jesse van den Kieboom

 * Copyright (C) 2014, 2016 - Sébastien Wilmet

 *

 * GtkSourceView is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * GtkSourceView is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include "gtksourcefilesaver.h"

#include "gtksourcefile.h"

#include "gtksourcebufferinputstream.h"

#include "gtksourceencoding.h"

#include "gtksourcebuffer.h"

#include "gtksourcebuffer-private.h"

#include "gtksourceview-enumtypes.h"

#include "gtksourceview-i18n.h"

/**

 * SECTION:filesaver

 * @Short_description: Save a GtkSourceBuffer into a file

 * @Title: GtkSourceFileSaver

 * @See_also: #GtkSourceFile, #GtkSourceFileLoader

 *

 * A #GtkSourceFileSaver object permits to save a #GtkSourceBuffer into a

 * #GFile.

 *

 * A file saver should be used only for one save operation, including errors

 * handling. If an error occurs, you can reconfigure the saver and relaunch the

 * operation with gtk_source_file_saver_save_async().

 */

/* The code has been written initially in gedit (GeditDocumentSaver).

 * It uses a GtkSourceBufferInputStream as input, create converter(s) if needed

 * for the encoding and the compression, and write the contents to a

 * GOutputStream (the file).

 */

#if 0

#define DEBUG(x) (x)

#else

#define DEBUG(x)

#endif

#define WRITE_CHUNK_SIZE 8192

#define QUERY_ATTRIBUTES G_FILE_ATTRIBUTE_TIME_MODIFIED

enum

{

	PROP_0,

	PROP_BUFFER,

	PROP_FILE,

	PROP_LOCATION,

	PROP_ENCODING,

	PROP_NEWLINE_TYPE,

	PROP_COMPRESSION_TYPE,

	PROP_FLAGS

};

struct _GtkSourceFileSaverPrivate

{

	/* Weak ref to the GtkSourceBuffer. A strong ref could create a

	 * reference cycle in an application. For example a subclass of

	 * GtkSourceBuffer can have a strong ref to the FileSaver.

	 */

	GtkSourceBuffer *source_buffer;

	/* Weak ref to the GtkSourceFile. A strong ref could create a reference

	 * cycle in an application. For example a subclass of GtkSourceFile can

	 * have a strong ref to the FileSaver.

	 */

	GtkSourceFile *file;

	GFile *location;

	const GtkSourceEncoding *encoding;

	GtkSourceNewlineType newline_type;

	GtkSourceCompressionType compression_type;

	GtkSourceFileSaverFlags flags;

	GTask *task;

};

typedef struct _TaskData TaskData;

struct _TaskData

{

	/* The output_stream contains the required converter(s) for the encoding

	 * and the compression type.

	 * The two streams cannot be spliced directly, because:

	 * (1) We need to call the progress callback.

	 * (2) Sync methods must be used for the input stream, and async

	 *     methods for the output stream.

	 */

	GtkSourceBufferInputStream *input_stream;

	GOutputStream *output_stream;

	GFileInfo *info;

	goffset total_size;

	GFileProgressCallback progress_cb;

	gpointer progress_cb_data;

	GDestroyNotify progress_cb_notify;

	/* This field is used when cancelling the output stream: an error occurs

	 * and is stored in this field, the output stream is cancelled

	 * asynchronously, and then the error is reported to the task.

	 */

	GError *error;

	gssize chunk_bytes_read;

	gssize chunk_bytes_written;

	gchar chunk_buffer[WRITE_CHUNK_SIZE];

	guint tried_mount : 1;

};

G_DEFINE_TYPE_WITH_PRIVATE (GtkSourceFileSaver, gtk_source_file_saver, G_TYPE_OBJECT)

static void read_file_chunk (GTask *task);

static void write_file_chunk (GTask *task);

static void recover_not_mounted (GTask *task);

static TaskData *

task_data_new (void)

{

	return g_new0 (TaskData, 1);

}

static void

task_data_free (gpointer data)

{

	TaskData *task_data = data;

	if (task_data == NULL)

	{

		return;

	}

	g_clear_object (&task_data->input_stream);

	g_clear_object (&task_data->output_stream);

	g_clear_object (&task_data->info);

	g_clear_error (&task_data->error);

	if (task_data->progress_cb_notify != NULL)

	{

		task_data->progress_cb_notify (task_data->progress_cb_data);

	}

	g_free (task_data);

}

static void

gtk_source_file_saver_set_property (GObject      *object,

				    guint         prop_id,

				    const GValue *value,

				    GParamSpec   *pspec)

{

	GtkSourceFileSaver *saver = GTK_SOURCE_FILE_SAVER (object);

	switch (prop_id)

	{

		case PROP_BUFFER:

			g_assert (saver->priv->source_buffer == NULL);

			saver->priv->source_buffer = g_value_get_object (value);

			g_object_add_weak_pointer (G_OBJECT (saver->priv->source_buffer),

						   (gpointer *)&saver->priv->source_buffer);

			break;

		case PROP_FILE:

			g_assert (saver->priv->file == NULL);

			saver->priv->file = g_value_get_object (value);

			g_object_add_weak_pointer (G_OBJECT (saver->priv->file),

						   (gpointer *)&saver->priv->file);

			break;

		case PROP_LOCATION:

			g_assert (saver->priv->location == NULL);

			saver->priv->location = g_value_dup_object (value);

			break;

		case PROP_ENCODING:

			gtk_source_file_saver_set_encoding (saver, g_value_get_boxed (value));

			break;

		case PROP_NEWLINE_TYPE:

			gtk_source_file_saver_set_newline_type (saver, g_value_get_enum (value));

			break;

		case PROP_COMPRESSION_TYPE:

			gtk_source_file_saver_set_compression_type (saver, g_value_get_enum (value));

			break;

		case PROP_FLAGS:

			gtk_source_file_saver_set_flags (saver, g_value_get_flags (value));

			break;

		default:

			G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

			break;

	}

}

static void

gtk_source_file_saver_get_property (GObject    *object,

				    guint       prop_id,

				    GValue     *value,

				    GParamSpec *pspec)

{

	GtkSourceFileSaver *saver = GTK_SOURCE_FILE_SAVER (object);

	switch (prop_id)

	{

		case PROP_BUFFER:

			g_value_set_object (value, saver->priv->source_buffer);

			break;

		case PROP_FILE:

			g_value_set_object (value, saver->priv->file);

			break;

		case PROP_LOCATION:

			g_value_set_object (value, saver->priv->location);

			break;

		case PROP_ENCODING:

			g_value_set_boxed (value, saver->priv->encoding);

			break;

		case PROP_NEWLINE_TYPE:

			g_value_set_enum (value, saver->priv->newline_type);

			break;

		case PROP_COMPRESSION_TYPE:

			g_value_set_enum (value, saver->priv->compression_type);

			break;

		case PROP_FLAGS:

			g_value_set_flags (value, saver->priv->flags);

			break;

		default:

			G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

			break;

	}

}

static void

gtk_source_file_saver_dispose (GObject *object)

{

	GtkSourceFileSaver *saver = GTK_SOURCE_FILE_SAVER (object);

	if (saver->priv->source_buffer != NULL)

	{

		g_object_remove_weak_pointer (G_OBJECT (saver->priv->source_buffer),

					      (gpointer *)&saver->priv->source_buffer);

		saver->priv->source_buffer = NULL;

	}

	if (saver->priv->file != NULL)

	{

		g_object_remove_weak_pointer (G_OBJECT (saver->priv->file),

					      (gpointer *)&saver->priv->file);

		saver->priv->file = NULL;

	}

	g_clear_object (&saver->priv->location);

	g_clear_object (&saver->priv->task);

	G_OBJECT_CLASS (gtk_source_file_saver_parent_class)->dispose (object);

}

static void

gtk_source_file_saver_constructed (GObject *object)

{

	GtkSourceFileSaver *saver = GTK_SOURCE_FILE_SAVER (object);

	if (saver->priv->file != NULL)

	{

		const GtkSourceEncoding *encoding;

		GtkSourceNewlineType newline_type;

		GtkSourceCompressionType compression_type;

		encoding = gtk_source_file_get_encoding (saver->priv->file);

		gtk_source_file_saver_set_encoding (saver, encoding);

		newline_type = gtk_source_file_get_newline_type (saver->priv->file);

		gtk_source_file_saver_set_newline_type (saver, newline_type);

		compression_type = gtk_source_file_get_compression_type (saver->priv->file);

		gtk_source_file_saver_set_compression_type (saver, compression_type);

		if (saver->priv->location == NULL)

		{

			saver->priv->location = gtk_source_file_get_location (saver->priv->file);

			if (saver->priv->location != NULL)

			{

				g_object_ref (saver->priv->location);

			}

			else

			{

				g_warning ("GtkSourceFileSaver: the GtkSourceFile's location is NULL. "

					   "Use gtk_source_file_saver_new_with_target().");

			}

		}

	}

	G_OBJECT_CLASS (gtk_source_file_saver_parent_class)->constructed (object);

}

static void

gtk_source_file_saver_class_init (GtkSourceFileSaverClass *klass)

{

	GObjectClass *object_class = G_OBJECT_CLASS (klass);

	object_class->dispose = gtk_source_file_saver_dispose;

	object_class->set_property = gtk_source_file_saver_set_property;

	object_class->get_property = gtk_source_file_saver_get_property;

	object_class->constructed = gtk_source_file_saver_constructed;

	/**

	 * GtkSourceFileSaver:buffer:

	 *

	 * The #GtkSourceBuffer to save. The #GtkSourceFileSaver object has a

	 * weak reference to the buffer.

	 *

	 * Since: 3.14

	 */

	g_object_class_install_property (object_class,

					 PROP_BUFFER,

					 g_param_spec_object ("buffer",

							      "GtkSourceBuffer",

							      "",

							      GTK_SOURCE_TYPE_BUFFER,

							      G_PARAM_READWRITE |

							      G_PARAM_CONSTRUCT_ONLY |

							      G_PARAM_STATIC_STRINGS));

	/**

	 * GtkSourceFileSaver:file:

	 *

	 * The #GtkSourceFile. The #GtkSourceFileSaver object has a weak

	 * reference to the file.

	 *

	 * Since: 3.14

	 */

	g_object_class_install_property (object_class,

					 PROP_FILE,

					 g_param_spec_object ("file",

							      "GtkSourceFile",

							      "",

							      GTK_SOURCE_TYPE_FILE,

							      G_PARAM_READWRITE |

							      G_PARAM_CONSTRUCT_ONLY |

							      G_PARAM_STATIC_STRINGS));

	/**

	 * GtkSourceFileSaver:location:

	 *

	 * The #GFile where to save the buffer. By default the location is taken

	 * from the #GtkSourceFile at construction time.

	 *

	 * Since: 3.14

	 */

	g_object_class_install_property (object_class,

					 PROP_LOCATION,

					 g_param_spec_object ("location",

							      "Location",

							      "",

							      G_TYPE_FILE,

							      G_PARAM_READWRITE |

							      G_PARAM_CONSTRUCT_ONLY |

							      G_PARAM_STATIC_STRINGS));

	/**

	 * GtkSourceFileSaver:encoding:

	 *

	 * The file's encoding.

	 *

	 * Since: 3.14

	 */

	g_object_class_install_property (object_class,

					 PROP_ENCODING,

					 g_param_spec_boxed ("encoding",

							     "Encoding",

							     "",

							     GTK_SOURCE_TYPE_ENCODING,

							     G_PARAM_READWRITE |

							     G_PARAM_CONSTRUCT |

							     G_PARAM_STATIC_STRINGS));

	/**

	 * GtkSourceFileSaver:newline-type:

	 *

	 * The newline type.

	 *

	 * Since: 3.14

	 */

	g_object_class_install_property (object_class,

					 PROP_NEWLINE_TYPE,

					 g_param_spec_enum ("newline-type",

					                    "Newline type",

							    "",

					                    GTK_SOURCE_TYPE_NEWLINE_TYPE,

					                    GTK_SOURCE_NEWLINE_TYPE_LF,

					                    G_PARAM_READWRITE |

					                    G_PARAM_CONSTRUCT |

							    G_PARAM_STATIC_STRINGS));

	/**

	 * GtkSourceFileSaver:compression-type:

	 *

	 * The compression type.

	 *

	 * Since: 3.14

	 */

	g_object_class_install_property (object_class,

					 PROP_COMPRESSION_TYPE,

					 g_param_spec_enum ("compression-type",

					                    "Compression type",

					                    "",

					                    GTK_SOURCE_TYPE_COMPRESSION_TYPE,

					                    GTK_SOURCE_COMPRESSION_TYPE_NONE,

					                    G_PARAM_READWRITE |

					                    G_PARAM_CONSTRUCT |

							    G_PARAM_STATIC_STRINGS));

	/**

	 * GtkSourceFileSaver:flags:

	 *

	 * File saving flags.

	 *

	 * Since: 3.14

	 */

	g_object_class_install_property (object_class,

					 PROP_FLAGS,

					 g_param_spec_flags ("flags",

							     "Flags",

							     "",

							     GTK_SOURCE_TYPE_FILE_SAVER_FLAGS,

							     GTK_SOURCE_FILE_SAVER_FLAGS_NONE,

							     G_PARAM_READWRITE |

							     G_PARAM_CONSTRUCT |

							     G_PARAM_STATIC_STRINGS));

	/* Due to potential deadlocks when registering types, we need to

	 * ensure the dependent private class GtkSourceBufferInputStream

	 * has been registered up front.

	 *

	 * See https://bugzilla.gnome.org/show_bug.cgi?id=780216

	 */

	g_type_ensure (GTK_SOURCE_TYPE_BUFFER_INPUT_STREAM);

}

static void

gtk_source_file_saver_init (GtkSourceFileSaver *saver)

{

	saver->priv = gtk_source_file_saver_get_instance_private (saver);

}

/* BEGIN NOTE:

 *

 * This fixes an issue in GOutputStream that applies the atomic replace save

 * strategy. The stream moves the written file to the original file when the

 * stream is closed. However, there is no way currently to tell the stream that

 * the save should be aborted (there could be a conversion error). The patch

 * explicitly closes the output stream in all these cases with a GCancellable in

 * the cancelled state, causing the output stream to close, but not move the

 * file. This makes use of an implementation detail in the local file stream

 * and should be properly fixed by adding the appropriate API in GIO. Until

 * then, at least we prevent data corruption for now.

 *

 * Relevant bug reports:

 *

 * Bug 615110 - write file ignore encoding errors (gedit)

 * https://bugzilla.gnome.org/show_bug.cgi?id=615110

 *

 * Bug 602412 - g_file_replace does not restore original file when there is

 *              errors while writing (glib/gio)

 * https://bugzilla.gnome.org/show_bug.cgi?id=602412

 */

static void

cancel_output_stream_ready_cb (GObject      *source_object,

			       GAsyncResult *result,

			       gpointer      user_data)

{

	GOutputStream *output_stream = G_OUTPUT_STREAM (source_object);

	GTask *task = G_TASK (user_data);

	TaskData *task_data;

	task_data = g_task_get_task_data (task);

	g_output_stream_close_finish (output_stream, result, NULL);

	if (task_data->error != NULL)

	{

		GError *error = task_data->error;

		task_data->error = NULL;

		g_task_return_error (task, error);

	}

	else

	{

		g_task_return_boolean (task, FALSE);

	}

}

static void

cancel_output_stream (GTask *task)

{

	TaskData *task_data;

	GCancellable *cancellable;

	DEBUG ({

	       g_print ("Cancel output stream\n");

	});

	task_data = g_task_get_task_data (task);

	cancellable = g_cancellable_new ();

	g_cancellable_cancel (cancellable);

	g_output_stream_close_async (task_data->output_stream,

				     g_task_get_priority (task),

				     cancellable,

				     cancel_output_stream_ready_cb,

				     task);

	g_object_unref (cancellable);

}

/*

 * END NOTE

 */

static void

query_info_cb (GObject      *source_object,

	       GAsyncResult *result,

	       gpointer      user_data)

{

	GFile *location = G_FILE (source_object);

	GTask *task = G_TASK (user_data);

	TaskData *task_data;

	GError *error = NULL;

	DEBUG ({

	       g_print ("Finished query info on file\n");

	});

	task_data = g_task_get_task_data (task);

	g_clear_object (&task_data->info);

	task_data->info = g_file_query_info_finish (location, result, &error);

	if (error != NULL)

	{

		DEBUG ({

		       g_print ("Query info failed: %s\n", error->message);

		});

		g_task_return_error (task, error);

		return;

	}

	g_task_return_boolean (task, TRUE);

}

static void

close_output_stream_cb (GObject      *source_object,

			GAsyncResult *result,

			gpointer      user_data)

{

	GOutputStream *output_stream = G_OUTPUT_STREAM (source_object);

	GTask *task = G_TASK (user_data);

	GtkSourceFileSaver *saver;

	GError *error = NULL;

	DEBUG ({

	       g_print ("%s\n", G_STRFUNC);

	});

	saver = g_task_get_source_object (task);

	g_output_stream_close_finish (output_stream, result, &error);

	if (error != NULL)

	{

		DEBUG ({

		       g_print ("Closing stream error: %s\n", error->message);

		});

		g_task_return_error (task, error);

		return;

	}

	/* Get the file info: note we cannot use

	 * g_file_output_stream_query_info_async() since it is not able to get

	 * the modification time.

	 */

	DEBUG ({

	       g_print ("Query info on file\n");

	});

	g_file_query_info_async (saver->priv->location,

			         QUERY_ATTRIBUTES,

			         G_FILE_QUERY_INFO_NONE,

				 g_task_get_priority (task),

				 g_task_get_cancellable (task),

			         query_info_cb,

			         task);

}

static void

write_complete (GTask *task)

{

	TaskData *task_data;

	GError *error = NULL;

	DEBUG ({

	       g_print ("Close input stream\n");

	});

	task_data = g_task_get_task_data (task);

	g_input_stream_close (G_INPUT_STREAM (task_data->input_stream),

			      g_task_get_cancellable (task),

			      &error);

	if (error != NULL)

	{

		DEBUG ({

		       g_print ("Closing input stream error: %s\n", error->message);

		});

		g_clear_error (&task_data->error);

		task_data->error = error;

		cancel_output_stream (task);

		return;

	}

	DEBUG ({

	       g_print ("Close output stream\n");

	});

	g_output_stream_close_async (task_data->output_stream,

				     g_task_get_priority (task),

				     g_task_get_cancellable (task),

				     close_output_stream_cb,

				     task);

}

static void

write_file_chunk_cb (GObject      *source_object,

		     GAsyncResult *result,

		     gpointer      user_data)

{

	GOutputStream *output_stream = G_OUTPUT_STREAM (source_object);

	GTask *task = G_TASK (user_data);

	TaskData *task_data;

	gssize bytes_written;

	GError *error = NULL;

	DEBUG ({

	       g_print ("%s\n", G_STRFUNC);

	});

	task_data = g_task_get_task_data (task);

	bytes_written = g_output_stream_write_finish (output_stream, result, &error);

	DEBUG ({

	       g_print ("Written: %" G_GSSIZE_FORMAT "\n", bytes_written);

	});

	if (error != NULL)

	{

		DEBUG ({

		       g_print ("Write error: %s\n", error->message);

		});

		g_clear_error (&task_data->error);

		task_data->error = error;

		cancel_output_stream (task);

		return;

	}

	task_data->chunk_bytes_written += bytes_written;

	/* Write again */

	if (task_data->chunk_bytes_written < task_data->chunk_bytes_read)

	{

		write_file_chunk (task);

		return;

	}

	if (task_data->progress_cb != NULL)

	{

		gsize total_chars_written;

		total_chars_written = _gtk_source_buffer_input_stream_tell (task_data->input_stream);

		task_data->progress_cb (total_chars_written,

					task_data->total_size,

					task_data->progress_cb_data);

	}

	read_file_chunk (task);

}

static void

write_file_chunk (GTask *task)

{

	TaskData *task_data;

	DEBUG ({

	       g_print ("%s\n", G_STRFUNC);

	});

	task_data = g_task_get_task_data (task);

	g_output_stream_write_async (task_data->output_stream,

				     task_data->chunk_buffer + task_data->chunk_bytes_written,

				     task_data->chunk_bytes_read - task_data->chunk_bytes_written,

				     g_task_get_priority (task),

				     g_task_get_cancellable (task),

				     write_file_chunk_cb,

				     task);

}

static void

read_file_chunk (GTask *task)

{

	TaskData *task_data;

	GError *error = NULL;

	DEBUG ({

	       g_print ("%s\n", G_STRFUNC);

	});

	task_data = g_task_get_task_data (task);

	task_data->chunk_bytes_written = 0;

	/* We use sync methods on doc stream since it is in memory. Using async

	 * would be racy and we could end up with invalid iters.

	 */

	task_data->chunk_bytes_read = g_input_stream_read (G_INPUT_STREAM (task_data->input_stream),

							   task_data->chunk_buffer,

							   WRITE_CHUNK_SIZE,

							   g_task_get_cancellable (task),

							   &error);

	if (error != NULL)

	{

		g_clear_error (&task_data->error);

		task_data->error = error;

		cancel_output_stream (task);

		return;

	}

	/* Check if we finished reading and writing. */

	if (task_data->chunk_bytes_read == 0)

	{

		write_complete (task);

		return;

	}

	write_file_chunk (task);

}

static void

replace_file_cb (GObject      *source_object,

		 GAsyncResult *result,

		 gpointer      user_data)

{

	GFile *location = G_FILE (source_object);

	GTask *task = G_TASK (user_data);

	GtkSourceFileSaver *saver;

	TaskData *task_data;

	GFileOutputStream *file_output_stream;

	GOutputStream *output_stream;

	GError *error = NULL;

	DEBUG ({

	       g_print ("%s\n", G_STRFUNC);

	});

	saver = g_task_get_source_object (task);

	task_data = g_task_get_task_data (task);

	file_output_stream = g_file_replace_finish (location, result, &error);

	if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_MOUNTED) &&

	    !task_data->tried_mount)

	{

		recover_not_mounted (task);

		g_error_free (error);

		return;

	}

	else if (error != NULL)

	{

		DEBUG ({

		       g_print ("Opening file failed: %s\n", error->message);

		});

		g_task_return_error (task, error);

		return;

	}

	if (saver->priv->compression_type == GTK_SOURCE_COMPRESSION_TYPE_GZIP)

	{

		GZlibCompressor *compressor;

		DEBUG ({

		       g_print ("Use gzip compressor\n");

		});

		compressor = g_zlib_compressor_new (G_ZLIB_COMPRESSOR_FORMAT_GZIP, -1);

		output_stream = g_converter_output_stream_new (G_OUTPUT_STREAM (file_output_stream),

							       G_CONVERTER (compressor));

		g_object_unref (compressor);

		g_object_unref (file_output_stream);

	}

	else

	{

		output_stream = G_OUTPUT_STREAM (file_output_stream);

	}

	/* FIXME: manage converter error? */

	DEBUG ({

	       g_print ("Encoding charset: %s\n",

			gtk_source_encoding_get_charset (saver->priv->encoding));

	});

	if (saver->priv->encoding != gtk_source_encoding_get_utf8 ())

	{

		GCharsetConverter *converter;

		converter = g_charset_converter_new (gtk_source_encoding_get_charset (saver->priv->encoding),

						     "UTF-8",

						     NULL);

		g_clear_object (&task_data->output_stream);

		task_data->output_stream = g_converter_output_stream_new (output_stream,

									  G_CONVERTER (converter));

		g_object_unref (converter);

		g_object_unref (output_stream);

	}

	else

	{

		g_clear_object (&task_data->output_stream);

		task_data->output_stream = G_OUTPUT_STREAM (output_stream);

	}

	task_data->total_size = _gtk_source_buffer_input_stream_get_total_size (task_data->input_stream);