Remove some additional Chain.track documentation.

pkg/stack_trace/lib/src/chain.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.
 
 library stack_trace.chain;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'frame.dart';
@@ skipping 17 matching lines @@
 /// accessed using [new Chain.current]. Any errors that would be top-leveled in
 /// the zone can be handled, along with their associated chains, with the
 /// `onError` callback. For example:
 ///
 ///     Chain.capture(() {
 ///       // ...
 ///     }, onError: (error, stackChain) {
 ///       print("Caught error $error\n"
 ///             "$stackChain");
 ///     });
-///
-/// For the most part [Chain.capture] will notice when an error is thrown and
-/// associate the correct stack chain with it; the chain can be accessed using
-/// [new Chain.forTrace]. However, there are some cases where exceptions won't
-/// be automatically detected: any [Future] constructor,
-/// [Completer.completeError], [Stream.addError], and libraries that use these.
-/// For these, all you need to do is wrap the Future or Stream in a call to
-/// [Chain.track] and the errors will be tracked correctly.
 class Chain implements StackTrace {
   /// The line used in the string representation of stack chains to represent
   /// the gap between traces.
   static const _GAP = '===== asynchronous gap ===========================\n';
 
   /// The stack traces that make up this chain.
   ///
   /// Like the frames in a stack trace, the traces are ordered from most local
   /// to least local. The first one is the trace where the actual exception was
   /// raised, the second one is where that callback was scheduled, and so on.
   final List<Trace> traces;
 
   /// The [StackZoneSpecification] for the current zone.
   static StackZoneSpecification get _currentSpec =>
     Zone.current[#stack_trace.stack_zone.spec];
 
   /// Runs [callback] in a [Zone] in which the current stack chain is tracked
   /// and automatically associated with (most) errors.
   ///
   /// If [onError] is passed, any error in the zone that would otherwise go
   /// unhandled is passed to it, along with the [Chain] associated with that
   /// error. Note that if [callback] produces multiple unhandled errors,
   /// [onError] may be called more than once. If [onError] isn't passed, the
   /// parent Zone's `unhandledErrorHandler` will be called with the error and
   /// its chain.
   ///
-  /// For the most part an error thrown in the zone will have the correct stack
-  /// chain associated with it. However, there are some cases where exceptions
-  /// won't be automatically detected: any [Future] constructor,
-  /// [Completer.completeError], [Stream.addError], and libraries that use
-  /// these. For these, all you need to do is wrap the Future or Stream in a
-  /// call to [Chain.track] and the errors will be tracked correctly.
-  ///
   /// Note that even if [onError] isn't passed, this zone will still be an error
   /// zone. This means that any errors that would cross the zone boundary are
   /// considered unhandled.
   ///
   /// If [callback] returns a value, it will be returned by [capture] as well.
   ///
   /// Currently, capturing stack chains doesn't work when using dart2js due to
   /// issues [15171] and [15105]. Stack chains reported on dart2js will contain
   /// only one trace.
   ///
@@ skipping 105 matching lines @@
   }
 
   /// Converts [this] to a [Trace].
   ///
   /// The trace version of a chain is just the concatenation of all the traces
   /// in the chain.
   Trace toTrace() => new Trace(flatten(traces.map((trace) => trace.frames)));
 
   String toString() => traces.join(_GAP);
 }