Switch to using SourceLocation universally in service protocol.

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:html';
 import 'observatory_element.dart';
 import 'package:observatory/app.dart';
@@ skipping 357 matching lines @@
 
 class BreakCommand extends DebuggerCommand {
   BreakCommand(Debugger debugger) : super(debugger, 'break', []);
 
   Future run(List<String> args) async {
     if (args.length > 1) {
       debugger.console.print('not implemented');
       return new Future.value(null);
     }
     var arg = (args.length == 0 ? '' : args[0]);
-    var loc = await SourceLocation.parse(debugger, arg);
+    var loc = await DebuggerLocation.parse(debugger, arg);
     if (loc.valid) {
       if (loc.function != null) {
         try {
           await debugger.isolate.addBreakpointAtEntry(loc.function);
         } on ServerRpcException catch(e) {
           if (e.code == ServerRpcException.kCannotAddBreakpoint) {
             debugger.console.print('Unable to set breakpoint at ${loc}');
           } else {
             rethrow;
           }
@@ skipping 18 matching lines @@
       }
     } else {
       debugger.console.print(loc.errorMessage);
     }
   }
 
   Future<List<String>> complete(List<String> args) {
     if (args.length != 1) {
       return new Future.value([args.join('')]);
     }
-    // TODO - fix SourceLocation complete
-    return new Future.value(SourceLocation.complete(debugger, args[0]));
+    // TODO - fix DebuggerLocation complete
+    return new Future.value(DebuggerLocation.complete(debugger, args[0]));
   }
 
   String helpShort = 'Add a breakpoint by source location or function name';
 
   String helpLong =
       'Add a breakpoint by source location or function name.\n'
       '\n'
       'Syntax: break                       '
       '- Break at the current position\n'
       '        break <line>                '
@@ skipping 20 matching lines @@
 
 class ClearCommand extends DebuggerCommand {
   ClearCommand(Debugger debugger) : super(debugger, 'clear', []);
 
   Future run(List<String> args) {
     if (args.length > 1) {
       debugger.console.print('not implemented');
       return new Future.value(null);
     }
     var arg = (args.length == 0 ? '' : args[0]);
-    return SourceLocation.parse(debugger, arg).then((loc) {
+    return DebuggerLocation.parse(debugger, arg).then((loc) {
       if (loc.valid) {
         if (loc.function != null) {
           debugger.console.print(
               'Ignoring breakpoint at $loc: '
               'Function entry breakpoints not yet implemented');
           return null;
         }
         if (loc.col != null) {
           // TODO(turnidge): Add tokenPos clear support.
           debugger.console.print(
               'Ignoring column: '
               'clearing breakpoint at a specific column not yet implemented');
         }
 
         for (var bpt in debugger.isolate.breakpoints.values) {
-          var script = bpt.script;
+          var script = bpt.location.script;
           if (script.id == loc.script.id) {
             assert(script.loaded);
-            var line = script.tokenToLine(bpt.tokenPos);
+            var line = script.tokenToLine(bpt.location.tokenPos);
             if (line == loc.line) {
               return debugger.isolate.removeBreakpoint(bpt).then((result) {
                 if (result is DartError) {
                   debugger.console.print(
                       'Unable to clear breakpoint at ${loc}: ${result.message}');
                   return;
                 }
               });
             }
           }
         }
         debugger.console.print('No breakpoint found at ${loc}');
       } else {
         debugger.console.print(loc.errorMessage);
       }
     });
   }
 
   Future<List<String>> complete(List<String> args) {
     if (args.length != 1) {
       return new Future.value([args.join('')]);
     }
-    return new Future.value(SourceLocation.complete(debugger, args[0]));
+    return new Future.value(DebuggerLocation.complete(debugger, args[0]));
   }
 
   String helpShort = 'Remove a breakpoint by source location or function name';
 
   String helpLong =
       'Remove a breakpoint by source location or function name.\n'
       '\n'
       'Syntax: clear                       '
       '- Clear at the current position\n'
       '        clear <line>                '
@@ skipping 64 matching lines @@
       : super(debugger, 'breakpoints', []);
 
   Future run(List<String> args) {
     if (debugger.isolate.breakpoints.isEmpty) {
       debugger.console.print('No breakpoints');
     }
     List bpts = debugger.isolate.breakpoints.values.toList();
     bpts.sort((a, b) => a.number - b.number);
     for (var bpt in bpts) {
       var bpId = bpt.number;
-      var script = bpt.script;
-      var tokenPos = bpt.tokenPos;
+      var script = bpt.location.script;
+      var tokenPos = bpt.location.tokenPos;
       var line = script.tokenToLine(tokenPos);
       var col = script.tokenToCol(tokenPos);
       if (!bpt.resolved) {
         debugger.console.print(
             'Future breakpoint ${bpId} at ${script.name}:${line}:${col}');
       } else {
         debugger.console.print(
             'Breakpoint ${bpId} at ${script.name}:${line}:${col}');
       }
     }
@@ skipping 377 matching lines @@
 
   void _reportPause(ServiceEvent event) {
     if (event.kind == ServiceEvent.kPauseStart) {
       console.print(
           "Paused at isolate start (type 'continue' to start the isolate')");
     } else if (event.kind == ServiceEvent.kPauseExit) {
       console.print(
           "Paused at isolate exit (type 'continue' to exit the isolate')");
     }
     if (stack['frames'].length > 0) {
-      var frame = stack['frames'][0];
-      var script = frame['script'];
+      Frame frame = stack['frames'][0];
+      var script = frame.location.script;
       script.load().then((_) {
-        var line = script.tokenToLine(frame['tokenPos']);
-        var col = script.tokenToCol(frame['tokenPos']);
+        var line = script.tokenToLine(frame.location.tokenPos);
+        var col = script.tokenToCol(frame.location.tokenPos);
         if (event.breakpoint != null) {
           var bpId = event.breakpoint.number;
           console.print('Paused at breakpoint ${bpId} at '
                         '${script.name}:${line}:${col}');
         } else if (event.exception != null) {
           // TODO(turnidge): Test this.
           console.print('Paused due to exception ${event.exception} at '
                         '${script.name}:${line}:${col}');
         } else {
           console.print('Paused at ${script.name}:${line}:${col}');
@@ skipping 11 matching lines @@
         break;
       case ServiceEvent.kBreakpointResolved:
         verb = 'resolved';
         break;
       case ServiceEvent.kBreakpointRemoved:
         verb = 'removed';
         break;
       default:
         break;
     }
-    var script = bpt.script;
+    var script = bpt.location.script;
     return script.load().then((_) {
       var bpId = bpt.number;
-      var tokenPos = bpt.tokenPos;
+      var tokenPos = bpt.location.tokenPos;
       var line = script.tokenToLine(tokenPos);
       var col = script.tokenToCol(tokenPos);
       if (bpt.resolved) {
         console.print(
             'Breakpoint ${bpId} ${verb} at ${script.name}:${line}:${col}');
       } else {
         console.print(
             'Future breakpoint ${bpId} ${verb} at ${script.name}:${line}:${col}');
       }
     });
@@ skipping 184 matching lines @@
 
 @CustomTag('debugger-stack')
 class DebuggerStackElement extends ObservatoryElement {
   @published Isolate isolate;
   @observable bool hasStack = false;
   @observable bool hasMessages = false;
   @observable bool isSampled = false;
   @observable int currentFrame;
   ObservatoryDebugger debugger;
 
-  _addFrame(List frameList, ObservableMap frameInfo) {
+  _addFrame(List frameList, Frame frameInfo) {
     DebuggerFrameElement frameElement = new Element.tag('debugger-frame');
     frameElement.frame = frameInfo;
 
-    if (frameInfo['index'] == currentFrame) {
+    if (frameInfo.index == currentFrame) {
       frameElement.setCurrent(true);
     } else {
       frameElement.setCurrent(false);
     }
 
     var li = new LIElement();
     li.classes.add('list-group-item');
     li.children.insert(0, frameElement);
 
     frameList.insert(0, li);
   }
 
-  _addMessage(List messageList, ServiceMap messageInfo) {
+  _addMessage(List messageList, ServiceMessage messageInfo) {
     DebuggerMessageElement messageElement = new Element.tag('debugger-message');
     messageElement.message = messageInfo;
 
     var li = new LIElement();
     li.classes.add('list-group-item');
     li.children.insert(0, messageElement);
 
     messageList.add(li);
   }
 
@@ skipping 83 matching lines @@
     updateStackFrames(newStack);
     updateStackMessages(newStack);
     isSampled = pauseEvent == null;
   }
 
   void setCurrentFrame(int value) {
     currentFrame = value;
     List frameElements = $['frameList'].children;
     for (var frameElement in frameElements) {
       var dbgFrameElement = frameElement.children[0];
-      if (dbgFrameElement.frame['index'] == currentFrame) {
+      if (dbgFrameElement.frame.index == currentFrame) {
         dbgFrameElement.setCurrent(true);
       } else {
         dbgFrameElement.setCurrent(false);
       }
     }
   }
 
   Set<Script> activeScripts() {
     var s = new Set<Script>();
     List frameElements = $['frameList'].children;
@@ skipping 17 matching lines @@
     } else {
       return new Future.value(null);
     }
   }
 
   DebuggerStackElement.created() : super.created();
 }
 
 @CustomTag('debugger-frame')
 class DebuggerFrameElement extends ObservatoryElement {
-  @published ObservableMap frame;
+  @published Frame frame;
 
   // Is this the current frame?
   bool _current = false;
 
   // Has this frame been pinned open?
   bool _pinned = false;
 
   void setCurrent(bool value) {
     busy = true;
-    frame['function'].load().then((func) {
+    frame.function.load().then((func) {
       _current = value;
       var frameOuter = $['frameOuter'];
       if (_current) {
         frameOuter.classes.add('current');
         expanded = true;
         frameOuter.classes.add('shadow');
         scrollIntoView();
       } else {
         frameOuter.classes.remove('current');
         if (_pinned) {
           expanded = true;
           frameOuter.classes.add('shadow');
         } else {
           expanded = false;
           frameOuter.classes.remove('shadow');
         }
       }
       busy = false;
     });
   }
 
   @observable String scriptHeight;
   @observable bool expanded = false;
   @observable bool busy = false;
 
   DebuggerFrameElement.created() : super.created();
 
-  bool matchFrame(ObservableMap newFrame) {
-    return newFrame['function'].id == frame['function'].id;
+  bool matchFrame(Frame newFrame) {
+    return newFrame.function.id == frame.function.id;
   }
 
-  void updateFrame(ObservableMap newFrame) {
+  void updateFrame(Frame newFrame) {
     assert(matchFrame(newFrame));
-    frame['index'] = newFrame['index'];
-    frame['tokenPos'] = newFrame['tokenPos'];
-    frame['vars'] = newFrame['vars'];
+    frame = newFrame;
   }
 
-  Script get script => frame['script'];
+  Script get script => frame.location.script;
 
   @override
   void attached() {
     super.attached();
     int windowHeight = window.innerHeight;
     scriptHeight = '${windowHeight ~/ 1.6}px';
   }
 
   void toggleExpand(var a, var b, var c) {
     if (busy) {
       return;
     }
     busy = true;
-    frame['function'].load().then((func) {
+    frame.function.load().then((func) {
         _pinned = !_pinned;
         var frameOuter = $['frameOuter'];
         if (_pinned) {
           expanded = true;
           frameOuter.classes.add('shadow');
         } else {
           expanded = false;
           frameOuter.classes.remove('shadow');
         }
         busy = false;
       });
   }
 }
 
 @CustomTag('debugger-message')
 class DebuggerMessageElement extends ObservatoryElement {
-  @published ServiceMap message;
+  @published ServiceMessage message;
   @observable ServiceObject preview;
 
   // Is this the current message?
   bool _current = false;
 
   // Has this message been pinned open?
   bool _pinned = false;
 
   void setCurrent(bool value) {
     _current = value;
@@ skipping 14 matching lines @@
       }
     }
   }
 
   @observable String scriptHeight;
   @observable bool expanded = false;
   @observable bool busy = false;
 
   DebuggerMessageElement.created() : super.created();
 
-  void updateMessage(ServiceMap newMessage) {
+  void updateMessage(ServiceMessage newMessage) {
     bool messageChanged =
-        (message['messageObjectId'] != newMessage['messageObjectId']);
-    message['index'] = newMessage['index'];
-    message['handlerFunction'] = newMessage['handlerFunction'];
-    message['messageObjectId'] = newMessage['messageObjectId'];
+        (message.messageObjectId != newMessage.messageObjectId);
+    message = newMessage;
     if (messageChanged) {
       // Message object id has changed: clear preview and collapse.
       preview = null;
       if (expanded) {
         toggleExpand(null, null, null);
       }
     }
   }
 
   @override
   void attached() {
     super.attached();
     int windowHeight = window.innerHeight;
     scriptHeight = '${windowHeight ~/ 1.6}px';
   }
 
   void toggleExpand(var a, var b, var c) {
     if (busy) {
       return;
     }
     busy = true;
-    var function = message['handlerFunction'];
+    var function = message.handler;
     var loadedFunction;
     if (function == null) {
       // Complete immediately.
       loadedFunction = new Future.value(null);
     } else {
       loadedFunction = function.load();
     }
     loadedFunction.then((_) {
       _pinned = !_pinned;
       var messageOuter = $['messageOuter'];
       if (_pinned) {
         expanded = true;
         messageOuter.classes.add('shadow');
       } else {
         expanded = false;
         messageOuter.classes.remove('shadow');
       }
       busy = false;
     });
   }
 
   Future<ServiceObject> previewMessage(_) {
-    return message.isolate.getObject(message['messageObjectId']).then((result) {
+    return message.isolate.getObject(message.messageObjectId).then((result) {
       preview = result;
       return result;
     });
   }
 }
 
 @CustomTag('debugger-console')
 class DebuggerConsoleElement extends ObservatoryElement {
   @published Isolate isolate;
 
@@ skipping 103 matching lines @@
           default:
             busy = false;
             break;
         }
       });
   }
 
   DebuggerInputElement.created() : super.created();
 }