Remove Futures class, move methods to Future.

utils/tests/pub/test_pub.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.
 
 /// Test infrastructure for testing pub. Unlike typical unit tests, most pub
 /// tests are integration tests that stage some stuff on the file system, run
 /// pub, and then validate the results. This library provides an API to build
 /// tests like that.
 library test_pub;
 
@@ skipping 556 matching lines @@
   pub.writeLine("y");
 }
 
 
 /// Calls [fn] with appropriately modified arguments to run a pub process. [fn]
 /// should have the same signature as [startProcess], except that the returned
 /// [Future] may have a type other than [Process].
 Future _doPub(Function fn, sandboxDir, List args, Future<Uri> tokenEndpoint) {
   String pathInSandbox(path) => join(getFullPath(sandboxDir), path);
 
-  return Futures.wait([
+  return Future.wait([
     ensureDir(pathInSandbox(appPath)),
     _awaitObject(args),
     tokenEndpoint == null ? new Future.immediate(null) : tokenEndpoint
   ]).then((results) {
     var args = results[1];
     var tokenEndpoint = results[2];
     // Find a Dart executable we can use to spawn. Use the same one that was
     // used to run this script itself.
     var dartBin = new Options().executable;
 
@@ skipping 320 matching lines @@
   /// the creation is done.
   Future<Directory> create(parentDir) {
     // Create the directory.
     return ensureDir(join(parentDir, _stringName)).then((dir) {
       if (contents == null) return new Future<Directory>.immediate(dir);
 
       // Recursively create all of its children.
       final childFutures =
           contents.mappedBy((child) => child.create(dir)).toList();
       // Only complete once all of the children have been created too.
-      return Futures.wait(childFutures).then((_) => dir);
+      return Future.wait(childFutures).then((_) => dir);
     });
   }
 
   /// Deletes the directory within [dir]. Returns a [Future] that is completed
   /// after the deletion is done.
   Future delete(dir) {
     return deleteDir(join(dir, _stringName));
   }
 
   /// Validates that the directory at [path] contains all of the expected
   /// contents in this descriptor. Note that this does *not* check that the
   /// directory doesn't contain other unexpected stuff, just that it *does*
   /// contain the stuff we do expect.
   Future validate(String path) {
     return _validateOneMatch(path, (dir) {
       // Validate each of the items in this directory.
       final entryFutures =
           contents.mappedBy((entry) => entry.validate(dir)).toList();
 
       // If they are all valid, the directory is valid.
-      return Futures.wait(entryFutures).then((entries) => null);
+      return Future.wait(entryFutures).then((entries) => null);
     });
   }
 
   /// Loads [path] from within this directory.
   InputStream load(List<String> path) {
     if (path.isEmpty) {
       throw "Can't load the contents of $name: is a directory.";
     }
 
     for (var descriptor in contents) {
@@ skipping 115 matching lines @@
   TarFileDescriptor(Pattern name, this.contents)
   : super(name);
 
   /// Creates the files and directories within this tar file, then archives
   /// them, compresses them, and saves the result to [parentDir].
   Future<File> create(parentDir) {
     // TODO(rnystrom): Use withTempDir().
     var tempDir;
     return createTempDir().then((_tempDir) {
       tempDir = _tempDir;
-      return Futures.wait(contents.mappedBy((child) => child.create(tempDir)));
+      return Future.wait(contents.mappedBy((child) => child.create(tempDir)));
     }).then((createdContents) {
       return consumeInputStream(createTarGz(createdContents, baseDir: tempDir));
     }).then((bytes) {
       return new File(join(parentDir, _stringName)).writeAsBytes(bytes);
     }).then((file) {
       return deleteDir(tempDir).then((_) => file);
     });
   }
 
   /// Validates that the `.tar.gz` file at [path] contains the expected
@@ skipping 389 matching lines @@
   }
 }
 
 /// Takes a simple data structure (composed of [Map]s, [List]s, scalar objects,
 /// and [Future]s) and recursively resolves all the [Future]s contained within.
 /// Completes with the fully resolved structure.
 Future _awaitObject(object) {
   // Unroll nested futures.
   if (object is Future) return object.then(_awaitObject);
   if (object is Collection) {
-    return Futures.wait(object.mappedBy(_awaitObject).toList());
+    return Future.wait(object.mappedBy(_awaitObject).toList());
   }
   if (object is! Map) return new Future.immediate(object);
 
   var pairs = <Future<Pair>>[];
   object.forEach((key, value) {
     pairs.add(_awaitObject(value)
         .then((resolved) => new Pair(key, resolved)));
   });
-  return Futures.wait(pairs).then((resolvedPairs) {
+  return Future.wait(pairs).then((resolvedPairs) {
     var map = {};
     for (var pair in resolvedPairs) {
       map[pair.first] = pair.last;
     }
     return map;
   });
 }
 
 /// Schedules a callback to be called as part of the test case.
 void _schedule(_ScheduledEvent event) {
@@ skipping 34 matching lines @@
 /// calling [completion] is unnecessary.
 void expectLater(Future actual, matcher, {String reason,
     FailureHandler failureHandler, bool verbose: false}) {
   _schedule((_) {
     return actual.then((value) {
       expect(value, matcher, reason: reason, failureHandler: failureHandler,
           verbose: false);
     });
   });
 }