Clear future callbacks when the future is completed.

sdk/lib/async/future_impl.dart

 // Copyright (c) 2012, 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.
 
 part of dart.async;
 
 /** The onValue and onError handlers return either a value or a future */
 typedef dynamic _FutureOnValue<T>(T value);
 /** Test used by [Future.catchError] to handle skip some errors. */
 typedef bool _FutureErrorTest(var error);
@@ skipping 110 matching lines @@
    * remaining listeners.
    */
   // TODO(floitsch): since single listeners are the common case we should
   // use a bit to indicate that the _resultOrListeners contains a container.
   _Future _nextListener;
 
   // TODO(floitsch): we only need two closure fields to store the callbacks.
   // If we store the type of a closure in the state field (where there are
   // still bits left), we can just store two closures instead of using 4
   // fields of which 2 are always null.
-  final _FutureOnValue _onValueCallback;
-  final _FutureErrorTest _errorTestCallback;
-  final Function _onErrorCallback;
-  final _FutureAction _whenCompleteActionCallback;
+  _FutureOnValue _onValueCallback;
+  _FutureErrorTest _errorTestCallback;
+  Function _onErrorCallback;
+  _FutureAction _whenCompleteActionCallback;
 
   _FutureOnValue get _onValue => _isChained ? null : _onValueCallback;
   _FutureErrorTest get _errorTest => _isChained ? null : _errorTestCallback;
   Function get _onError => _isChained ? null : _onErrorCallback;
   _FutureAction get _whenCompleteAction
       => _isChained ? null : _whenCompleteActionCallback;
 
   _Future()
       : _zone = Zone.current,
         _onValueCallback = null, _errorTestCallback = null,

[floitsch, 2014/06/17 08:56:35]

There are lots of null-initializations that can be dropped now.

         _onErrorCallback = null, _whenCompleteActionCallback = null;
 
   /// Valid types for value: `T` or `Future<T>`.
   _Future.immediate(value)
         : _zone = Zone.current,
           _onValueCallback = null, _errorTestCallback = null,
           _onErrorCallback = null, _whenCompleteActionCallback = null {
     _asyncComplete(value);
   }
 
@@ skipping 416 matching lines @@
             listenerHasValue = handleValueCallback();
           }
         } else {
           handleError();
         }
         if (listener._whenCompleteAction != null) {
           handleWhenCompleteCallback();
         }
         // If we changed zone, oldZone will not be null.
         if (oldZone != null) Zone._leave(oldZone);
+        listener._onValueCallback = null;
+        listener._errorTestCallback = null;
+        listener._onErrorCallback = null;
+        listener._whenCompleteActionCallback = null;
 
         if (isPropagationAborted) return;
         // If the listener's value is a future we need to chain it. Note that
         // this can only happen if there is a callback. Since 'is' checks
         // can be expensive, we're trying to avoid it.
         if (listenerHasValue &&
             !identical(sourceValue, listenerValueOrError) &&
             listenerValueOrError is Future) {
           Future chainSource = listenerValueOrError;
           // Shortcut if the chain-source is already completed. Just continue
@@ skipping 54 matching lines @@
       }
     }, onError: (e, s) {
       if (timer.isActive) {
         timer.cancel();
         result._completeError(e, s);
       }
     });
     return result;
   }
 }