Revert "Fix remaining strong-mode warnings and errors in dart:io."

sdk/lib/io/directory_impl.dart

 // Copyright (c) 2012, 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.
 
 part of dart.io;
 
 class _Directory extends FileSystemEntity implements Directory {
   final String path;
 
   _Directory(this.path) {
@@ skipping 54 matching lines @@
     }
     return (result == 1);
   }
 
   Directory get absolute => new Directory(_absolutePath);
 
   Future<FileStat> stat() => FileStat.stat(path);
 
   FileStat statSync() => FileStat.statSync(path);
 
+  // Compute the index of the first directory in the list that exists. If
+  // none of the directories exist dirsToCreate.length is returned.
+  Future<int> _computeExistingIndex(List dirsToCreate) {
+    var future;
+    var notFound = dirsToCreate.length;
+    for (var i = 0; i < dirsToCreate.length; i++) {
+      if (future == null) {
+        future = dirsToCreate[i].exists().then((e) => e ? i : notFound);
+      } else {
+        future = future.then((index) {
+          if (index != notFound) {
+            return new Future.value(index);
+          }
+          return dirsToCreate[i].exists().then((e) => e ? i : notFound);
+        });
+      }
+    }
+    if (future == null) {
+      return new Future.value(notFound);
+    } else {
+      return future;
+    }
+  }
+
   Future<Directory> create({bool recursive: false}) {
     if (recursive) {
       return exists().then((exists) {
         if (exists) return this;
         if (path != parent.path) {
           return parent.create(recursive: true).then((_) {
             return create();
           });
         } else {
           return create();
@@ skipping 164 matching lines @@
 
   static const int RESPONSE_TYPE = 0;
   static const int RESPONSE_PATH = 1;
   static const int RESPONSE_COMPLETE = 1;
   static const int RESPONSE_ERROR = 2;
 
   final String path;
   final bool recursive;
   final bool followLinks;
 
-  StreamController<FileSystemEntity> controller;
+  StreamController controller;
   bool canceled = false;
   bool nextRunning = false;
   bool closed = false;
   _AsyncDirectoryListerOps _ops;
   Completer closeCompleter = new Completer();
 
   _AsyncDirectoryLister(this.path, this.recursive, this.followLinks) {
-    controller = new StreamController<FileSystemEntity>(onListen: onListen,
-                                                        onResume: onResume,
-                                                        onCancel: onCancel,
-                                                        sync: true);
+    controller = new StreamController(onListen: onListen,
+                                      onResume: onResume,
+                                      onCancel: onCancel,
+                                      sync: true);
   }
 
   // Calling this function will increase the reference count on the native
   // object that implements the async directory lister operations. It should
   // only be called to pass the pointer to the IO Service, which will decrement
   // the reference count when it is finished with it.
   int _pointer() {
     return (_ops == null) ? null : _ops.getPointer();
   }
 
-  Stream<FileSystemEntity> get stream => controller.stream;
+  Stream get stream => controller.stream;
 
   void onListen() {
     _IOService._dispatch(_DIRECTORY_LIST_START, [path, recursive, followLinks])
         .then((response) {
           if (response is int) {
             _ops = new _AsyncDirectoryListerOps(response);
             next();
           } else if (response is Error) {
             controller.addError(response, response.stackTrace);
             close();
@@ skipping 103 matching lines @@
       controller.addError(
           new FileSystemException("Directory listing failed",
                                   errorPath,
                                   err));
     } else {
       controller.addError(
           new FileSystemException("Internal error"));
     }
   }
 }