FlameChart: convert colors magic into dataProvider.entryColor getter

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 1091 matching lines @@
 
     /**
      * @return {?WebInspector.FlameChart.TimelineData}
      */
     timelineData: function()
     {
         return this._timelineData || this._calculateTimelineData();
     },
 
     /**
-     * @return {!WebInspector.FlameChart.ColorGenerator}
-     */
-    colorGenerator: function()
-    {
-        return this._colorGenerator;
-    },
-
-    /**
      * @return {?WebInspector.FlameChart.TimelineData}
      */
     _calculateTimelineData: function()
     {
         if (!this._cpuProfileView.profileHead)
             return null;
 
         var samples = this._cpuProfileView.samples;
         var idToNode = this._cpuProfileView._idToNode;
         var gcNode = this._cpuProfileView._gcNode;
         var samplesCount = samples.length;
         var samplingInterval = this._cpuProfileView.samplingIntervalMs;
 
         var index = 0;
 
         var openIntervals = [];
         var stackTrace = [];
-        var colorEntryIndexes = [];
         var maxDepth = 5; // minimum stack depth for the case when we see no activity.
         var depth = 0;
 
         /**
          * @constructor
-         * @param {!Object} color
-         * @param {!number} depth
-         * @param {!number} duration
-         * @param {!number} startTime
+         * @param {string} color
+         * @param {number} depth
+         * @param {number} duration
+         * @param {number} startTime
          * @param {!Object} node
          */
         function ChartEntry(color, depth, duration, startTime, node)
         {
             this.color = color;
             this.depth = depth;
             this.duration = duration;
             this.startTime = startTime;
             this.node = node;
             this.selfTime = 0;
@@ skipping 35 matching lines @@
                 ++depth;
             }
             if (depth < openIntervals.length)
                 openIntervals.length = depth;
             if (!node) {
                 entries[intervalIndex].selfTime += samplingInterval;
                 continue;
             }
 
             var colorGenerator = this._colorGenerator;
+            var color = "";
             while (node) {
-                var color = colorGenerator.colorForID(node.functionName + ":" + node.url + ":" + node.lineNumber);
-                var indexesForColor = colorEntryIndexes[color.index];
-                if (!indexesForColor)
-                    indexesForColor = colorEntryIndexes[color.index] = [];
-
-                var entry = new ChartEntry(color, depth, samplingInterval, sampleIndex * samplingInterval, node);
-                indexesForColor.push(entries.length);
-                entries.push(entry);
+                color = colorGenerator.colorForID(node.functionName + ":" + node.url + ":" + node.lineNumber);
+                entries.push(new ChartEntry(color, depth, samplingInterval, sampleIndex * samplingInterval, node));

[pfeldman, 2014/03/03 12:20:54]

You only want to do this on demand.

                 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 entryColorIndexes = new Uint16Array(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;
-            entryColorIndexes[i] = color.index;
+            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");
         }
 
         this._maxStackDepth = Math.max(maxDepth, depth);
 
         this._timelineData = {
-            colorEntryIndexes: colorEntryIndexes,
-            entryColorIndexes: entryColorIndexes,
             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 70 matching lines @@
         return this._entryDeoptFlags[entryIndex] ? 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];
+    },
 }