Switch from AsyncThunk to AsyncMemoizer.

lib/src/runner/browser/compiler_pool.dart

 // Copyright (c) 2015, 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.
 
 library test.util.compiler_pool;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 
+import 'package:async/async.dart';
 import 'package:path/path.dart' as p;
 import 'package:pool/pool.dart';
 
-import '../../util/async_thunk.dart';
 import '../../util/io.dart';
 import '../load_exception.dart';
 
 /// A pool of `dart2js` instances.
 ///
 /// This limits the number of compiler instances running concurrently.
 class CompilerPool {
   /// The internal pool that controls the number of process running at once.
   final Pool _pool;
 
   /// Whether to enable colors on dart2js.
   final bool _color;
 
   /// The currently-active dart2js processes.
   final _processes = new Set<Process>();
 
   /// Whether [close] has been called.
-  bool get _closed => _closeThunk.hasRun;
+  bool get _closed => _closeMemo.hasRun;
 
-  /// The thunk for running [close] exactly once.
-  final _closeThunk = new AsyncThunk();
+  /// The memoizer for running [close] exactly once.
+  final _closeMemo = new AsyncMemoizer();
 
   /// Creates a compiler pool that runs up to [concurrency] instances of
   /// `dart2js` at once.
   ///
   /// If [concurrency] isn't provided, it defaults to 4.
   ///
   /// If [color] is true, `dart2js` will be run with colors enabled.
   CompilerPool({int concurrency, bool color: false})
       : _pool = new Pool(concurrency == null ? 4 : concurrency),
         _color = color;
@@ skipping 72 matching lines @@
     return sanitizeForWindows(stream)
         .listen((data) => buffer.write(UTF8.decode(data))).asFuture();
   }
 
   /// Closes the compiler pool.
   ///
   /// This kills all currently-running compilers and ensures that no more will
   /// be started. It returns a [Future] that completes once all the compilers
   /// have been killed and all resources released.
   Future close() {
-    return _closeThunk.run(() async {
+    return _closeMemo.runOnce(() async {
       await Future.wait(_processes.map((process) async {
         process.kill();
         await process.exitCode;
       }));
     });
   }
 }