Display the awaiter call stack in Observatory

runtime/observatory/lib/src/elements/debugger.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.
 
 library debugger_page_element;
 
 import 'dart:async';
 import 'dart:svg';
 import 'dart:html';
 import 'dart:math';
@@ skipping 582 matching lines @@
       _setBreakOnException,
       (debugger, _) => debugger.breakOnException
     ],
     'up-is-down': [
       _boolValues,
       _setUpIsDown,
       (debugger, _) => debugger.upIsDown
     ],
     'causal-async-stacks': [
       _boolValues,
-      _setSaneAsyncStacks,
+      _setCausalAsyncStacks,
       (debugger, _) => debugger.saneAsyncStacks
     ],
+    'awaiter-stacks': [
+      _boolValues,
+      _setAwaiterStacks,
+      (debugger, _) => debugger.awaiterStacks
+    ]
   };
 
   static Future _setBreakOnException(debugger, name, value) async {
     var result = await debugger.isolate.setExceptionPauseMode(value);
     if (result.isError) {
       debugger.console.print(result.toString());
     } else {
       // Printing will occur elsewhere.
       debugger.breakOnException = value;
     }
   }
 
   static Future _setUpIsDown(debugger, name, value) async {
     if (value == 'true') {
       debugger.upIsDown = true;
     } else {
       debugger.upIsDown = false;
     }
     debugger.console.print('${name} = ${value}');
   }
 
-  static Future _setSaneAsyncStacks(debugger, name, value) async {
+  static Future _setCausalAsyncStacks(debugger, name, value) async {
     if (value == 'true') {
-      debugger.saneAsyncStacks = true;
+      debugger.causalAsyncStacks = true;
     } else {
-      debugger.saneAsyncStacks = false;
+      debugger.causalAsyncStacks = false;
     }
     debugger.refreshStack();
     debugger.console.print('${name} = ${value}');
   }
 
+  static Future _setAwaiterStacks(debugger, name, value) async {
+    debugger.awaiterStacks = (value == 'true');
+    debugger.refreshStack();
+    debugger.console.print('${name} == ${value}');
+  }
+
   Future run(List<String> args) async {
     if (args.length == 0) {
       for (var name in _options.keys) {
         var getHandler = _options[name][2];
         var value = await getHandler(debugger, name);
         debugger.console.print("${name} = ${value}");
       }
     } else if (args.length == 1) {
       var name = args[0].trim();
       var optionInfo = _options[name];
@@ skipping 709 matching lines @@
   int _currentFrame = null;
 
   bool get upIsDown => _upIsDown;
   void set upIsDown(bool value) {
     settings.set('up-is-down', value);
     _upIsDown = value;
   }
 
   bool _upIsDown;
 
-  bool get saneAsyncStacks => _saneAsyncStacks;
-  void set saneAsyncStacks(bool value) {
+  bool get causalAsyncStacks => _causalAsyncStacks;
+  void set causalAsyncStacks(bool value) {
     settings.set('causal-async-stacks', value);
-    _saneAsyncStacks = value;
+    _causalAsyncStacks = value;
   }
 
-  bool _saneAsyncStacks;
+  bool _causalAsyncStacks;
 
+  bool get awaiterStacks => _awaiterStacks;
+  void set awaiterStacks(bool value) {
+    settings.set('awaiter-stacks', value);
+    _causalAsyncStacks = value;
+  }
+
+  bool _awaiterStacks;
+
+  static const String kAwaiterStackFrames = 'awaiterFrames';
   static const String kAsyncCausalStackFrames = 'asyncCausalFrames';
   static const String kStackFrames = 'frames';
 
   void upFrame(int count) {
     if (_upIsDown) {
       currentFrame += count;
     } else {
       currentFrame -= count;
     }
   }
 
   void downFrame(int count) {
     if (_upIsDown) {
       currentFrame -= count;
     } else {
       currentFrame += count;
     }
   }
 
   int get stackDepth {
-    if (saneAsyncStacks) {
+    if (awaiterStacks) {
+      var awaiterStackFrames = stack[kAwaiterStackFrames];
+      if (awaiterStackFrames != null) {
+        return awaiterStackFrames.length;
+      }
+    }
+    if (causalAsyncStacks) {
       var asyncCausalStackFrames = stack[kAsyncCausalStackFrames];
-      var stackFrames = stack[kStackFrames];
-      if (asyncCausalStackFrames == null) {
-        // No causal frames.
-        return stackFrames.length;
+      if (asyncCausalStackFrames != null) {
+        return asyncCausalStackFrames.length;
       }
-      return asyncCausalStackFrames.length;
-    } else {
-      return stack[kStackFrames].length;
     }
+    return stack[kStackFrames].length;
   }
 
   List get stackFrames {
-    if (saneAsyncStacks) {
+    if (awaiterStacks) {
+      var awaiterStackFrames = stack[kAwaiterStackFrames];
+      if (awaiterStackFrames != null) {
+        return awaiterStackFrames;
+      }
+    }
+    if (causalAsyncStacks) {
       var asyncCausalStackFrames = stack[kAsyncCausalStackFrames];
-      var stackFrames = stack[kStackFrames];
-      if (asyncCausalStackFrames == null) {
-        // No causal frames.
-        return stackFrames ?? [];
+      if (asyncCausalStackFrames != null) {
+        return asyncCausalStackFrames;
       }
-      return asyncCausalStackFrames;
-    } else {
-      return stack[kStackFrames] ?? [];
     }
+    return stack[kStackFrames] ?? [];
   }
 
   static final _history = [''];
 
   ObservatoryDebugger(this.isolate) {
     _loadSettings();
     cmd = new RootCommand([
       new AsyncNextCommand(this),
       new BreakCommand(this),
       new ClearCommand(this),
@@ skipping 17 matching lines @@
       new StepCommand(this),
       new SyncNextCommand(this),
       new UpCommand(this),
       new VmCommand(this),
     ], _history);
     _consolePrinter = new _ConsoleStreamPrinter(this);
   }
 
   void _loadSettings() {
     _upIsDown = settings.get('up-is-down');
-    _saneAsyncStacks = settings.get('causal-async-stacks') ?? true;
+    _causalAsyncStacks = settings.get('causal-async-stacks') ?? true;
+    _awaiterStacks = settings.get('awaiter-stacks') ?? true;
   }
 
   S.VM get vm => page.app.vm;
 
   void init() {
     console.printBold('Debugging isolate isolate ${isolate.number} '
         '\'${isolate.name}\' ');
     console.printBold('Type \'h\' for help');
     // Wait a bit and if polymer still hasn't set up the isolate,
     // report this to the user.
@@ skipping 798 matching lines @@
     li.children.insert(0, messageElement);
 
     messageList.add(li);
   }
 
   ObservatoryApplication get app => ObservatoryApplication.app;
 
   void updateStackFrames(S.ServiceMap newStack) {
     List frameElements = _frameList.children;
     List newFrames;
-    if (_debugger.saneAsyncStacks &&
+    if (_debugger.awaiterStacks &&
+        (newStack[ObservatoryDebugger.kAwaiterStackFrames] != null)) {
+      newFrames = newStack[ObservatoryDebugger.kAwaiterStackFrames];
+    } else if (_debugger.causalAsyncStacks &&
         (newStack[ObservatoryDebugger.kAsyncCausalStackFrames] != null)) {
       newFrames = newStack[ObservatoryDebugger.kAsyncCausalStackFrames];
     } else {
       newFrames = newStack[ObservatoryDebugger.kStackFrames];
     }
 
     // Remove any frames whose functions don't match, starting from
     // bottom of stack.
     int oldPos = frameElements.length - 1;
     int newPos = newFrames.length - 1;
@@ skipping 1034 matching lines @@
   ..setAttribute('height', '24')
   ..children = [
     new PathElement()
       ..setAttribute(
           'd',
           'M11 17h2v-6h-2v6zm1-15C6.48 2 2 6.48 2 12s4.48 10 '
           '10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 '
           '0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zM11 '
           '9h2V7h-2v2z')
   ];