Make ChildEventBusManager.disconnect async.

This allows other async events a chance to be popagated up to
the parent, rather than the bus abruptly being cut off with
a bunch of pending events.

Change-Id: I2a60826174d33240c0a1016b41ef881efdd97fed
Reviewed-on: http://gerrit.dmdirc.com/3818
Reviewed-by: Greg Holmes <greg@dmdirc.com>
Automatic-Compile: DMDirc Build Manager

src/com/dmdirc/util/ChildEventBusManager.java

@@ -31,7 +31,8 @@ import net.engio.mbassy.listener.Handler;
 import static com.google.common.base.Preconditions.checkNotNull;
 
 /**
- * Utility for creating and managing instances of {@link com.dmdirc.DMDircMBassador} that are slaved to a parent bus.
+ * Utility for creating and managing instances of {@link DMDircMBassador} that are slaved to a
+ * parent bus.
  * <p>
  * Any events sent on the child bus will be propagated up to the parent bus.
  */
@@ -59,10 +60,11 @@ public class ChildEventBusManager {
     /**
      * Disconnects the child event bus from the parent.
      * <p>
-     * After this method is called, no further events will be passed to the parent.
+     * The child will be disconnected asynchronously, to allow any pending async events to be
+     * dispatched. After the bus is disconnected, no future events will be passed to the parent.
      */
     public void disconnect() {
-        child.unsubscribe(propagator);
+        child.publishAsync(new ChildEventBusDisconnectingEvent());
     }
 
     /**
@@ -78,9 +80,22 @@ public class ChildEventBusManager {
 
         @Handler
         public void handleEvent(final DMDircEvent event) {
-            parent.publish(event);
+            if (!(event instanceof ChildEventBusDisconnectingEvent)) {
+                // Don't propagate our private event
+                parent.publish(event);
+            }
         }
 
+        // Allow all other handlers on the child bus to process this first
+        @Handler(priority = Integer.MIN_VALUE)
+        public void handleDisconnect(final ChildEventBusDisconnectingEvent event) {
+            child.unsubscribe(propagator);
+        }
+
+    }
+
+    private static class ChildEventBusDisconnectingEvent extends DMDircEvent {
+
     }
 
 }

test/com/dmdirc/util/ChildEventBusManagerTest.java

@@ -35,13 +35,12 @@ import static org.junit.Assert.assertSame;
 
 public class ChildEventBusManagerTest {
 
-    private DMDircMBassador parent;
     private ChildEventBusManager manager;
     private StubHandler handler;
 
     @Before
     public void setup() {
-        parent = new DMDircMBassador();
+        final DMDircMBassador parent = new DMDircMBassador();
         manager = new ChildEventBusManager(parent);
         handler = new StubHandler();
         parent.subscribe(handler);
@@ -54,9 +53,15 @@ public class ChildEventBusManagerTest {
     }
 
     @Test
-    public void testDoesNotPropagateAfterDisconnect() {
+    public void testDoesNotPropagateAfterDisconnect() throws InterruptedException {
         manager.connect();
         manager.disconnect();
+
+        // Wait for the asynchronous disconnect to go through. This is a bit lame.
+        do {
+            Thread.sleep(100);
+        } while (manager.getChildBus().hasPendingMessages());
+
         manager.getChildBus().publish(new StubEvent());
         assertNull(handler.received);
     }