Dart: Better handle leak checks. close() is async.

mojo/public/dart/src/handle_watcher.dart

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 part of core;
 
 class _MojoHandleWatcherNatives {
   static int sendControlData(int controlHandle, int mojoHandle, SendPort port,
       int data) native "MojoHandleWatcher_SendControlData";
-  static List recvControlData(int controlHandle) native
-      "MojoHandleWatcher_RecvControlData";
-  static int setControlHandle(int controlHandle) native
-      "MojoHandleWatcher_SetControlHandle";
+  static List recvControlData(
+      int controlHandle) native "MojoHandleWatcher_RecvControlData";
+  static int setControlHandle(
+      int controlHandle) native "MojoHandleWatcher_SetControlHandle";
   static int getControlHandle() native "MojoHandleWatcher_GetControlHandle";
 }
 
 // The MojoHandleWatcher sends a stream of events to application isolates that
 // register Mojo handles with it. Application isolates make the following calls:
 //
 // add(handle, port, signals) - Instructs the MojoHandleWatcher isolate to add
 //     'handle' to the set of handles it watches, and to notify the calling
 //     isolate only for the events specified by 'signals' using the send port
 //     'port'
@@ skipping 71 matching lines @@
       int deadline = watcher._processTimerDeadlines();
       MojoWaitManyResult mwmr =
           MojoHandle.waitMany(watcher._handles, watcher._signals, deadline);
       if (mwmr.result.isOk && mwmr.index == 0) {
         watcher._handleControlMessage();
       } else if (mwmr.result.isOk && (mwmr.index > 0)) {
         int handle = watcher._handles[mwmr.index];
 
         // Route event.
         watcher._routeEvent(
-            mwmr.states[mwmr.index].satisfied_signals,
-            mwmr.index);
+            mwmr.states[mwmr.index].satisfied_signals, mwmr.index);
         // Remove the handle from the list.
         watcher._removeHandle(handle);
       } else if (!mwmr.result.isDeadlineExceeded) {
         // Some handle was closed, but not by us.
         // Find it and close it on our side.
         watcher._pruneClosedHandles(mwmr.states);
       }
     }
   }
 
@@ skipping 10 matching lines @@
     var signals = _decodeSignals(result[2]);
     int command = _decodeCommand(result[2]);
     switch (command) {
       case ADD:
         _addHandle(result[0], result[1], signals);
         break;
       case REMOVE:
         _removeHandle(result[0]);
         break;
       case CLOSE:
-        _close(result[0]);
+        _close(result[0], result[1]);
         break;
       case TIMER:
         _timer(result[1], result[0]);
         break;
       case SHUTDOWN:
         _shutdownHandleWatcher(result[1]);
         break;
       default:
         throw "Invalid Command: $command";
         break;
@@ skipping 38 matching lines @@
       _signals[idx] = _signals[last];
       _ports[idx] = _ports[last];
       _handles.removeLast();
       _signals.removeLast();
       _ports.removeLast();
       _handleIndices[_handles[idx]] = idx;
       _handleCount--;
     }
   }
 
-  void _close(int mojoHandle, {bool pruning: false}) {
+  void _close(int mojoHandle, SendPort port, {bool pruning: false}) {
+    assert(!pruning || (port == null));
     int idx = _handleIndices[mojoHandle];
     if (idx == null) {
-      // A client may request to close a handle that has already been closed on
-      // the other side and pruned, but before receiving notification from the
-      // handle watcher.
+      // An app isolate may request that the handle watcher close a handle that
+      // has already been pruned. This happens when the app isolate has not yet
+      // received the PEER_CLOSED event. The app isolate will not close the
+      // handle, so we must do so here.
+      _tempHandle._set(mojoHandle);
+      _tempHandle.close();
+      if (port != null) port.send(null); // Notify that close is done.
       return;
     }
     if (idx == 0) {
       throw "The control handle (idx = 0) cannot be closed.";
     }
-    _tempHandle.h = _handles[idx];
+    _tempHandle._set(_handles[idx]);
     _tempHandle.close();
-    _tempHandle.h = MojoHandle.INVALID;
+    if (port != null) port.send(null); // Notify that close is done.
     if (pruning) {
       // If this handle is being pruned, notify the application isolate
       // by sending MojoHandleSignals.PEER_CLOSED.
       _ports[idx].send([_signals[idx], MojoHandleSignals.kPeerClosed]);
     }
     _removeHandle(mojoHandle);
   }
 
   // Returns the next timer deadline in units of microseconds from 'now'.
   int _processTimerDeadlines() {
     int now = (new DateTime.now()).millisecondsSinceEpoch;
     while (_timerQueue.hasTimer && (now >= _timerQueue.currentTimeout)) {
       _timerQueue.currentPort.send(null);
       _timerQueue.removeCurrent();
       now = (new DateTime.now()).millisecondsSinceEpoch;
     }
-    return _timerQueue.hasTimer ?
-        (_timerQueue.currentTimeout - now) * 1000 :
-        MojoHandle.DEADLINE_INDEFINITE;
+    return _timerQueue.hasTimer
+        ? (_timerQueue.currentTimeout - now) * 1000
+        : MojoHandle.DEADLINE_INDEFINITE;
   }
 
   void _timer(SendPort port, int deadline) {
     _timerQueue.updateTimer(port, deadline);
   }
 
   void _pruneClosedHandles(List<MojoHandleSignalsState> states) {
     List<int> closed = new List();
     for (var i = 0; i < _handles.length; i++) {
       if (states != null) {
         var signals = new MojoHandleSignals(states[i].satisfied_signals);
         if (signals.isPeerClosed) {
           closed.add(_handles[i]);
         }
       } else {
-        _tempHandle.h = _handles[i];
+        _tempHandle._set(_handles[i]);
         MojoWaitResult mwr = _tempHandle.wait(MojoHandleSignals.kAll, 0);
         if ((!mwr.result.isOk) && (!mwr.result.isDeadlineExceeded)) {
           closed.add(_handles[i]);
         }
-        _tempHandle.h = MojoHandle.INVALID;
+        _tempHandle._set(MojoHandle.INVALID);
       }
     }
     for (var h in closed) {
-      _close(h, pruning: true);
+      _close(h, null, pruning: true);
     }
     // '_close' updated the '_handles' array, so at this point the '_handles'
     // array and the caller's 'states' array are mismatched.
   }
 
   void _shutdownHandleWatcher(SendPort shutdownSendPort) {
     _shutdown = true;
-    _tempHandle.h = _controlHandle;
+    _tempHandle._set(_controlHandle);
     _tempHandle.close();
-    _tempHandle.h = MojoHandle.INVALID;
     shutdownSendPort.send(null);
   }
 
-  static MojoResult _sendControlData(MojoHandle mojoHandle, SendPort port,
-      int data) {
+  static MojoResult _sendControlData(
+      MojoHandle mojoHandle, SendPort port, int data) {
     int controlHandle = _MojoHandleWatcherNatives.getControlHandle();
     if (controlHandle == MojoHandle.INVALID) {
       return MojoResult.FAILED_PRECONDITION;
     }
 
     int rawHandle = MojoHandle.INVALID;
     if (mojoHandle != null) {
       rawHandle = mojoHandle.h;
     }
     var result = _MojoHandleWatcherNatives.sendControlData(
-        controlHandle,
-        rawHandle,
-        port,
-        data);
+        controlHandle, rawHandle, port, data);
     return new MojoResult(result);
   }
 
   // Starts up the MojoHandleWatcher isolate. Should be called only once
   // per VM process.
   static Future<Isolate> _start() {
     // Make a control message pipe,
     MojoMessagePipe pipe = new MojoMessagePipe();
     int consumerHandle = pipe.endpoints[0].handle.h;
     int producerHandle = pipe.endpoints[1].handle.h;
@@ skipping 23 matching lines @@
 
     // Invalidate the control handle.
     _MojoHandleWatcherNatives.setControlHandle(MojoHandle.INVALID);
 
     // Wait for the handle watcher isolate to exit.
     shutdownReceivePort.first.then((_) {
       shutdownReceivePort.close();
     });
   }
 
-  static MojoResult close(MojoHandle mojoHandle) {
-    return _sendControlData(mojoHandle, null, _encodeCommand(CLOSE));
+  // If wait is true, returns a future that resolves only after the handle
+  // has actually been closed by the handle watcher. Otherwise, returns a
+  // future that resolves immediately.
+  static Future<MojoResult> close(MojoHandle mojoHandle, {bool wait: false}) {
+    assert(MojoHandle._removeUnclosedHandle(mojoHandle));
+    if (!wait) {
+      return new Future.value(
+          _sendControlData(mojoHandle, null, _encodeCommand(CLOSE)));
+    }
+    MojoResult result;
+    var completer = new Completer();
+    var rawPort = new RawReceivePort((_) {
+      completer.complete(result);
+    });
+    result =
+        _sendControlData(mojoHandle, rawPort.sendPort, _encodeCommand(CLOSE));
+    return completer.future.then((r) {
+      rawPort.close();
+      return r;
+    });
   }
 
   static MojoResult add(MojoHandle mojoHandle, SendPort port, int signals) {
     return _sendControlData(mojoHandle, port, _encodeCommand(ADD, signals));
   }
 
   static MojoResult remove(MojoHandle mojoHandle) {
     return _sendControlData(mojoHandle, null, _encodeCommand(REMOVE));
   }
 
   static MojoResult timer(Object ignored, SendPort port, int deadline) {
     // The deadline will be unwrapped before sending to the handle watcher.
     return _sendControlData(
-        new MojoHandle(deadline),
-        port,
-        _encodeCommand(TIMER));
+        new MojoHandle._internal(deadline), port, _encodeCommand(TIMER));
   }
 }