convert isolates to use Future

client/samples/dartcombat/state.dart

 // Copyright (c) 2011, 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.
 
 /**
  * Stores the actual data on a player's boat grid, the UI representation for its
  * grid and the status of each shot. Acts as a controller handling isolate
  * messages (from the main isolate message and shots from the enemy), and UI
  * events.
  */
@@ skipping 125 matching lines @@
 
   /** local action to generate an asynchronous shot at the enemy. */
   void shoot(int x, int y) {
     superShot(x, y, _id % 2 == 0);
   }
 
   /** A single shot on (x, y). */
   void singleShot(int x, int y) {
     if (_canShoot(x, y)) {
       _recordPendingShot(x, y);
-      Promise<int> res = enemy.shoot(x, y); // async shot!
-      res.addCompleteHandler((int result) {
+      Future<int> res = enemy.shoot(x, y); // async shot!
+      res.then((int result) {
         _recordShotResult(result, x, y);
       });
-      res.addErrorHandler((String error) {
+      res.handleException((String error) {
         _recordFailedShot(x, y);
+        return true;
       });
     }
   }
 
   /**
    * Takes 1 shot, if it's a hit, it then shoots to each of the 4 cardinal
    * directions until a boat is sunk. When [parallel] all directions are
    * explored in parallel.
    */
   void superShot(int x, int y, bool parallel) {
     if (_canShoot(x, y)) {
       _recordPendingShot(x, y);
-      Promise<int> firstShot = enemy.shoot(x, y);
-      firstShot.addCompleteHandler((int res) {
+      Future<int> firstShot = enemy.shoot(x, y);
+      firstShot.then((int res) {
         _recordShotResult(res, x, y);
         if (res == Constants.HIT) {
           // no miss, but no sunk, search around
           _exploreAllDirections(x, y, parallel);
         }
       });
-      firstShot.addErrorHandler((String error) {
+      firstShot.handleException((String error) {
         _recordFailedShot(x, y);
+        return true;
       });
     }
   }
 
   static final LEFT_DIR = const [-1, 0];
   static final RIGHT_DIR = const [1, 0];
   static final UP_DIR = const [0, -1];
   static final DOWN_DIR = const [0, 1];
 
-  Promise<bool> _exploreAllDirections(int x, int y, bool parallel) {
-    Promise<bool> superShot = new Promise<bool>();
+  Future<bool> _exploreAllDirections(int x, int y, bool parallel) {
+    Completer<bool> superShot = new Completer<bool>();
     if (parallel) {
-      final arr = new List<Promise<bool>>();
+      final arr = new List<Future<bool>>();
       arr.add(_exploreDirectionHelper(LEFT_DIR, x, y));
       arr.add(_exploreDirectionHelper(RIGHT_DIR, x, y));
       arr.add(_exploreDirectionHelper(UP_DIR, x, y));
       arr.add(_exploreDirectionHelper(DOWN_DIR, x, y));
-      superShot.waitFor(arr, 4);
+      Futures.wait(arr).then((arrValues) {
+        superShot.complete(true);
+      });
     } else {
       _seqExploreDirectionHelper(LEFT_DIR, x, y, superShot,
           _seqExploreDirectionHelper(RIGHT_DIR, x, y, superShot,
             _seqExploreDirectionHelper(UP_DIR, x, y, superShot,
               _seqExploreDirectionHelper(DOWN_DIR, x, y, superShot, null))))(false);
     }
-    return superShot;
+    return superShot.future;
   }
   Function _seqExploreDirectionHelper(List<int> dir, int x, int y,
-      Promise<bool> seq, void _next(bool res)) {
+      Completer<bool> seq, void _next(bool res)) {
     return (bool res) {
       if (res) {
         seq.complete(true);
       } else {
         _exploreDirectionHelper(dir, x, y).then(
             (_next != null) ? _next : (void _(v) {seq.complete(false);}));
       }
     };
   }
 
-  Promise<bool> _exploreDirectionHelper(List<int> dir, int x, int y) {
-    Promise<bool> sunk = new Promise<bool>();
+  Future<bool> _exploreDirectionHelper(List<int> dir, int x, int y) {
+    Completer<bool> sunk = new Completer<bool>();
     _followDir(x + dir[0], y + dir[1], dir[0], dir[1], sunk);
-    return sunk;
+    return sunk.future;
   }
 
-  void _followDir(int x, int y, int incX, int incY, Promise<bool> sunk) {
+  void _followDir(int x, int y, int incX, int incY, Completer<bool> sunk) {
     if (_canShoot(x, y)) {
       _recordPendingShot(x, y);
-      Promise<int> shot = enemy.shoot(x, y);
-      shot.addCompleteHandler((int res) {
+      Future<int> shot = enemy.shoot(x, y);
+      shot.then((int res) {
         _recordShotResult(res, x, y);
         switch (res) {
           case Constants.HIT:
-            if (!sunk.isDone() && !sunk.isCancelled()) {
+            if (!sunk.future.isComplete) {
               _followDir(x + incX, y + incY, incX, incY, sunk);
             }
             break;
           case Constants.SUNK:
             sunk.complete(true);
             break;
           case Constants.MISS:
             sunk.complete(false);
             break;
         }
       });
-      shot.addErrorHandler((String error) {
+      shot.handleException((String error) {
         _recordFailedShot(x, y);
-        sunk.fail(error);
+        sunk.completeException(error);
+        return true;
       });
       // We don't actually chain sunk.cancel with shot.cancel because individual
       // shots can't be cancelled.
     } else {
       sunk.complete(false);
     }
   }
 
   /** checks that a shot is in range and has not been done before. */
   bool _canShoot(int x, int y) {
@@ skipping 42 matching lines @@
       case Constants.SUNK:
         totalHits++;
         boatsSunk++;
         _enemyView.addHit(x, y);
         enemyGrid.hit(x, y);
         break;
     }
     _enemyView.statusBar.updateStatus();
   }
 }