DevTools: make all timeline trace events use 0-based line numbers

third_party/WebKit/Source/devtools/front_end/timeline_model/TimelineModel.js

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 813 matching lines @@
         var eventStack = this._eventStack;
         while (eventStack.length && eventStack.peekLast().endTime <= event.startTime)
             eventStack.pop();
 
         var recordTypes = WebInspector.TimelineModel.RecordType;
 
         if (this._currentScriptEvent && event.startTime > this._currentScriptEvent.endTime)
             this._currentScriptEvent = null;
 
         var eventData = event.args["data"] || event.args["beginData"] || {};
-        if (eventData && eventData["stackTrace"])
+        if (eventData["stackTrace"])
             event.stackTrace = eventData["stackTrace"];
+        if (event.stackTrace && event.name !== recordTypes.JSSample) {
+            // TraceEvents come with 1-based line & column numbers. The frontend code
+            // requires 0-based ones. Adjust the values.
+            for (var i = 0; i < event.stackTrace.length; ++i) {
+                --event.stackTrace[i].lineNumber;
+                --event.stackTrace[i].columnNumber;
+            }
+        }
 
         if (eventStack.length && eventStack.peekLast().name === recordTypes.EventDispatch)
             eventStack.peekLast().hasChildren = true;
         this._asyncEventTracker.processEvent(event);
         if (event.initiator && event.initiator.url)
             event.url = event.initiator.url;
         switch (event.name) {
         case recordTypes.ResourceSendRequest:
         case recordTypes.WebSocketCreate:
-            event.url = event.args["data"]["url"];
+            event.url = eventData["url"];
             event.initiator = eventStack.peekLast() || null;
             break;
 
         case recordTypes.ScheduleStyleRecalculation:
-            this._lastScheduleStyleRecalculation[event.args["data"]["frame"]] = event;
+            this._lastScheduleStyleRecalculation[eventData["frame"]] = event;
             break;
 
         case recordTypes.UpdateLayoutTree:
         case recordTypes.RecalculateStyles:
             this._invalidationTracker.didRecalcStyle(event);
             if (event.args["beginData"])
                 event.initiator = this._lastScheduleStyleRecalculation[event.args["beginData"]["frame"]];
             this._lastRecalculateStylesEvent = event;
             if (this._currentScriptEvent)
                 event.warning = WebInspector.TimelineModel.WarningType.ForcedStyle;
             break;
 
         case recordTypes.ScheduleStyleInvalidationTracking:
         case recordTypes.StyleRecalcInvalidationTracking:
         case recordTypes.StyleInvalidatorInvalidationTracking:
         case recordTypes.LayoutInvalidationTracking:
         case recordTypes.LayerInvalidationTracking:
         case recordTypes.PaintInvalidationTracking:
         case recordTypes.ScrollInvalidationTracking:
             this._invalidationTracker.addInvalidation(new WebInspector.InvalidationTrackingEvent(event));
             break;
 
         case recordTypes.InvalidateLayout:
             // Consider style recalculation as a reason for layout invalidation,
             // but only if we had no earlier layout invalidation records.
             var layoutInitator = event;
-            var frameId = event.args["data"]["frame"];
+            var frameId = eventData["frame"];
             if (!this._layoutInvalidate[frameId] && this._lastRecalculateStylesEvent && this._lastRecalculateStylesEvent.endTime >  event.startTime)
                 layoutInitator = this._lastRecalculateStylesEvent.initiator;
             this._layoutInvalidate[frameId] = layoutInitator;
             break;
 
         case recordTypes.Layout:
             this._invalidationTracker.didLayout(event);
             var frameId = event.args["beginData"]["frame"];
             event.initiator = this._layoutInvalidate[frameId];
             // In case we have no closing Layout event, endData is not available.
             if (event.args["endData"]) {
                 event.backendNodeId = event.args["endData"]["rootNode"];
                 event.highlightQuad =  event.args["endData"]["root"];
             }
             this._layoutInvalidate[frameId] = null;
             if (this._currentScriptEvent)
                 event.warning = WebInspector.TimelineModel.WarningType.ForcedLayout;
             break;
 
+        case recordTypes.FunctionCall:
+            // Compatibility with old format.
+            if (typeof eventData["scriptName"] === "string")
+                eventData["url"] = eventData["scriptName"];
+            if (typeof eventData["scriptLine"] === "number")
+                eventData["lineNumber"] = eventData["scriptLine"];

[caseq, 2016/07/21 23:04:17]

nit: // Fall-through intended.

[alph, 2016/07/21 23:35:23]

Done.

         case recordTypes.EvaluateScript:
-        case recordTypes.FunctionCall:
+        case recordTypes.CompileScript:
+            if (typeof eventData["lineNumber"] === "number")
+                --eventData["lineNumber"];
+            if (typeof eventData["columnNumber"] === "number")
+                --eventData["columnNumber"];
             if (!this._currentScriptEvent)
                 this._currentScriptEvent = event;

[caseq, 2016/07/21 23:04:17]

do we want this for CompileScript as well?

[alph, 2016/07/21 23:35:23]

It's usually a nested event. So this code never executed for CompileScript.

             break;
 
         case recordTypes.SetLayerTreeId:
             this._inspectedTargetLayerTreeId = event.args["layerTreeId"] || event.args["data"]["layerTreeId"];
             break;
 
         case recordTypes.Paint:
             this._invalidationTracker.didPaint(event);
-            event.highlightQuad = event.args["data"]["clip"];
-            event.backendNodeId = event.args["data"]["nodeId"];
+            event.highlightQuad = eventData["clip"];
+            event.backendNodeId = eventData["nodeId"];
             // Only keep layer paint events, skip paints for subframes that get painted to the same layer as parent.
-            if (!event.args["data"]["layerId"])
+            if (!eventData["layerId"])
                 break;
-            var layerId = event.args["data"]["layerId"];
+            var layerId = eventData["layerId"];
             this._lastPaintForLayer[layerId] = event;
             break;
 
         case recordTypes.DisplayItemListSnapshot:
         case recordTypes.PictureSnapshot:
             var layerUpdateEvent = this._findAncestorEvent(recordTypes.UpdateLayer);
             if (!layerUpdateEvent || layerUpdateEvent.args["layerTreeId"] !== this._inspectedTargetLayerTreeId)
                 break;
             var paintEvent = this._lastPaintForLayer[layerUpdateEvent.args["layerId"]];
             if (paintEvent)
                 paintEvent.picture = event;
             break;
 
         case recordTypes.ScrollLayer:
-            event.backendNodeId = event.args["data"]["nodeId"];
+            event.backendNodeId = eventData["nodeId"];
             break;
 
         case recordTypes.PaintImage:
-            event.backendNodeId = event.args["data"]["nodeId"];
-            event.url = event.args["data"]["url"];
+            event.backendNodeId = eventData["nodeId"];
+            event.url = eventData["url"];
             break;
 
         case recordTypes.DecodeImage:
         case recordTypes.ResizeImage:
             var paintImageEvent = this._findAncestorEvent(recordTypes.PaintImage);
             if (!paintImageEvent) {
                 var decodeLazyPixelRefEvent = this._findAncestorEvent(recordTypes.DecodeLazyPixelRef);
                 paintImageEvent = decodeLazyPixelRefEvent && this._paintImageEventByPixelRefId[decodeLazyPixelRefEvent.args["LazyPixelRef"]];
             }
             if (!paintImageEvent)
@@ skipping 495 matching lines @@
     /** @type {?Array.<!Object.<string, number>>} */
     this.invalidationList = eventData["invalidationList"];
     /** @type {!WebInspector.InvalidationCause} */
     this.cause = {reason: eventData["reason"], stackTrace: eventData["stackTrace"]};
 
     // FIXME: Move this to TimelineUIUtils.js.
     if (!this.cause.reason && this.cause.stackTrace && this.type === WebInspector.TimelineModel.RecordType.LayoutInvalidationTracking)
         this.cause.reason = "Layout forced";
 }
 
-/** @typedef {{reason: string, stackTrace: ?Array.<!RuntimeAgent.CallFrame>}} */
+/** @typedef {{reason: string, stackTrace: ?Array<!RuntimeAgent.CallFrame>}} */
 WebInspector.InvalidationCause;
 
 /**
  * @constructor
  */
 WebInspector.InvalidationTracker = function()
 {
     this._initializePerFrameState();
 }
 
@@ skipping 298 matching lines @@
         if (!id)
             return;
         /** @type {!Map<string, !WebInspector.TracingModel.Event>|undefined} */
         var initiatorMap = this._initiatorByType.get(initiatorType);
         if (isInitiator)
             initiatorMap.set(id, event);
         else
             event.initiator = initiatorMap.get(id) || null;
     }
 }