DevTools: merge ScriptCallStack and ScriptAsyncCallStack, move CallStacks from console to Runtime.

third_party/WebKit/Source/devtools/front_end/timeline/TimelineJSProfile.js

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 
 WebInspector.TimelineJSProfileProcessor = { };
 
 /**
  * @param {!ProfilerAgent.CPUProfile} jsProfile
  * @param {!WebInspector.TracingModel.Thread} thread
  * @return {!Array<!WebInspector.TracingModel.Event>}
  */
 WebInspector.TimelineJSProfileProcessor.generateTracingEventsFromCpuProfile = function(jsProfile, thread)
 {
     if (!jsProfile.samples)
         return [];
     var jsProfileModel = new WebInspector.CPUProfileDataModel(jsProfile);
     var idleNode = jsProfileModel.idleNode;
     var programNode = jsProfileModel.programNode;
     var gcNode = jsProfileModel.gcNode;
     var samples = jsProfileModel.samples;
     var timestamps = jsProfileModel.timestamps;
     var jsEvents = [];
-    /** @type {!Map<!Object, !ConsoleAgent.StackTrace>} */
+    /** @type {!Map<!Object, !Array<!RuntimeAgent.CallFrame>>} */
     var nodeToStackMap = new Map();
     nodeToStackMap.set(programNode, []);
     for (var i = 0; i < samples.length; ++i) {
         var node = jsProfileModel.nodeByIndex(i);
         if (node === gcNode || node === idleNode)
             continue;
-        var stackTrace = nodeToStackMap.get(node);
-        if (!stackTrace) {
-            stackTrace = /** @type {!ConsoleAgent.StackTrace} */ (new Array(node.depth + 1));
-            nodeToStackMap.set(node, stackTrace);
+        var callFrames = nodeToStackMap.get(node);
+        if (!callFrames) {
+            callFrames = /** @type {!Array<!RuntimeAgent.CallFrame>} */ (new Array(node.depth + 1));
+            nodeToStackMap.set(node, callFrames);
             for (var j = 0; node.parent; node = node.parent)
-                stackTrace[j++] = /** @type {!ConsoleAgent.CallFrame} */ (node);
+                callFrames[j++] = /** @type {!RuntimeAgent.CallFrame} */ (node);
         }
         var jsSampleEvent = new WebInspector.TracingModel.Event(WebInspector.TracingModel.DevToolsTimelineEventCategory,
             WebInspector.TimelineModel.RecordType.JSSample,
             WebInspector.TracingModel.Phase.Instant, timestamps[i], thread);
-        jsSampleEvent.args["data"] = { stackTrace: stackTrace };
+        jsSampleEvent.args["data"] = { stackTrace: callFrames };
         jsEvents.push(jsSampleEvent);
     }
     return jsEvents;
 }
 
 /**
  * @param {!Array<!WebInspector.TracingModel.Event>} events
  * @return {!Array<!WebInspector.TracingModel.Event>}
  */
 WebInspector.TimelineJSProfileProcessor.generateJSFrameEvents = function(events)
 {
     /**
-     * @param {!ConsoleAgent.CallFrame} frame1
-     * @param {!ConsoleAgent.CallFrame} frame2
+     * @param {!RuntimeAgent.CallFrame} frame1
+     * @param {!RuntimeAgent.CallFrame} frame2
      * @return {boolean}
      */
     function equalFrames(frame1, frame2)
     {
         return frame1.scriptId === frame2.scriptId && frame1.functionName === frame2.functionName;
     }
 
     /**
      * @param {!WebInspector.TracingModel.Event} e
      * @return {number}
@@ skipping 93 matching lines @@
         }
         var minFrameDurationMs = currentSamplingIntervalMs / 2;
         for (var k = 0; k < depth; ++k)
             jsFramesStack[k].setEndTime(time);
         for (var k = depth; k < jsFramesStack.length; ++k)
             jsFramesStack[k].setEndTime(Math.min(eventEndTime(jsFramesStack[k]) + minFrameDurationMs, time));
         jsFramesStack.length = depth;
     }
 
     /**
-     * @param {!Array<!ConsoleAgent.CallFrame>} stack
+     * @param {!Array<!RuntimeAgent.CallFrame>} stack
      */
     function filterStackFrames(stack)
     {
         for (var i = 0, j = 0; i < stack.length; ++i) {
             var url = stack[i].url;
             if (url && url.startsWith("native "))
                 continue;
             stack[j++] = stack[i];
         }
         stack.length = j;
     }
 
     /**
      * @param {!WebInspector.TracingModel.Event} e
      */
     function extractStackTrace(e)
     {
         var recordTypes = WebInspector.TimelineModel.RecordType;
-        var stackTrace;
+        var callFrames;
         if (e.name === recordTypes.JSSample) {
             var eventData = e.args["data"] || e.args["beginData"];
-            stackTrace = /** @type {!Array<!ConsoleAgent.CallFrame>} */ (eventData && eventData["stackTrace"]);
+            callFrames = /** @type {!Array<!RuntimeAgent.CallFrame>} */ (eventData && eventData["stackTrace"]);
         } else {
-            stackTrace = /** @type {!Array<!ConsoleAgent.CallFrame>} */ (jsFramesStack.map(frameEvent => frameEvent.args["data"]).reverse());
+            callFrames = /** @type {!Array<!RuntimeAgent.CallFrame>} */ (jsFramesStack.map(frameEvent => frameEvent.args["data"]).reverse());
         }
         if (filterNativeFunctions)
-            filterStackFrames(stackTrace);
+            filterStackFrames(callFrames);
         var endTime = eventEndTime(e);
-        var numFrames = stackTrace.length;
+        var numFrames = callFrames.length;
         var minFrames = Math.min(numFrames, jsFramesStack.length);
         var i;
         for (i = lockedJsStackDepth.peekLast() || 0; i < minFrames; ++i) {
-            var newFrame = stackTrace[numFrames - 1 - i];
+            var newFrame = callFrames[numFrames - 1 - i];
             var oldFrame = jsFramesStack[i].args["data"];
             if (!equalFrames(newFrame, oldFrame))
                 break;
             jsFramesStack[i].setEndTime(Math.max(jsFramesStack[i].endTime, endTime));
         }
         truncateJSStack(i, e.startTime);
         for (; i < numFrames; ++i) {
-            var frame = stackTrace[numFrames - 1 - i];
+            var frame = callFrames[numFrames - 1 - i];
             var jsFrameEvent = new WebInspector.TracingModel.Event(WebInspector.TracingModel.DevToolsTimelineEventCategory, recordTypes.JSFrame,
                 WebInspector.TracingModel.Phase.Complete, e.startTime, e.thread);
             jsFrameEvent.ordinal = e.ordinal;
             jsFrameEvent.addArgs({ data: frame });
             jsFrameEvent.setEndTime(endTime);
             jsFramesStack.push(jsFrameEvent);
             jsFrameEvents.push(jsFrameEvent);
         }
     }
 
@@ skipping 22 matching lines @@
 WebInspector.TimelineJSProfileProcessor.CodeMap = function()
 {
     /** @type {!Map<string, !WebInspector.TimelineJSProfileProcessor.CodeMap.Bank>} */
     this._banks = new Map();
 }
 
 /**
  * @constructor
  * @param {number} address
  * @param {number} size
- * @param {!ConsoleAgent.CallFrame} callFrame
+ * @param {!RuntimeAgent.CallFrame} callFrame
  */
 WebInspector.TimelineJSProfileProcessor.CodeMap.Entry = function(address, size, callFrame)
 {
     this.address = address;
     this.size = size;
     this.callFrame = callFrame;
 }
 
 /**
  * @param {number} address
  * @param {!WebInspector.TimelineJSProfileProcessor.CodeMap.Entry} entry
  * @return {number}
  */
 WebInspector.TimelineJSProfileProcessor.CodeMap.comparator = function(address, entry)
 {
     return address - entry.address;
 }
 
 WebInspector.TimelineJSProfileProcessor.CodeMap.prototype = {
     /**
      * @param {string} addressHex
      * @param {number} size
-     * @param {!ConsoleAgent.CallFrame} callFrame
+     * @param {!RuntimeAgent.CallFrame} callFrame
      */
     addEntry: function(addressHex, size, callFrame)
     {
         var entry = new WebInspector.TimelineJSProfileProcessor.CodeMap.Entry(this._getAddress(addressHex), size, callFrame);
         this._addEntry(addressHex, entry);
     },
 
     /**
      * @param {string} oldAddressHex
      * @param {string} newAddressHex
      * @param {number} size
      */
     moveEntry: function(oldAddressHex, newAddressHex, size)
     {
         var entry = this._getBank(oldAddressHex).removeEntry(this._getAddress(oldAddressHex));
         if (!entry) {
             console.error("Entry at address " + oldAddressHex + " not found");
             return;
         }
         entry.address = this._getAddress(newAddressHex);
         entry.size = size;
         this._addEntry(newAddressHex, entry);
     },
 
     /**
      * @param {string} addressHex
-     * @return {?ConsoleAgent.CallFrame}
+     * @return {?RuntimeAgent.CallFrame}
      */
     lookupEntry: function(addressHex)
     {
         return this._getBank(addressHex).lookupEntry(this._getAddress(addressHex));
     },
 
     /**
      * @param {string} addressHex
      * @param {!WebInspector.TimelineJSProfileProcessor.CodeMap.Entry} entry
      */
@@ skipping 54 matching lines @@
         var index = this._entries.lowerBound(address, WebInspector.TimelineJSProfileProcessor.CodeMap.comparator);
         var entry = this._entries[index];
         if (!entry || entry.address !== address)
             return null;
         this._entries.splice(index, 1);
         return entry;
     },
 
     /**
      * @param {number} address
-     * @return {?ConsoleAgent.CallFrame}
+     * @return {?RuntimeAgent.CallFrame}
      */
     lookupEntry: function(address)
     {
         var index = this._entries.upperBound(address, WebInspector.TimelineJSProfileProcessor.CodeMap.comparator) - 1;
         var entry = this._entries[index];
         return entry && address < entry.address + entry.size ? entry.callFrame : null;
     },
 
     /**
      * @param {!WebInspector.TimelineJSProfileProcessor.CodeMap.Entry} newEntry
@@ skipping 10 matching lines @@
                 break;
         }
         ++index;
         this._entries.splice(index, lastIndex - index, newEntry);
     }
 }
 
 /**
  * @param {string} name
  * @param {number} scriptId
- * @return {!ConsoleAgent.CallFrame}
+ * @return {!RuntimeAgent.CallFrame}
  */
 WebInspector.TimelineJSProfileProcessor._buildCallFrame = function(name, scriptId)
 {
     /**
      * @param {string} functionName
      * @param {string=} url
      * @param {string=} scriptId
      * @param {number=} line
      * @param {number=} column
      * @param {boolean=} isNative
-     * @return {!ConsoleAgent.CallFrame}
+     * @return {!RuntimeAgent.CallFrame}
      */
     function createFrame(functionName, url, scriptId, line, column, isNative)
     {
-        return /** @type {!ConsoleAgent.CallFrame} */ ({
+        return /** @type {!RuntimeAgent.CallFrame} */ ({
             "functionName": functionName,
             "url": url || "",
             "scriptId": scriptId || "0",
             "lineNumber": line || 0,
             "columnNumber": column || 0,
             "isNative": isNative || false
         });
     }
 
     // Code states:
@@ skipping 27 matching lines @@
 /**
  * @param {!Array<!WebInspector.TracingModel.Event>} events
  * @return {!Array<!WebInspector.TracingModel.Event>}
  */
 WebInspector.TimelineJSProfileProcessor.processRawV8Samples = function(events)
 {
     var missingAddesses = new Set();
 
     /**
      * @param {string} address
-     * @return {?ConsoleAgent.CallFrame}
+     * @return {?RuntimeAgent.CallFrame}
      */
     function convertRawFrame(address)
     {
         var entry = codeMap.lookupEntry(address);
         if (entry)
             return entry.isNative ? null : entry;
         if (!missingAddesses.has(address)) {
             missingAddesses.add(address);
             console.error("Address " + address + " has missing code entry");
         }
@@ skipping 28 matching lines @@
                 WebInspector.TracingModel.Phase.Instant, e.startTime, e.thread);
             sampleEvent.ordinal = e.ordinal;
             sampleEvent.args = {"data": {"stackTrace": stack }};
             samples.push(sampleEvent);
             break;
         }
     }
 
     return samples;
 }