Update charted to 0.4.8 and roll

packages/watcher/lib/src/directory_watcher/windows.dart

 // Copyright (c) 2014, 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.
 // TODO(rnystrom): Merge with mac_os version.
 
-library watcher.directory_watcher.windows;
-
 import 'dart:async';
 import 'dart:collection';
 import 'dart:io';
 
 import 'package:path/path.dart' as p;
 
 import '../constructable_file_system_event.dart';
 import '../directory_watcher.dart';
 import '../path_set.dart';
 import '../resubscribable.dart';
@@ skipping 111 matching lines @@
       if (p.basename(event.path) != p.basename(absoluteDir)) return;
       // Test if the directory is removed. FileSystemEntity.typeSync will
       // return NOT_FOUND if it's unable to decide upon the type, including
       // access denied issues, which may happen when the directory is deleted.
       // FileSystemMoveEvent and FileSystemDeleteEvent events will always mean
       // the directory is now gone.
       if (event is FileSystemMoveEvent ||
           event is FileSystemDeleteEvent ||
           (FileSystemEntity.typeSync(path) ==
            FileSystemEntityType.NOT_FOUND)) {
-        for (var path in _files.toSet()) {
+        for (var path in _files.paths) {
           _emitEvent(ChangeType.REMOVE, path);
         }
         _files.clear();
         close();
       }
     }, onError: (error) {
       // Ignore errors, simply close the stream. The user listens on
       // [directory], and while it can fail to listen on the parent, we may
       // still be able to listen on the path requested.
       _parentWatchSubscription.cancel();
       _parentWatchSubscription = null;
     });
   }
 
   void _onEvent(FileSystemEvent event) {
     assert(isReady);
     final batcher = _eventBatchers.putIfAbsent(
         event.path, () => new _EventBatcher());
     batcher.addEvent(event, () {
       _eventBatchers.remove(event.path);
       _onBatch(batcher.events);
     });
   }
 
   /// The callback that's run when [Directory.watch] emits a batch of events.
   void _onBatch(List<FileSystemEvent> batch) {
-    _sortEvents(batch).forEach((path, events) {
+    _sortEvents(batch).forEach((path, eventSet) {
 
-      var canonicalEvent = _canonicalEvent(events);
-      events = canonicalEvent == null ?
+      var canonicalEvent = _canonicalEvent(eventSet);
+      var events = canonicalEvent == null ?
           _eventsBasedOnFileSystem(path) : [canonicalEvent];
 
       for (var event in events) {
         if (event is FileSystemCreateEvent) {
           if (!event.isDirectory) {
             if (_files.contains(path)) continue;
 
             _emitEvent(ChangeType.ADD, path);
             _files.add(path);
             continue;
           }
 
           if (_files.containsDir(path)) continue;
 
           var stream = new Directory(path).list(recursive: true);
-          var sub;
-          sub = stream.listen((entity) {
+          StreamSubscription<FileSystemEntity> subscription;
+          subscription = stream.listen((entity) {
             if (entity is Directory) return;
             if (_files.contains(path)) return;
 
             _emitEvent(ChangeType.ADD, entity.path);
             _files.add(entity.path);
           }, onDone: () {
-            _listSubscriptions.remove(sub);
+            _listSubscriptions.remove(subscription);
           }, onError: (e, stackTrace) {
-            _listSubscriptions.remove(sub);
+            _listSubscriptions.remove(subscription);
             _emitError(e, stackTrace);
           }, cancelOnError: true);
-          _listSubscriptions.add(sub);
+          _listSubscriptions.add(subscription);
         } else if (event is FileSystemModifyEvent) {
           if (!event.isDirectory) {
             _emitEvent(ChangeType.MODIFY, path);
           }
         } else {
           assert(event is FileSystemDeleteEvent);
           for (var removedPath in _files.remove(path)) {
             _emitEvent(ChangeType.REMOVE, removedPath);
           }
         }
       }
     });
   }
 
   /// Sort all the events in a batch into sets based on their path.
   ///
   /// A single input event may result in multiple events in the returned map;
   /// for example, a MOVE event becomes a DELETE event for the source and a
   /// CREATE event for the destination.
   ///
   /// The returned events won't contain any [FileSystemMoveEvent]s, nor will it
   /// contain any events relating to [path].
   Map<String, Set<FileSystemEvent>> _sortEvents(List<FileSystemEvent> batch) {
-    var eventsForPaths = {};
+    var eventsForPaths = <String, Set>{};
 
     // Events within directories that already have events are superfluous; the
     // directory's full contents will be examined anyway, so we ignore such
     // events. Emitting them could cause useless or out-of-order events.
     var directories = unionAll(batch.map((event) {
       if (!event.isDirectory) return new Set();
-      if (event is! FileSystemMoveEvent) return new Set.from([event.path]);
-      return new Set.from([event.path, event.destination]);
+      if (event is FileSystemMoveEvent) {
+        return new Set.from([event.path, event.destination]);
+      }
+      return new Set.from([event.path]);
     }));
 
     isInModifiedDirectory(path) =>
         directories.any((dir) => path != dir && path.startsWith(dir));
 
     addEvent(path, event) {
       if (isInModifiedDirectory(path)) return;
       var set = eventsForPaths.putIfAbsent(path, () => new Set());
       set.add(event);
     }
@@ skipping 74 matching lines @@
   /// This returns a list whose order should be reflected in the events emitted
   /// to the user, unlike the batched events from [Directory.watch]. The
   /// returned list may be empty, indicating that no changes occurred to [path]
   /// (probably indicating that it was created and then immediately deleted).
   List<FileSystemEvent> _eventsBasedOnFileSystem(String path) {
     var fileExisted = _files.contains(path);
     var dirExisted = _files.containsDir(path);
     var fileExists = new File(path).existsSync();
     var dirExists = new Directory(path).existsSync();
 
-    var events = [];
+    var events = <FileSystemEvent>[];
     if (fileExisted) {
       if (fileExists) {
         events.add(new ConstructableFileSystemModifyEvent(path, false, false));
       } else {
         events.add(new ConstructableFileSystemDeleteEvent(path, false));
       }
     } else if (dirExisted) {
       if (dirExists) {
         // If we got contradictory events for a directory that used to exist and
         // still exists, we need to rescan the whole thing in case it was
@@ skipping 14 matching lines @@
     return events;
   }
 
   /// The callback that's run when the [Directory.watch] stream is closed.
   /// Note that this is unlikely to happen on Windows, unless the system itself
   /// closes the handle.
   void _onDone() {
     _watchSubscription = null;
 
     // Emit remove events for any remaining files.
-    for (var file in _files.toSet()) {
+    for (var file in _files.paths) {
       _emitEvent(ChangeType.REMOVE, file);
     }
     _files.clear();
     close();
   }
 
   /// Start or restart the underlying [Directory.watch] stream.
   void _startWatch() {
     // Batch the events together so that we can dedup events.
     var innerStream = new Directory(path).watch(recursive: true);
@@ skipping 28 matching lines @@
 
     _eventsController.add(new WatchEvent(type, path));
   }
 
   /// Emit an error, then close the watcher.
   void _emitError(error, StackTrace stackTrace) {
     _eventsController.addError(error, stackTrace);
     close();
   }
 }