Add stack chain support to pkg/watcher and pkg/http.

pkg/watcher/lib/src/directory_watcher/linux.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 watcher.directory_watcher.linux;
 
 import 'dart:async';
 import 'dart:io';
 
+import 'package:stack_trace/stack_trace.dart';
+
 import '../utils.dart';
 import '../watch_event.dart';
 import 'resubscribable.dart';
 
 /// Uses the inotify subsystem to watch for filesystem events.
 ///
 /// Inotify doesn't suport recursively watching subdirectories, nor does
 /// [Directory.watch] polyfill that functionality. This class polyfills it
 /// instead.
 ///
@@ skipping 29 matching lines @@
 
   /// A set of all subscriptions that this watcher subscribes to.
   ///
   /// These are gathered together so that they may all be canceled when the
   /// watcher is closed.
   final _subscriptions = new Set<StreamSubscription>();
 
   _LinuxDirectoryWatcher(String directory)
       : directory = directory {
     // Batch the inotify changes together so that we can dedup events.
-    var innerStream = new Directory(directory).watch().transform(
-        new BatchedStreamTransformer<FileSystemEvent>());
+    var innerStream = Chain.track(new Directory(directory).watch())
+        .transform(new BatchedStreamTransformer<FileSystemEvent>());
     _listen(innerStream, _onBatch,
         onError: _eventsController.addError,
         onDone: _onDone);
 
-    _listen(new Directory(directory).list(), (entity) {
+    _listen(Chain.track(new Directory(directory).list()), (entity) {
       _entries[entity.path] = new _EntryState(entity is Directory);
       if (entity is! Directory) return;
       _watchSubdir(entity.path);
     }, onError: (error, stackTrace) {
       _eventsController.addError(error, stackTrace);
       close();
     }, onDone: () {
       _waitUntilReady().then((_) => _readyCompleter.complete());
     }, cancelOnError: true);
   }
@@ skipping 74 matching lines @@
     // `DirectoryWatcher.eventsAndExistingFiles`) to tell a watcher to emit
     // events for all the files that already exist. This would be useful for
     // top-level clients such as barback as well, and could be implemented with
     // a wrapper similar to how listening/canceling works now.
 
     // If a directory is added after we're finished with the initial scan, emit
     // an event for each entry in it. This gives the user consistently gets an
     // event for every new file.
     watcher.ready.then((_) {
       if (!isReady || _eventsController.isClosed) return;
-      _listen(new Directory(path).list(recursive: true), (entry) {
+      _listen(Chain.track(new Directory(path).list(recursive: true)), (entry) {
         if (entry is Directory) return;
         _eventsController.add(new WatchEvent(ChangeType.ADD, entry.path));
       }, onError: (error, stackTrace) {
         // Ignore an exception caused by the dir not existing. It's fine if it
         // was added and then quickly removed.
         if (error is FileSystemException) return;
 
         _eventsController.addError(error, stackTrace);
         close();
       }, cancelOnError: true);
@@ skipping 126 matching lines @@
   static const DIRECTORY = const _EntryState._("directory");
 
   const _EntryState._(this._name);
 
   /// Returns [DIRECTORY] if [isDir] is true, and [FILE] otherwise.
   factory _EntryState(bool isDir) =>
       isDir ? _EntryState.DIRECTORY : _EntryState.FILE;
 
   String toString() => _name;
 }