Include the awaiter stack trace in the service protocol

runtime/vm/debugger.h

 // Copyright (c) 2012, 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.
 
 #ifndef RUNTIME_VM_DEBUGGER_H_
 #define RUNTIME_VM_DEBUGGER_H_
 
 #include "include/dart_tools_api.h"
 
 #include "vm/object.h"
@@ skipping 318 matching lines @@
   RawObject* GetAsyncOperation();
 
   RawObject* Evaluate(const String& expr);
 
   // Print the activation frame into |jsobj|. if |full| is false, script
   // and local variable objects are only references. if |full| is true,
   // the complete script, function, and, local variable objects are included.
   void PrintToJSONObject(JSONObject* jsobj, bool full = false);
 
   RawObject* GetAsyncAwaiter();
+  RawObject* GetCausalStack();
 
   bool HandlesException(const Instance& exc_obj);
 
  private:
   void PrintToJSONObjectRegular(JSONObject* jsobj, bool full);
   void PrintToJSONObjectAsyncCausal(JSONObject* jsobj, bool full);
   void PrintToJSONObjectAsyncSuspensionMarker(JSONObject* jsobj, bool full);
-
+  void PrintToJSONObjectAsyncActivation(JSONObject* jsobj, bool full);
   void PrintContextMismatchError(intptr_t ctx_slot,
                                  intptr_t frame_ctx_level,
                                  intptr_t var_ctx_level);
 
   intptr_t TryIndex();
   void GetPcDescriptors();
   void GetVarDescriptors();
   void GetDescIndices();
 
   RawObject* GetAsyncContextVariable(const String& name);
   RawObject* GetAsyncStreamControllerStreamAwaiter(const Object& stream);
   RawObject* GetAsyncStreamControllerStream();
   RawObject* GetAsyncCompleterAwaiter(const Object& completer);
   RawObject* GetAsyncCompleter();
   void ExtractTokenPositionFromAsyncClosure();
 
   static const char* KindToCString(Kind kind) {
     switch (kind) {
       case kRegular:
         return "Regular";
       case kAsyncCausal:
         return "AsyncCausal";
       case kAsyncSuspensionMarker:
         return "AsyncSuspensionMarker";
+      case kAsyncActivation:
+        return "AsyncActivation";
       default:
         UNREACHABLE();
         return "";
     }
   }
 
   RawObject* GetStackVar(intptr_t slot_index);
   RawObject* GetContextVar(intptr_t ctxt_level, intptr_t slot_index);
 
   uword pc_;
@@ skipping 153 matching lines @@
   // Returns a stack trace with frames corresponding to invisible functions
   // omitted. CurrentStackTrace always returns a new trace on the current stack.
   // The trace returned by StackTrace may have been cached; it is suitable for
   // use when stepping, but otherwise may be out of sync with the current stack.
   DebuggerStackTrace* StackTrace();
   DebuggerStackTrace* CurrentStackTrace();
 
   DebuggerStackTrace* AsyncCausalStackTrace();
   DebuggerStackTrace* CurrentAsyncCausalStackTrace();
 
+  DebuggerStackTrace* AwaiterStackTrace();
+  DebuggerStackTrace* CurrentAwaiterStackTrace();
+
   // Returns a debugger stack trace corresponding to a dart.core.StackTrace.
   // Frames corresponding to invisible functions are omitted. It is not valid
   // to query local variables in the returned stack.
   DebuggerStackTrace* StackTraceFrom(const class StackTrace& dart_stacktrace);
 
   RawArray* GetInstanceFields(const Instance& obj);
   RawArray* GetStaticFields(const Class& cls);
   RawArray* GetLibraryFields(const Library& lib);
   RawArray* GetGlobalFields(const Library& lib);
 
@@ skipping 132 matching lines @@
                             bool include_private_fields);
 
   // Handles any events which pause vm execution.  Breakpoints,
   // interrupts, etc.
   void Pause(ServiceEvent* event);
 
   void HandleSteppingRequest(DebuggerStackTrace* stack_trace,
                              bool skip_next_step = false);
 
   void CacheStackTraces(DebuggerStackTrace* stack_trace,
-                        DebuggerStackTrace* async_causal_stack_trace);
+                        DebuggerStackTrace* async_causal_stack_trace,
+                        DebuggerStackTrace* awaiter_stack_trace);
   void ClearCachedStackTraces();
 
 
   // Can we rewind to the indicated frame?
   bool CanRewindFrame(intptr_t frame_index, const char** error) const;
 
   void RewindToFrame(intptr_t frame_index);
   void RewindToUnoptimizedFrame(StackFrame* frame, const Code& code);
   void RewindToOptimizedFrame(StackFrame* frame,
                               const Code& code,
@@ skipping 25 matching lines @@
   // paused for breakpoints, isolate interruption, and (sometimes)
   // exceptions.
   ServiceEvent* pause_event_;
 
   // An id -> object map.  Valid only while IsPaused().
   RemoteObjectCache* obj_cache_;
 
   // Current stack trace. Valid only while IsPaused().
   DebuggerStackTrace* stack_trace_;
   DebuggerStackTrace* async_causal_stack_trace_;
+  DebuggerStackTrace* awaiter_stack_trace_;
 
   // When stepping through code, only pause the program if the top
   // frame corresponds to this fp value, or if the top frame is
   // lower on the stack.
   uword stepping_fp_;
 
   // If we step while at a breakpoint, we would hit the same pc twice.
   // We use this field to let us skip the next single-step after a
   // breakpoint.
   bool skip_next_step_;
@@ skipping 11 matching lines @@
 
   friend class Isolate;
   friend class BreakpointLocation;
   DISALLOW_COPY_AND_ASSIGN(Debugger);
 };
 
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_DEBUGGER_H_