Add step OverAwait to service protocol

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 1559 matching lines @@
   }
 
   Future stepInto() {
     return invokeRpc('resume', {'step': 'Into'});
   }
 
   Future stepOver() {
     return invokeRpc('resume', {'step': 'Over'});
   }
 
+  Future stepOverAsyncContinuation() {
+    return invokeRpc('resume', {'step': 'OverAsyncContinuation'});
+  }
+
   Future stepOut() {
     return invokeRpc('resume', {'step': 'Out'});
   }
 
 
-  static const int kFirstResume = 0;
-  static const int kSecondResume = 1;
-  /// result[kFirstResume] completes after the inital resume. The UI should
+  static const int kResumeFuture = 0;
+  static const int kPauseFuture = 1;
+  /// result[kResumeFuture] 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.
+  /// result[kPauseFuture] completes when the isolate is paused after the
+  /// await. Tests should wait on this future to know that we've completed
+  /// the OverAWait.
   Future<List<Future>> asyncStepOver() async {
-    final Completer firstResume = new Completer();
-    final Completer secondResume = new Completer();
-    final List<Future> result = [firstResume.future, secondResume.future];
+    final Completer resumedAfterSyntheticBreakpointAdded = new Completer();
+    final Completer pausedAtSyntheticBreakpoint = new Completer();
+    final List<Future> result =
+        [resumedAfterSyntheticBreakpointAdded.future,
+          pausedAtSyntheticBreakpoint.future];
     StreamSubscription subscription;
 
-    // Inner error handling function.
-    handleError(error) {
+    // Cancel the subscription.
+    cancelSubscription() {
       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);
+    // Complete futures with with error.
+    completeError(error) {
+      if (!resumedAfterSyntheticBreakpointAdded.isCompleted) {
+        resumedAfterSyntheticBreakpointAdded.completeError(error);
+      }
+      if (!pausedAtSyntheticBreakpoint.isCompleted) {
+        pausedAtSyntheticBreakpoint.completeError(error);
+      }
+    }
 
-      // 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) {
+      completeError(e);
+      return result;
+    }
+
+    Breakpoint syntheticBreakpoint;
+
+    subscription = stream.listen((ServiceEvent event) async {
+      // Synthetic breakpoint add event. This is the first event we will
+      // receive.
+      bool isAdd = (event.kind == ServiceEvent.kBreakpointAdded) &&
+                   (event.breakpoint.isSyntheticAsyncContinuation) &&
+                   (event.owner == this);
+      // Resume after synthetic breakpoint added. This is the second event
+      // we will recieve.
+      bool isResume = (event.kind == ServiceEvent.kResume) &&
+                      (syntheticBreakpoint != null) &&
+                      (event.owner == this);
+      // Paused at synthetic breakpoint. This is the third event we will
+      // receive.
+      bool isPaused = (event.kind == ServiceEvent.kPauseBreakpoint) &&
+                      (syntheticBreakpoint != null) &&
+                      (event.breakpoint == syntheticBreakpoint);
+      if (isAdd) {
+        syntheticBreakpoint = event.breakpoint;
+      } else if (isResume) {
+        resumedAfterSyntheticBreakpointAdded.complete(this);
+      } else if (isPaused) {
+        pausedAtSyntheticBreakpoint.complete(this);
+        syntheticBreakpoint = null;
+        cancelSubscription();
       }
+    });
 
-      // Subscribe to the debugger event stream.
-      Stream stream;
-      try {
-        stream = await vm.getEventStream(VM.kDebugStream);
-      } catch (e) {
-        handleError(e);
-        return result;
-      }
+    // Issue the step OverAwait command.
+    try {
+      await isolate.stepOverAsyncContinuation();
+    } catch (e) {
+      // This can fail when another client issued the same resume command
+      // or another client has moved the isolate forward.
+      cancelSubscription();
+      completeError(e);
+    }
 
-      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 result;
   }
 
   Future setName(String newName) {
     return invokeRpc('setName', {'name': newName});
   }
 
   Future setExceptionPauseMode(String mode) {
     return invokeRpc('setExceptionPauseMode', {'mode': mode});
   }
@@ skipping 232 matching lines @@
   ServiceEvent.connectionClosed(this.reason) : super._empty(null) {
     kind = kConnectionClosed;
   }
 
   @observable String kind;
   @observable DateTime timestamp;
   @observable Breakpoint breakpoint;
   @observable Frame topFrame;
   @observable String extensionRPC;
   @observable Instance exception;
-  @observable Instance asyncContinuation;
-  @observable bool atAsyncJump;
+  @observable bool atAsyncContinuation;
   @observable ServiceObject inspectee;
   @observable ByteData data;
   @observable int count;
   @observable String reason;
   @observable String exceptions;
   @observable String bytesAsString;
   @observable Map logRecord;
   @observable String extensionKind;
   @observable Map extensionData;
 
@@ skipping 28 matching lines @@
         breakpoint = pauseBpts[0];
       }
     }
     if (map['extensionRPC'] != null) {
       extensionRPC = map['extensionRPC'];
     }
     topFrame = map['topFrame'];
     if (map['exception'] != null) {
       exception = map['exception'];
     }
-    if (map['_asyncContinuation'] != null) {
-      asyncContinuation = map['_asyncContinuation'];
-      atAsyncJump = map['_atAsyncJump'];
-    } else {
-      atAsyncJump = false;
-    }
+    atAsyncContinuation = map['atAsyncContinuation'] != null;
     if (map['inspectee'] != null) {
       inspectee = map['inspectee'];
     }
     if (map['_data'] != null) {
       data = map['_data'];
     }
     if (map['chunkIndex'] != null) {
       chunkIndex = map['chunkIndex'];
     }
     if (map['chunkCount'] != null) {
@@ skipping 50 matching lines @@
 
   // Either SourceLocation or UnresolvedSourceLocation.
   @observable Location location;
 
   // The breakpoint is in a file which is not yet loaded.
   @observable bool latent;
 
   // The breakpoint has been assigned to a final source location.
   @observable bool resolved;
 
+  // The breakpoint was synthetically created as part of an
+  // 'OverAsyncContinuation' resume request.
+  @observable bool isSyntheticAsyncContinuation;
+
   void _update(ObservableMap map, bool mapIsRef) {
     _loaded = true;
     _upgradeCollection(map, owner);
 
     var newNumber = map['breakpointNumber'];
     // number never changes.
     assert((number == null) || (number == newNumber));
     number = newNumber;
     resolved = map['resolved'];
 
     var oldLocation = location;
     var newLocation = map['location'];
     if (oldLocation is UnresolvedSourceLocation &&
         newLocation is SourceLocation) {
       // Breakpoint has been resolved.  Remove old breakpoint.
       var oldScript = oldLocation.script;
       if (oldScript != null && oldScript.loaded) {
         oldScript._removeBreakpoint(this);
       }
     }
     location = newLocation;
     var newScript = location.script;
     if (newScript != null && newScript.loaded) {
       newScript._addBreakpoint(this);
     }
 
+    isSyntheticAsyncContinuation = map['isSyntheticAsyncContinuation'] != null;
+
     assert(resolved || location is UnresolvedSourceLocation);
   }
 
   void remove() {
     // Remove any references to this breakpoint.  It has been removed.
     location.script._removeBreakpoint(this);
     if ((isolate.pauseEvent != null) &&
         (isolate.pauseEvent.breakpoint != null) &&
         (isolate.pauseEvent.breakpoint.id == id)) {
       isolate.pauseEvent.breakpoint = null;
     }
   }
 
   String toString() {
     if (number != null) {
-      return 'Breakpoint ${number} at ${location})';
+      if (isSyntheticAsyncContinuation) {
+        return 'Synthetic Async Continuation Breakpoint ${number}';
+      } else {
+        return 'Breakpoint ${number} at ${location}';
+      }
     } else {
       return 'Uninitialized breakpoint';
     }
   }
 }
 
 
 class LibraryDependency {
   @reflectable final bool isImport;
   @reflectable final bool isDeferred;
@@ skipping 1957 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);
     }
   }
 }