2005-03-08 Joe Shaw <joeshaw@novell.com>

	Fix a bunch of lifecycle and memory management problems
	in the mono bindings.

	* mono/Arguments.cs (Arguments): Implement IDisposable

	* mono/Bus.cs (Bus): Don't allow public instantiation.  This is
	strictly a static class.

	* mono/Connection.cs: Move the DBusObjectPathVTable and associated
	delegates into this file.
	(Connection): Implement IDisposable.
	(Dispose): Disconnect the connection and set the raw connection
	pointer to IntPtr.Zero.
	(~Connection): Call Dispose().
	(RegisterObjectPath): Added.  Manages the registration of object
	paths so we can cleanly disconnect them at dispose/finalize time.
	(UnregisterObjectPath): Ditto.
	(set_RawConnection): Unregister all of the object paths when
	changing the underlying DBusConnection.  Add them back onto the
	new connection, if any.

	* mono/Handler.cs: Don't implement IDisposable; it doesn't use any
	more unmanaged resources anymore, so it's not necessary.  Move all
	the DBusObjectPathVTable stuff out of here.
	(Handler): Save references to our delegates so that they don't get
	finalized.  Call Connection.RegisterObjectPath() instead of
	dbus_connection_register_object_path() directly.
	(Message_Called): Dispose the message after we're finished with
	it.

	* mono/Message.cs (Message): Implement IDisposable.
	(Dispose): Dispose the Arguments, and set the RawMessage to
	IntPtr.Zero.
	(SendWithReplyAndBlock): We own the ref to the reply that comes
	back from dbus_connection_send_with_reply_and_block() so add a
	comment about that and unref it after we've constructed a managed
	MethodReturn class around it.  Fixes a big, big leak.

	* mono/ProxyBuilder.cs: Reflect into Message to get the Dispose
	method.
	(BuildSignalHandler): After we've sent the Signal message, dispose
	of it.
	(BuildMethod): Dispose of the method call and reply messages after
	we've sent the message and extracted the data we want from the
	reply.

	* mono/Service.cs (UnregisterObject): Don't call handler.Dispose()
	anymore.
	(Service_FilterCalled): Dispose of the message after we're
	finished with it.

1 files changed, 15 insertions, 7 deletions

diff --git a/mono/Arguments.cs b/mono/Arguments.cs
index 41e6d15d..61ae443f 100644
--- a/mono/Arguments.cs
+++ b/mono/Arguments.cs
@@ -7,29 +7,37 @@ namespace DBus
 {
   // Holds the arguments of a message. Provides methods for appending
   // arguments and to assist in matching .NET types with D-BUS types.
-  public class Arguments : IEnumerable
+	public class Arguments : IEnumerable, IDisposable
   {
     // Must follow sizeof(DBusMessageIter)
     internal const int DBusMessageIterSize = 14*4;
     private static Hashtable dbusTypes = null;
     private Message message;
-    private IntPtr appenderIter = Marshal.AllocCoTaskMem(DBusMessageIterSize);
+    private IntPtr appenderIter;
     private IEnumerator enumerator = null;
     
-    internal Arguments()
+    internal Arguments (Message message)
     {
+      this.appenderIter = Marshal.AllocCoTaskMem(DBusMessageIterSize);
+      this.message = message;
     }
 
-    ~Arguments()
+    private void Dispose (bool disposing)
     {
       Marshal.FreeCoTaskMem(appenderIter);
     }
 
-    internal Arguments(Message message)
+    public void Dispose ()
     {
-      this.message = message;
+      Dispose (true);
+      GC.SuppressFinalize (this);
     }
-    
+
+    ~Arguments()
+    {
+      Dispose (false);
+    }
+
     // Checks the suitability of a D-BUS type for supporting a .NET
     // type.
     public static bool Suits(Type dbusType, Type type)