Rewrite asyncStepOver to use await

runtime/observatory/lib/src/service/object.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.
 
 part of service;
 
 // Some value smaller than the object ring, so requesting a large array
 // doesn't result in an expired ref because the elements lapped it in the
 // object ring.
 const int kDefaultFieldLimit = 100;
@@ skipping 1572 matching lines @@
 
 
   static const int kFirstResume = 0;
   static const int kSecondResume = 1;
   /// result[kFirstResume] completes after the inital resume. The UI should
   /// wait on this future because some other breakpoint may be hit before the
   /// async continuation.
   /// result[kSecondResume] completes after the second resume. Tests should
   /// wait on this future to avoid confusing the pause event at the
   /// state-machine switch with the pause event after the state-machine switch.
-  List<Future> asyncStepOver() {
-    Completer firstResume = new Completer();
-    Completer secondResume = new Completer();
-    var subscription;
+  Future<List<Future>> asyncStepOver() async {
+    final Completer firstResume = new Completer();
+    final Completer secondResume = new Completer();
+    final List<Future> result = [firstResume.future, secondResume.future];
+    StreamSubscription subscription;
 
+    // Inner error handling function.
     handleError(error) {
       if (subscription != null) {
         subscription.cancel();
         subscription = null;
       }
       firstResume.completeError(error);
       secondResume.completeError(error);
     }
 
     if ((pauseEvent == null) ||
         (pauseEvent.kind != ServiceEvent.kPauseBreakpoint) ||
         (pauseEvent.asyncContinuation == null)) {
       handleError(new Exception("No async continuation available"));
     } else {
       Instance continuation = pauseEvent.asyncContinuation;
       assert(continuation.isClosure);
-      addBreakOnActivation(continuation).then((Breakpoint continuationBpt) {
-        vm.getEventStream(VM.kDebugStream).then((stream) {
-          var onResume = firstResume;
-          subscription = stream.listen((ServiceEvent event) {
-            if ((event.kind == ServiceEvent.kPauseBreakpoint) &&
-                (event.breakpoint == continuationBpt)) {
-              // We are stopped before state-machine dispatch; step-over to
-              // reach user code.
-              removeBreakpoint(continuationBpt).then((_) {
-                onResume = secondResume;
-                stepOver().catchError(handleError);
-              });
-            } else if (event.kind == ServiceEvent.kResume) {
-              if (onResume == secondResume) {
-                subscription.cancel();
-                subscription = null;
-              }
-              if (onResume != null) {
-                onResume.complete(this);
-                onResume = null;
-              }
-            }
-          });
-          resume().catchError(handleError);
-        }).catchError(handleError);
-      }).catchError(handleError);
+
+      // Add breakpoint at continuation.
+      Breakpoint continuationBpt;
+      try {
+        continuationBpt = await addBreakOnActivation(continuation);
+      } catch (e) {
+        handleError(e);
+        return result;
+      }
+
+      // Subscribe to the debugger event stream.
+      Stream stream;
+      try {
+        stream = await vm.getEventStream(VM.kDebugStream);
+      } catch (e) {
+        handleError(e);
+        return result;
+      }
+
+      Completer onResume = firstResume;
+      subscription = stream.listen((ServiceEvent event) async {
+        if ((event.kind == ServiceEvent.kPauseBreakpoint) &&
+            (event.breakpoint == continuationBpt)) {
+          // We are stopped before state-machine dispatch:
+          // 1) Remove the continuation breakpoint.
+          // 2) step over.
+          // reach user code.
+          await removeBreakpoint(continuationBpt);
+          onResume = secondResume;
+          stepOver().catchError(handleError);
+        } else if (event.kind == ServiceEvent.kResume) {
+          // We've resumed.
+          if (onResume == secondResume) {
+            // This is our second resume, cancel our subscription to the debug
+            // stream.
+            subscription.cancel();
+            subscription = null;
+          }
+          // Complete onResume and clear it.
+          if (onResume != null) {
+            onResume.complete(this);
+            onResume = null;
+          }
+        }
+      });
+
+      // Call resume, which will eventually cause us to hit continuationBpt.
+      resume().catchError(handleError);
     }
-
-    return [firstResume.future, secondResume.future];
+    return result;
   }
 
   Future setName(String newName) {
     return invokeRpc('setName', {'name': newName});
   }
 
   Future setExceptionPauseMode(String mode) {
     return invokeRpc('setExceptionPauseMode', {'mode': mode});
   }
 
@@ skipping 756 matching lines @@
     oneByteFunction = map['_oneByteFunction'];
     twoByteFunction = map['_twoByteFunction'];
     externalOneByteFunction = map['_externalOneByteFunction'];
     externalTwoByteFunction = map['_externalTwoByteFunction'];
 
     nativeFields = map['_nativeFields'];
     fields = map['fields'];
     elements = map['elements'];
     associations = map['associations'];
     if (map['bytes'] != null) {
-      var bytes = BASE64.decode(map['bytes']);
+      Uint8List bytes = BASE64.decode(map['bytes']);
       switch (map['kind']) {
         case "Uint8ClampedList":
           typedElements = bytes.buffer.asUint8ClampedList(); break;
         case "Uint8List":
           typedElements = bytes.buffer.asUint8List(); break;
         case "Uint16List":
           typedElements = bytes.buffer.asUint16List(); break;
         case "Uint32List":
           typedElements = bytes.buffer.asUint32List(); break;
         case "Uint64List":
@@ skipping 1197 matching lines @@
         }
         var function = inlinedFunctionsTable[inline_id];
         codeInlineInterval.functions.add(function);
       }
       inlineIntervals.add(codeInlineInterval);
     }
   }
 
   @observable bool hasDisassembly = false;
 
-  void _processDisassembly(List<String> disassembly){
+  void _processDisassembly(List disassembly) {
     assert(disassembly != null);
     instructions.clear();
     instructionsByAddressOffset = new List(endAddress - startAddress);
 
     assert((disassembly.length % 4) == 0);
     for (var i = 0; i < disassembly.length; i += 4) {
       var address = 0;  // Assume code comment.
       var machine = disassembly[i + 1];
       var human = disassembly[i + 2];
       var object = disassembly[i + 3];
@@ skipping 381 matching lines @@
     var v = list[i];
     if ((v is ObservableMap) && _isServiceMap(v)) {
       list[i] = owner.getFromMap(v);
     } else if (v is ObservableList) {
       _upgradeObservableList(v, owner);
     } else if (v is ObservableMap) {
       _upgradeObservableMap(v, owner);
     }
   }
 }