CPUFlameChart: remove unnecessary arrays and calculate colors on demand.

Source/devtools/front_end/CPUProfileView.js

 /*
  * Copyright (C) 2008 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 1113 matching lines @@
 
         var index = 0;
 
         var openIntervals = [];
         var stackTrace = [];
         var maxDepth = 5; // minimum stack depth for the case when we see no activity.
         var depth = 0;
 
         /**
          * @constructor
-         * @param {string} color
          * @param {number} depth
          * @param {number} duration
          * @param {number} startTime
          * @param {!Object} node
          */
-        function ChartEntry(color, depth, duration, startTime, node)
+        function ChartEntry(depth, duration, startTime, node)
         {
-            this.color = color;
             this.depth = depth;
             this.duration = duration;
             this.startTime = startTime;
             this.node = node;
             this.selfTime = 0;
         }
         var entries = /** @type {!Array.<!ChartEntry>} */ ([]);
 
         for (var sampleIndex = 0; sampleIndex < samplesCount; sampleIndex++) {
             var node = idToNode[samples[sampleIndex]];
@@ skipping 32 matching lines @@
             if (depth < openIntervals.length)
                 openIntervals.length = depth;
             if (!node) {
                 entries[intervalIndex].selfTime += samplingInterval;
                 continue;
             }
 
             var colorGenerator = this._colorGenerator;
             var color = "";
             while (node) {
-                color = colorGenerator.colorForID(node.functionName + ":" + node.url + ":" + node.lineNumber);
-                entries.push(new ChartEntry(color, depth, samplingInterval, sampleIndex * samplingInterval, node));
+                entries.push(new ChartEntry(depth, samplingInterval, sampleIndex * samplingInterval, node));
                 openIntervals.push({node: node, index: index});
                 ++index;
 
                 node = stackTrace.pop();
                 ++depth;
             }
             entries[entries.length - 1].selfTime += samplingInterval;
         }
 
-        var entryColors = new Array(entries.length);
         var entryNodes = new Array(entries.length);
         var entryLevels = new Uint8Array(entries.length);
         var entryTotalTimes = new Float32Array(entries.length);
         var entrySelfTimes = new Float32Array(entries.length);
         var entryOffsets = new Float32Array(entries.length);
-        var entryTitles = new Array(entries.length);
-        var entryDeoptFlags = new Uint8Array(entries.length);
 
         for (var i = 0; i < entries.length; ++i) {
             var entry = entries[i];
             entryNodes[i] = entry.node;
-            entryColors[i] = entry.color;
             entryLevels[i] = entry.depth;
             entryTotalTimes[i] = entry.duration;
             entryOffsets[i] = entry.startTime;
-            entryTitles[i] = entry.node.functionName;
-            var reason = entry.node.deoptReason;
-            entryDeoptFlags[i] = (reason && reason !== "no reason");
+            entrySelfTimes[i] = entry.selfTime;
         }
 
         this._maxStackDepth = Math.max(maxDepth, depth);
 
         this._timelineData = {
             entryLevels: entryLevels,
             entryTotalTimes: entryTotalTimes,
             entryOffsets: entryOffsets,
         };
 
-        this._entryTitles = entryTitles;
         this._entryNodes = entryNodes;
         this._entrySelfTimes = entrySelfTimes;
-        this._entryDeoptFlags = entryDeoptFlags;
-        this._entryColors = entryColors;
 
         return /** @type {!WebInspector.FlameChart.TimelineData} */ (this._timelineData);
     },
 
     /**
      * @param {number} ms
      * @return {string}
      */
     _millisecondsToString: function(ms)
     {
@@ skipping 17 matching lines @@
 
         var entryInfo = [];
         function pushEntryInfoRow(title, text)
         {
             var row = {};
             row.title = title;
             row.text = text;
             entryInfo.push(row);
         }
 
-        pushEntryInfoRow(WebInspector.UIString("Name"), this._entryTitles[entryIndex]);
+        pushEntryInfoRow(WebInspector.UIString("Name"), node.functionName);
         var selfTime = this._millisecondsToString(this._entrySelfTimes[entryIndex]);
         var totalTime = this._millisecondsToString(timelineData.entryTotalTimes[entryIndex]);
         pushEntryInfoRow(WebInspector.UIString("Self time"), selfTime);
         pushEntryInfoRow(WebInspector.UIString("Total time"), totalTime);
         if (node.url)
             pushEntryInfoRow(WebInspector.UIString("URL"), node.url + ":" + node.lineNumber);
         pushEntryInfoRow(WebInspector.UIString("Aggregated self time"), Number.secondsToString(node.selfTime / 1000, true));
         pushEntryInfoRow(WebInspector.UIString("Aggregated total time"), Number.secondsToString(node.totalTime / 1000, true));
         if (node.deoptReason && node.deoptReason !== "no reason")
             pushEntryInfoRow(WebInspector.UIString("Not optimized"), node.deoptReason);
 
         return entryInfo;
     },
 
     /**
      * @param {number} entryIndex
      * @return {boolean}
      */
     canJumpToEntry: function(entryIndex)
     {
         return this._entryNodes[entryIndex].scriptId !== "0";
     },
 
     /**
      * @param {number} entryIndex
      * @return {?string}
      */
     entryTitle: function(entryIndex)
     {
-        return this._entryTitles[entryIndex];
+        var node = this._entryNodes[entryIndex];
+        return node.functionName;
     },
 
     /**
      * @param {number} entryIndex
      * @return {?string}
      */
     entryFont: function(entryIndex)
     {
         if (!this._font) {
             this._font = (this.barHeight() - 4) + "px " + WebInspector.fontFamily();
             this._boldFont = "bold " + this._font;
         }
-        return this._entryDeoptFlags[entryIndex] ? this._boldFont : this._font;
+        var node = this._entryNodes[entryIndex];
+        var reason = node.deoptReason;
+        return (reason && reason !== "no reason") ? this._boldFont : this._font;
     },
 
     /**
      * @param {number} entryIndex
      * @return {!Object}
      */
     entryData: function(entryIndex)
     {
         return this._entryNodes[entryIndex];
     },
 
     /**
      * @param {number} entryIndex
      * @return {!string}
      */
     entryColor: function(entryIndex)
     {
-        return this._entryColors[entryIndex];
+        var node = this._entryNodes[entryIndex];
+        return this._colorGenerator.colorForID(node.functionName + ":" + node.url + ":" + node.lineNumber);;
     },
 }