Make pub strong-mode clean.

lib/src/barback/asset_environment.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.
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:barback/barback.dart';
 import 'package:path/path.dart' as path;
 import 'package:watcher/watcher.dart';
@@ skipping 178 matching lines @@
         .then((server) => _adminServer = server);
   }
 
   /// Binds a new port to serve assets from within [rootDirectory] in the
   /// entrypoint package.
   ///
   /// Adds and watches the sources within that directory. Returns a [Future]
   /// that completes to the bound server.
   ///
   /// If [rootDirectory] is already being served, returns that existing server.
-  Future<BarbackServer> serveDirectory(String rootDirectory) {
+  Future<BarbackServer> serveDirectory(String rootDirectory) async {
     // See if there is already a server bound to the directory.
     var directory = _directories[rootDirectory];
     if (directory != null) {
       return directory.server.then((server) {
         log.fine('Already serving $rootDirectory on ${server.url}.');
         return server;
       });
     }
 
     // See if the new directory overlaps any existing servers.
@@ skipping 14 matching lines @@
           .toSet();
       while (boundPorts.contains(port)) {
         port++;
       }
     }
 
     var sourceDirectory = new SourceDirectory(
         this, rootDirectory, _hostname, port);
     _directories[rootDirectory] = sourceDirectory;
 
-    return _provideDirectorySources(rootPackage, rootDirectory)
-        .then((subscription) {
-      sourceDirectory.watchSubscription = subscription;
-      return sourceDirectory.serve();
-    });
+    sourceDirectory.watchSubscription =
+        await _provideDirectorySources(rootPackage, rootDirectory);
+    return await sourceDirectory.serve();
   }
 
   /// Binds a new port to serve assets from within the "bin" directory of
   /// [package].
   ///
   /// Adds the sources within that directory and then binds a server to it.
   /// Unlike [serveDirectory], this works with packages that are not the
   /// entrypoint.
   ///
   /// Returns a [Future] that completes to the bound server.
@@ skipping 52 matching lines @@
   /// [id] is assumed to be an executable in a bin directory. The return value
   /// is intended for log output and may contain formatting.
   String _formatExecutable(AssetId id) =>
       log.bold("${id.package}:${path.basenameWithoutExtension(id.path)}");
 
   /// Stops the server bound to [rootDirectory].
   ///
   /// Also removes any source files within that directory from barback. Returns
   /// the URL of the unbound server, of `null` if [rootDirectory] was not
   /// bound to a server.
-  Future<Uri> unserveDirectory(String rootDirectory) {
+  Future<Uri> unserveDirectory(String rootDirectory) async {
     log.fine("Unserving $rootDirectory.");
     var directory = _directories.remove(rootDirectory);
     if (directory == null) return new Future.value();
 
-    return directory.server.then((server) {
-      var url = server.url;
-      return directory.close().then((_) {
-        _removeDirectorySources(rootDirectory);
-        return url;
-      });
-    });
+    var url = (await directory.server).url;
+    await directory.close();
+    _removeDirectorySources(rootDirectory);
+    return url;
   }
 
   /// Gets the source directory that contains [assetPath] within the entrypoint
   /// package.
   ///
   /// If [assetPath] is not contained within a source directory, this throws
   /// an exception.
   String getSourceDirectoryContaining(String assetPath) =>
       _directories.values
           .firstWhere((dir) => path.isWithin(dir.directory, assetPath))
           .directory;
 
   /// Return all URLs serving [assetPath] in this environment.
-  Future<List<Uri>> getUrlsForAssetPath(String assetPath) {
+  Future<List<Uri>> getUrlsForAssetPath(String assetPath) async {
     // Check the three (mutually-exclusive) places the path could be pointing.
-    return _lookUpPathInServerRoot(assetPath).then((urls) {
-      if (urls.isNotEmpty) return urls;
-      return _lookUpPathInPackagesDirectory(assetPath);
-    }).then((urls) {
-      if (urls.isNotEmpty) return urls;
-      return _lookUpPathInDependency(assetPath);
-    });
+    var urls = await _lookUpPathInServerRoot(assetPath);
+    if (urls.isEmpty) urls = await _lookUpPathInPackagesDirectory(assetPath);
+    if (urls.isEmpty) urls = await _lookUpPathInDependency(assetPath);
+    return urls;
   }
 
   /// Look up [assetPath] in the root directories of servers running in the
   /// entrypoint package.
   Future<List<Uri>> _lookUpPathInServerRoot(String assetPath) {
     // Find all of the servers whose root directories contain the asset and
     // generate appropriate URLs for each.
     return Future.wait(_directories.values
         .where((dir) => path.isWithin(dir.directory, assetPath))
         .map((dir) {
@@ skipping 432 matching lines @@
   String toString() => "polling";
 }
 
 class _NoneWatcherType implements WatcherType {
   const _NoneWatcherType();
 
   DirectoryWatcher create(String directory) => null;
 
   String toString() => "none";
 }