Clean up the Windows watcher.

pkg/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';
@@ skipping 10 matching lines @@
 class WindowsDirectoryWatcher extends ResubscribableDirectoryWatcher {
   WindowsDirectoryWatcher(String directory)
       : super(directory, () => new _WindowsDirectoryWatcher(directory));
 }
 
 class _EventBatcher {
   static const Duration _BATCH_DELAY = const Duration(milliseconds: 100);
   final List<FileSystemEvent> events = [];
   Timer timer;
 
-  void addEvent(FileSystemEvent event) {
+  void addEvent(FileSystemEvent event, void callback()) {
     events.add(event);
-  }
-
-  void startTimer(void callback()) {
     if (timer != null) {
       timer.cancel();
     }
     timer = new Timer(_BATCH_DELAY, callback);
   }
 
   void cancelTimer() {
     timer.cancel();
   }
 }
@@ skipping 25 matching lines @@
 
   /// The subscription to the stream returned by [Directory.watch] of the
   /// parent directory to [directory]. This is needed to detect changes to
   /// [directory], as they are not included on Windows.
   StreamSubscription<FileSystemEvent> _parentWatchSubscription;
 
   /// The subscription to the [Directory.list] call for the initial listing of
   /// the directory to determine its initial state.
   StreamSubscription<FileSystemEntity> _initialListSubscription;
 
-  /// The subscriptions to the [Directory.list] call for listing the contents of
-  /// subdirectories that was moved into the watched directory.
+  /// The subscriptions to the [Directory.list] calls for listing the contents
+  /// of subdirectories that were moved into the watched directory.
   final Set<StreamSubscription<FileSystemEntity>> _listSubscriptions
       = new HashSet<StreamSubscription<FileSystemEntity>>();
 
   _WindowsDirectoryWatcher(String directory)
       : directory = directory, _files = new PathSet(directory) {
-    _startWatch();
-    _startParentWatcher();
-
     // Before we're ready to emit events, wait for [_listDir] to complete.
-    _listDir().then(_readyCompleter.complete);
+    _listDir().then((_) {
+      _startWatch();
+      _startParentWatcher();
+      _readyCompleter.complete();
+    });
   }
 
   void close() {
     if (_watchSubscription != null) _watchSubscription.cancel();
     if (_parentWatchSubscription != null) _parentWatchSubscription.cancel();
     if (_initialListSubscription != null) _initialListSubscription.cancel();
     for (var sub in _listSubscriptions) {
       sub.cancel();
     }
     _listSubscriptions.clear();
     for (var batcher in _eventBatchers.values) {
       batcher.cancelTimer();
     }
     _eventBatchers.clear();
     _watchSubscription = null;
     _parentWatchSubscription = null;
     _initialListSubscription = null;
     _eventsController.close();
   }
 
   /// On Windows, if [directory] is deleted, we will not receive any event.
+  ///
   /// Instead, we add a watcher on the parent folder (if any), that can notify
-  /// us about [directory].
-  /// This also includes events such as moves.
+  /// us about [directory]. This also includes events such as moves.
   void _startParentWatcher() {
     var absoluteDir = p.absolute(directory);
     var parent = p.dirname(absoluteDir);
-    // Check if we [directory] is already the root directory.
+    // Check if [directory] is already the root directory.
     if (FileSystemEntity.identicalSync(parent, directory)) return;
     var parentStream = Chain.track(
         new Directory(parent).watch(recursive: false));
     _parentWatchSubscription = parentStream.listen((event) {
       // Only look at events for 'directory'.
       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(directory) ==
            FileSystemEntityType.NOT_FOUND)) {
         for (var path in _files.toSet()) {
           _emitEvent(ChangeType.REMOVE, path);
         }
         _files.clear();
         close();
       }
     }, onError: (error) {
-      // Ignore errors, simply close the stream.
+      // 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) {
-    // If we get a event before we're ready to begin emitting events,
-    // ignore those events and re-list the directory.
-    if (!isReady) {
-      _listDir().then((_) {
-       _readyCompleter.complete();
-      });
-      return;
-    }
-
-    _EventBatcher batcher = _eventBatchers.putIfAbsent(
+    assert(isReady);
+    final batcher = _eventBatchers.putIfAbsent(
         event.path, () => new _EventBatcher());
-    batcher.addEvent(event);
-    batcher.startTimer(() {
+    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) {
       var relativePath = p.relative(path, from: directory);
 
@@ skipping 66 matching lines @@
         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);
     }
 
     for (var event in batch) {
       if (event is FileSystemMoveEvent) {
-        FileSystemMoveEvent moveEvent = event;
-        addEvent(moveEvent.destination, event);
+        addEvent(event.destination, event);
       }
       addEvent(event.path, event);
     }
 
     return eventsForPaths;
   }
 
   /// Returns the canonical event from a batch of events on the same path, if
   /// one exists.
   ///
@@ skipping 98 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.
+    // Emit remove events for any remaining files.
     for (var file in _files.toSet()) {
       _emitEvent(ChangeType.REMOVE, file);
     }
     _files.clear();
     close();
   }
 
   /// Start or restart the underlying [Directory.watch] stream.
   void _startWatch() {
-    // Batch the events changes together so that we can dedup events.
+    // Batch the events together so that we can dedup events.
     var innerStream =
         Chain.track(new Directory(directory).watch(recursive: true));
     _watchSubscription = innerStream.listen(_onEvent,
         onError: _eventsController.addError,
         onDone: _onDone);
   }
 
   /// Starts or restarts listing the watched directory to get an initial picture
   /// of its state.
   Future _listDir() {
@@ skipping 20 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();
   }
 }