Track async causal stack traces

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 586 matching lines @@
     'break-on-exception': [
       _boeValues,
       _setBreakOnException,
       (debugger, _) => debugger.breakOnException
     ],
     'up-is-down': [
       _boolValues,
       _setUpIsDown,
       (debugger, _) => debugger.upIsDown
     ],
+    'sane-async-stacks': [

[rmacnak, 2017/02/08 18:34:18]

"causal" to match the vm flag

[Cutch, 2017/02/09 22:45:50]

Done.

+      _boolValues,
+      _setSaneAsyncStacks,
+      (debugger, _) => debugger.saneAsyncStacks
+    ],
   };
 
   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 {
+    if (value == 'true') {
+      debugger.saneAsyncStacks = true;
+    } else {
+      debugger.saneAsyncStacks = false;
+    }
+    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 736 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) {
+    settings.set('sane-async-stacks', value);
+    _saneAsyncStacks = value;
+  }
+
+  bool _saneAsyncStacks;
+
+  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 => stack['frames'].length;
+  int get stackDepth {
+    if (saneAsyncStacks) {
+      var asyncCausalStackFrames = stack[kAsyncCausalStackFrames];
+      var stackFrames = stack[kStackFrames];
+      if (asyncCausalStackFrames == null) {
+        // No causal frames.
+        return stackFrames.length;
+      }
+      return asyncCausalStackFrames.length;
+    } else {
+      return stack[kStackFrames].length;
+    }
+  }
+
+  List get stackFrames {
+    if (saneAsyncStacks) {
+      var asyncCausalStackFrames = stack[kAsyncCausalStackFrames];
+      var stackFrames = stack[kStackFrames];
+      if (asyncCausalStackFrames == null) {
+        // No causal frames.
+        return stackFrames ?? [];
+      }
+      return asyncCausalStackFrames;
+    } else {
+      return stack[kStackFrames] ?? [];
+    }
+  }
 
   static final _history = [''];
 
   ObservatoryDebugger(this.isolate) {
     _loadSettings();
     cmd = new RootCommand([
       new AsyncNextCommand(this),
       new BreakCommand(this),
       new ClearCommand(this),
       new ClsCommand(this),
@@ skipping 16 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('sane-async-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 803 matching lines @@
     li.classes.add('list-group-item');
     li.children.insert(0, messageElement);
 
     messageList.add(li);
   }
 
   ObservatoryApplication get app => ObservatoryApplication.app;
 
   void updateStackFrames(S.ServiceMap newStack) {
     List frameElements = _frameList.children;
-    List newFrames = newStack['frames'];
+    List newFrames;
+    if (_debugger.saneAsyncStacks &&
+        (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;
     while (oldPos >= 0 && newPos >= 0) {
       if (!frameElements[oldPos].children[0].matchFrame(newFrames[newPos])) {
         // The rest of the frame elements no longer match.  Remove them.
         for (int i = 0; i <= oldPos; i++) {
           // NOTE(turnidge): removeRange is missing, sadly.
@@ skipping 107 matching lines @@
 
   // Is this the current frame?
   bool _current = false;
 
   // Has this frame been pinned open?
   bool _pinned = false;
 
   bool _expanded = false;
 
   void setCurrent(bool value) {
-    _frame.function.load().then((func) {
+    Future load =
+        (_frame.function != null) ?
+        _frame.function.load() :
+        new Future.value(null);
+    load.then((func) {
       _current = value;
       if (_current) {
         _expand();
         scrollIntoView();
       } else {
         if (_pinned) {
           _expand();
         } else {
           _unexpand();
         }
@@ skipping 32 matching lines @@
     if (_pinned) {
       classes.add('shadow');
     } else {
       classes.remove('shadow');
     }
     if (_current) {
       classes.add('current');
     } else {
       classes.remove('current');
     }
+    if ((_frame.kind == M.FrameKind.asyncSuspensionMarker) ||
+        (_frame.kind == M.FrameKind.asyncCausal)) {
+      classes.add('causalFrame');
+    }
+    if (_frame.kind == M.FrameKind.asyncSuspensionMarker) {
+      final content = <Element>[
+        new SpanElement()
+          ..children = _createMarkerHeader(_frame.marker)
+      ];
+      children = content;
+      return;
+    }
     ButtonElement expandButton;
     final content = <Element>[
       expandButton = new ButtonElement()
         ..children = _createHeader()
         ..onClick.listen((e) async {
           if (e.target is AnchorElement) {
             return;
           }
           expandButton.disabled = true;
           await _toggleExpand();
@@ skipping 82 matching lines @@
                     collapseButton.disabled = false;
                   })
                   ..children = [iconExpandLess.clone(true)]
               ]
           ]
       ]);
     }
     children = content;
   }
 
+  List<Element> _createMarkerHeader(String marker) {
+    final content = [
+      new DivElement()
+        ..classes = ['frameSummaryText']
+        ..children = [
+          new DivElement()
+            ..classes = ['frameId']
+            ..text = 'Frame ${_frame.index}',
+          new SpanElement()..text = '$marker',
+        ]
+    ];
+    return [
+      new DivElement()
+        ..classes = ['frameSummary']
+        ..children = content
+      ];
+  }
+
   List<Element> _createHeader() {
     final content = [
       new DivElement()
         ..classes = ['frameSummaryText']
         ..children = [
           new DivElement()
             ..classes = ['frameId']
             ..text = 'Frame ${_frame.index}',
           new SpanElement()
             ..children = _frame.function == null
@@ skipping 24 matching lines @@
         ..classes = ['frameSummary']
         ..children = content
     ];
   }
 
   String makeExpandKey(String key) {
     return '${_frame.function.qualifiedName}/${key}';
   }
 
   bool matchFrame(S.Frame newFrame) {
+    if (newFrame.kind != _frame.kind) {
+      return false;
+    }
+    if (newFrame.function == null) {
+      return frame.function == null;
+    }
     return (newFrame.function.id == _frame.function.id &&
             newFrame.location.script.id ==
             frame.location.script.id);
   }
 
   void updateFrame(S.Frame newFrame) {
     assert(matchFrame(newFrame));
     _frame = newFrame;
   }
 
@@ skipping 666 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')
   ];