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, 24 insertions, 2 deletions

diff --git a/mono/Message.cs b/mono/Message.cs
index 5aa3542f..944e3f92 100644
--- a/mono/Message.cs
+++ b/mono/Message.cs
@@ -6,7 +6,7 @@ namespace DBus
   using System.Diagnostics;
   using System.Collections;
   
-  public class Message 
+  public class Message : IDisposable
   {
     private static Stack stack = new Stack ();
 	  
@@ -83,10 +83,26 @@ namespace DBus
     {
       this.service = service;
     }
+
+    public void Dispose() 
+    {
+      Dispose(true);
+      GC.SuppressFinalize(this);
+    }
     
-    ~Message() 
+    public void Dispose (bool disposing) 
     {
+      if (disposing) {
+        if (this.arguments != null)
+	  this.arguments.Dispose ();
+      }
+
       RawMessage = IntPtr.Zero; // free the native object
+    }     
+
+    ~Message() 
+    {
+      Dispose (false);
     }
     
     public static Message Wrap(IntPtr rawMessage, Service service) 
@@ -198,6 +214,12 @@ namespace DBus
 
       if (rawMessage != IntPtr.Zero) {
 	MethodReturn methodReturn = new MethodReturn(rawMessage, Service);
+	// Ownership of a ref is passed onto us from
+	// dbus_connection_send_with_reply_and_block().  It gets reffed as
+	// a result of being passed into the MethodReturn ctor, so unref
+	// the extra one here.
+	dbus_message_unref (rawMessage);
+
 	return methodReturn;
       } else {
 	throw new DBusException(error);