Roll to pickup pool changes

packages/pool/lib/pool.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:async/async.dart';
 import 'package:stack_trace/stack_trace.dart';
 
@@ skipping 60 matching lines @@
   /// If any [PoolResource.allowRelease] callback throws an exception after the
   /// pool is closed, this completes with that exception.
   Future get done => _closeMemo.future;
 
   /// Creates a new pool with the given limit on how many resources may be
   /// allocated at once.
   ///
   /// If [timeout] is passed, then if that much time passes without any activity
   /// all pending [request] futures will throw a [TimeoutException]. This is
   /// intended to avoid deadlocks.
-  Pool(this._maxAllocatedResources, {Duration timeout})
-      : _timeout = timeout {
+  Pool(this._maxAllocatedResources, {Duration timeout}) : _timeout = timeout {
     if (timeout != null) {
       // Start the timer canceled since we only want to start counting down once
       // we've run out of available resources.
       _timer = new RestartableTimer(timeout, _onTimeout)..cancel();
     }
   }
 
   /// Request a [PoolResource].
   ///
   /// If the maximum number of resources is already allocated, this will delay
@@ skipping 40 matching lines @@
   /// Existing resource requests remain unchanged.
   ///
   /// Any resources that are marked as releasable using
   /// [PoolResource.allowRelease] are released immediately. Once all resources
   /// have been released and any `onRelease` callbacks have completed, the
   /// returned future completes successfully. If any `onRelease` callback throws
   /// an error, the returned future completes with that error.
   ///
   /// This may be called more than once; it returns the same [Future] each time.
   Future close() => _closeMemo.runOnce(() {
-    if (_closeGroup != null) return _closeGroup.future;
+        if (_closeGroup != null) return _closeGroup.future;
 
-    _resetTimer();
+        _resetTimer();
 
-    _closeGroup = new FutureGroup();
-    for (var callback in _onReleaseCallbacks) {
-      _closeGroup.add(new Future.sync(callback));
-    }
+        _closeGroup = new FutureGroup();
+        for (var callback in _onReleaseCallbacks) {
+          _closeGroup.add(new Future.sync(callback));
+        }
 
-    _allocatedResources -= _onReleaseCallbacks.length;
-    _onReleaseCallbacks.clear();
+        _allocatedResources -= _onReleaseCallbacks.length;
+        _onReleaseCallbacks.clear();
 
-    if (_allocatedResources == 0) _closeGroup.close();
-    return _closeGroup.future;
-  });
+        if (_allocatedResources == 0) _closeGroup.close();
+        return _closeGroup.future;
+      });
   final _closeMemo = new AsyncMemoizer();
 
   /// If there are any pending requests, this will fire the oldest one.
   void _onResourceReleased() {
     _resetTimer();
 
     if (_requestedResources.isNotEmpty) {
       var pending = _requestedResources.removeFirst();
       pending.complete(new PoolResource._(this));
     } else {
       _allocatedResources--;
       if (isClosed && _allocatedResources == 0) _closeGroup.close();
     }
   }
 
   /// If there are any pending requests, this will fire the oldest one after
   /// running [onRelease].
   void _onResourceReleaseAllowed(onRelease()) {
     _resetTimer();
 
     if (_requestedResources.isNotEmpty) {
       var pending = _requestedResources.removeFirst();
       pending.complete(_runOnRelease(onRelease));
     } else if (isClosed) {
       _closeGroup.add(new Future.sync(onRelease));
       _allocatedResources--;
       if (_allocatedResources == 0) _closeGroup.close();
     } else {
-      _onReleaseCallbacks.add(
-          Zone.current.bindCallback(onRelease, runGuarded: false));
+      var zone = Zone.current;
+      var registered = zone.registerCallback(onRelease);
+      _onReleaseCallbacks.add(() => zone.run(registered));
     }
   }
 
   /// Runs [onRelease] and returns a Future that completes to a resource once an
   /// [onRelease] callback completes.
   ///
   /// Futures returned by [_runOnRelease] always complete in the order they were
   /// created, even if earlier [onRelease] callbacks take longer to run.
   Future<PoolResource> _runOnRelease(onRelease()) {
     new Future.sync(onRelease).then((value) {
@@ skipping 16 matching lines @@
     } else {
       _timer.reset();
     }
   }
 
   /// Handles [_timer] timing out by causing all pending resource completers to
   /// emit exceptions.
   void _onTimeout() {
     for (var completer in _requestedResources) {
       completer.completeError(
-          new TimeoutException("Pool deadlock: all resources have been "
+          new TimeoutException(
+              "Pool deadlock: all resources have been "
               "allocated for too long.",
               _timeout),
           new Chain.current());
     }
     _requestedResources.clear();
     _timer = null;
   }
 }
 
 /// A member of a [Pool].
@@ skipping 31 matching lines @@
   /// produce additional information later on. For example, an isolate's task
   /// may be complete, but it could still emit asynchronous errors.
   void allowRelease(onRelease()) {
     if (_released) {
       throw new StateError("A PoolResource may only be released once.");
     }
     _released = true;
     _pool._onResourceReleaseAllowed(onRelease);
   }
 }