<div dir="ltr"><div class="gmail_default" style="font-family:arial,helvetica,sans-serif">Got it, thanks a lot!</div><div class="gmail_default" style="font-family:arial,helvetica,sans-serif"> Carlo</div></div><div class="gmail_extra"> <div class="gmail_quote">On 22 December 2015 at 18:34, Aleksander Morgado <<a href="mailto:aleksander@aleksander.es" target="_blank">aleksander@aleksander.es</a>> wrote: <blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">Hey! On Tue, Dec 22, 2015 at 5:27 PM, Carlo Lobrano <<a href="mailto:c.lobrano@gmail.com">c.lobrano@gmail.com</a>> wrote: > I am using cinterion and other plugins as reference to implement > load_supported_bands for Telit plugin, but there is a point which is not > clear for me. > > In my reference plugins I've always seen this kind of result assignement > > supported_bands_ready (...) { > /* get the results */ > g_simple_async_result_set_op_res_gpointer (simple, > bands, > (GDestroyNotify) > g_array_unref); > g_simple_async_result_complete (operation_result); > g_object_unref (operation_result); > } > > where bands is a GArray* that might contain the list of supported bands if > everything went fine or NULL otherwise. > Yes, in the specific case of the cinterion plugin a newly allocated GArray* is returned by mm_cinterion_parse_scfg_test(). What we're doing here is to put that newly allocated GArray in the result, and say that whenever the result is disposed, the array should be disposed as well (i.e. the array is now owned by the result object). There is no memory leak here, because once the result is unref-ed for the last time, it will also dispose the GArray. > My question is: there is any kind of memory leak here? Is it correct to use > g_array_ref(bands) instead? > > supported_bands_ready (...) { > /* get the results */ > g_simple_async_result_set_op_res_gpointer (simple, > g_array_ref(bands), > (GDestroyNotify) > g_array_unref); > g_simple_async_result_complete (operation_result); > g_object_unref (operation_result); > } It would be ok to pass a newly created reference with g_array_ref(), but only if you afterwards dispose the one you got from mm_cinterion_parse_scfg_test(), or you would be leaking a reference. In other words, these two blocks would be both ok: 1) ======== if (mm_cinterion_parse_scfg_test (&bands)) { g_simple_async_result_set_op_res_gpointer (simple, bands, (GDestroyNotify) g_array_unref ()); g_simple_async_result_complete (simple); g_object_unref (simple); } 2) ======== if (mm_cinterion_parse_scfg_test (&bands)) { g_simple_async_result_set_op_res_gpointer (simple, g_array_ref (bands), (GDestroyNotify) g_array_unref ()); g_array_unref (bands); g_simple_async_result_complete (simple); g_object_unref (simple); } In this case, it may be cleaner to use approach #1, to avoid the need for the extra ref/unrefs. In some other cases, e.g. when the reference of the object returned is owned by some other thing, like a async method context helper struct, then it would be better to use approach #2, as that clearly shows who owns each reference. -- Aleksander <a href="https://aleksander.es" rel="noreferrer" target="_blank">https://aleksander.es</a> </blockquote></div> </div>