Fix code for strong zones.

lib/src/stack_zone_specification.dart

 // Copyright (c) 2013, 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 'chain.dart';
 import 'lazy_trace.dart';
 import 'trace.dart';
 import 'utils.dart';
@@ skipping 74 matching lines @@
   /// (converted to a [Trace] if necessary). If there is no chain associated
   /// with [trace], this just returns a single-trace chain containing [trace].
   Chain chainFor(StackTrace trace) {
     if (trace is Chain) return trace;
     var previous = trace == null ? null : _chains[trace];
     return new _Node(trace, previous).toChain();
   }
 
   /// Tracks the current stack chain so it can be set to [_currentChain] when
   /// [f] is run.
-  ZoneCallback _registerCallback(
-      Zone self, ZoneDelegate parent, Zone zone, Function f) {
+  ZoneCallback<R> _registerCallback<R>(
+      Zone self, ZoneDelegate parent, Zone zone, R f()) {
     if (f == null || _disabled) return parent.registerCallback(zone, f);
     var node = _createNode(1);
     return parent.registerCallback(zone, () => _run(f, node));
   }
 
   /// Tracks the current stack chain so it can be set to [_currentChain] when
   /// [f] is run.
-  ZoneUnaryCallback _registerUnaryCallback(
-      Zone self, ZoneDelegate parent, Zone zone, Function f) {
+  ZoneUnaryCallback<R, T> _registerUnaryCallback<R, T>(
+      Zone self, ZoneDelegate parent, Zone zone, R f(T arg)) {
     if (f == null || _disabled) return parent.registerUnaryCallback(zone, f);
     var node = _createNode(1);
     return parent.registerUnaryCallback(zone, (arg) {
       return _run(() => f(arg), node);
     });
   }
 
   /// Tracks the current stack chain so it can be set to [_currentChain] when
   /// [f] is run.
-  ZoneBinaryCallback _registerBinaryCallback(
+  ZoneBinaryCallback<R, T1, T2> _registerBinaryCallback<R, T1, T2>(
       Zone self, ZoneDelegate parent, Zone zone, Function f) {
     if (f == null || _disabled) return parent.registerBinaryCallback(zone, f);
 
     var node = _createNode(1);
     return parent.registerBinaryCallback(zone, (arg1, arg2) {
       return _run(() => f(arg1, arg2), node);
     });
   }
 
   /// Looks up the chain associated with [stackTrace] and passes it either to
   /// [_onError] or [parent]'s error handler.
-  _handleUncaughtError(
+  void _handleUncaughtError(
       Zone self, ZoneDelegate parent, Zone zone, error, StackTrace stackTrace) {
     if (_disabled) {
-      return parent.handleUncaughtError(zone, error, stackTrace);
+      parent.handleUncaughtError(zone, error, stackTrace);
     }
 
     var stackChain = chainFor(stackTrace);
     if (_onError == null) {
-      return parent.handleUncaughtError(zone, error, stackChain);
+      parent.handleUncaughtError(zone, error, stackChain);
     }
 
     // TODO(nweiz): Currently this copies a lot of logic from [runZoned]. Just
     // allow [runBinary] to throw instead once issue 18134 is fixed.
     try {
-      return parent.runBinary(zone, _onError, error, stackChain);
+      parent.runBinary(zone, _onError, error, stackChain);
     } catch (newError, newStackTrace) {
       if (identical(newError, error)) {
-        return parent.handleUncaughtError(zone, error, stackChain);
+        parent.handleUncaughtError(zone, error, stackChain);
       } else {
-        return parent.handleUncaughtError(zone, newError, newStackTrace);
+        parent.handleUncaughtError(zone, newError, newStackTrace);
       }
     }
   }
 
   /// Attaches the current stack chain to [stackTrace], replacing it if
   /// necessary.
   AsyncError _errorCallback(Zone self, ZoneDelegate parent, Zone zone,
       Object error, StackTrace stackTrace) {
     if (_disabled) return parent.errorCallback(zone, error, stackTrace);
 
@@ skipping 16 matching lines @@
   /// that many frames up instead.
   _Node _createNode([int level = 0]) =>
       new _Node(_currentTrace(level + 1), _currentNode);
 
   // TODO(nweiz): use a more robust way of detecting and tracking errors when
   // issue 15105 is fixed.
   /// Runs [f] with [_currentNode] set to [node].
   ///
   /// If [f] throws an error, this associates [node] with that error's stack
   /// trace.
-  _run(Function f, _Node node) {
+  T _run<T>(T f(), _Node node) {
     var previousNode = _currentNode;
     _currentNode = node;
     try {
       return f();
     } catch (e, stackTrace) {
       _chains[stackTrace] = node;
       rethrow;
     } finally {
       _currentNode = previousNode;
     }
@@ skipping 34 matching lines @@
     var text = stackTrace.toString();
     var index = text.indexOf(vmChainGap);
     if (index != -1) text = text.substring(0, index);
 
     var trace = new Trace.parse(text);
     // JS includes a frame for the call to StackTrace.current, but the VM
     // doesn't, so we skip an extra frame in a JS context.
     return new Trace(trace.frames.skip(level + (inJS ? 2 : 1)));
   });
 }