Automatically step past async state-machine switch for 'anext'.

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;
 
 /// Helper function for canceling a Future<StreamSubscription>.
 Future cancelFutureSubscription(
     Future<StreamSubscription> subscriptionFuture) async {
   if (subscriptionFuture != null) {
@@ skipping 1378 matching lines @@
   }
 
   Future stepOver() {
     return invokeRpc('resume', {'step': 'Over'});
   }
 
   Future stepOut() {
     return invokeRpc('resume', {'step': 'Out'});
   }
 
+  /// result[0] completes after the inital resume. The UI should wait on this
+  /// future because some other breakpoint may be hit before the async
+  /// continuation.
+  /// result[1] completes after the second resume. Tests should wait on this

[Cutch, 2015/07/20 23:49:35]

name these constants, e.g.:
result[0] -> result[kFirstResume]
result[1] -> result[kSecondResume]

[rmacnak, 2015/07/21 17:35:36]

Done.

+  /// 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;
+
+    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) {
+        isolate.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;
+              }

[Cutch, 2015/07/20 23:49:35]

else { assert(onResume == firstResume); } ?

[rmacnak, 2015/07/21 17:35:36]

Switching to
              if (onResume != null) {
                onResume.complete(this);
                onResume = null;
              }

onResume may be null if we break and resume somewhere else before returning to
the async continutation.

+              onResume.complete(this);
+              onResume = null;
+            }
+          });
+          this.resume().catchError(handleError);

[Cutch, 2015/07/20 23:49:35]

You use isolate. above, please be consistent with 'this' or 'isolate'

[rmacnak, 2015/07/21 17:35:36]

Done.

+        }).catchError(handleError);
+      }).catchError(handleError);
+    }
+
+    return [firstResume.future, secondResume.future];
+  }
+
   Future setName(String newName) {
     return invokeRpc('setName', {'name': newName});
   }
 
   Future setExceptionPauseInfo(String exceptions) {
     return invokeRpc('_setExceptionPauseInfo', {'exceptions': exceptions});
   }
 
   Future<ServiceMap> getStack() {
     return invokeRpc('getStack', {});
@@ skipping 2174 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);
     }
   }
 }