anchor.diff:  // this can be optimized to return a const-constructed [StreamTransformer].
   typedef StreamTransformer<Response, Response> StreamTransformerFactory(Request request, Trace trace);
   
  -_runZonedWithOnDone(fn, onDone, trace) {
  +_runZonedWithOnDone(fn, onDone, trace, {response: null, error: null}) {
     // Initial count is 1 due to running 'fn'. This makes it work out
     // nicely if 'fn' itself throws an Exception.
     var asyncCount = 1;
  
positive.code: 
  /// Fired when the user callback of a response is queued.
  class UserCallbackQueuedEvent implements TraceEvent {
    factory UserCallbackQueuedEvent() => const UserCallbackQueuedEvent._private();
  
    const UserCallbackQueuedEvent._private();
  
    String toString() => 'streamy.userCallback.start';
  }
  
  /// Fired when the user callback of a response completes.
  class UserCallbackDoneEvent implements TraceEvent {
    factory UserCallbackDoneEvent() => const UserCallbackDoneEvent._private();
  
    const UserCallbackDoneEvent._private();
  
    String toString() => 'streamy.userCallback.done';
  }
  
  /// Fired at the beginning of an asynchronous operation that happens during a user callback.
  class UserCallbackAsyncEnterEvent implements TraceEvent {
    factory UserCallbackAsyncEnterEvent() => const UserCallbackAsyncEnterEvent._private();
  
    const UserCallbackAsyncEnterEvent._private();
  
    String toString() => 'streamy.userCallback.async.start';
  }
  
  /// Fired at the end of an asynchronous operation that happens during a user callback.
  class UserCallbackAsyncExitEvent implements TraceEvent {
    factory UserCallbackAsyncExitEvent() => const UserCallbackAsyncExitEvent._private();
  
    const UserCallbackAsyncExitEvent._private();
  
    String toString() => 'streamy.userCallback.async.done';
  }
  
negative.code:   UserCallbackTracingTransformer() : super();
  
    void handleData(Response response, EventSink<Response> sink, Trace trace) {
      trace.record(new UserCallbackQueuedEvent(response: response));
      _openCallbacks++;
      _runZonedWithOnDone(() => sink.add(response), () {
        trace.record(new UserCallbackDoneEvent(response: response));
        _openCallbacks--;
        if (_openCallbacks == 0 && _closed && !_sentDone) {
          trace.record(new RequestOverEvent());
          _sentDone = true;
        }
      }, trace, response: response);
    }
  
    void handleError(error, EventSink<Response> sink, Trace trace) {
      trace.record(new UserCallbackQueuedEvent(error: error));
      _openCallbacks++;
      _runZonedWithOnDone(() {
        sink.addError(error);
      }, () {
        trace.record(new UserCallbackDoneEvent(error: error));
        _openCallbacks--;
        if (_openCallbacks == 0 && _closed && !_sentDone) {
          trace.record(new RequestOverEvent());
          _sentDone = true;
        }
      }, trace, error: error);
    }
  
    void handleDone(EventSink<Response> sink, Trace trace) {
  