Implement style recalc invalidation tracking in devtools

Source/devtools/front_end/timeline/TracingTimelineModel.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.
 
 /**
  * @constructor
  * @param {!WebInspector.TracingManager} tracingManager
  * @param {!WebInspector.TracingModel} tracingModel
  * @param {!WebInspector.TimelineModel.Filter} recordFilter
  * @extends {WebInspector.TimelineModel}
@@ skipping 577 matching lines @@
 
         case recordTypes.FireAnimationFrame:
             event.initiator = this._requestAnimationFrameEvents[event.args["data"]["id"]];
             break;
 
         case recordTypes.ScheduleStyleRecalculation:
             this._lastScheduleStyleRecalculation[event.args["frame"]] = event;
             break;
 
         case recordTypes.RecalculateStyles:
+            this._invalidationTracker.didRecalcStyle(event);
             event.initiator = this._lastScheduleStyleRecalculation[event.args["frame"]];
             this._lastRecalculateStylesEvent = event;
             break;
 
         case recordTypes.StyleRecalcInvalidationTracking:
         case recordTypes.LayoutInvalidationTracking:
         case recordTypes.LayerInvalidationTracking:
         case recordTypes.PaintInvalidationTracking:
             this._invalidationTracker.addInvalidation(event);
             break;
@@ skipping 562 matching lines @@
             if (invalidationToUpdate.nodeId !== invalidation.nodeId)
                 return;
             if (invalidationToUpdate.type === recordTypes.StyleRecalcInvalidationTracking
                     || invalidationToUpdate.type === recordTypes.LayoutInvalidationTracking) {
                 invalidationToUpdate.paintId = invalidation.paintId;
             }
         }
     },
 
     /**
+     * @param {!WebInspector.TracingModel.Event} styleRecalcEvent
+     */
+    didRecalcStyle: function(styleRecalcEvent)
+    {
+        var recalcFrameId = styleRecalcEvent.args["frame"];
+        var index = this._lastStyleRecalcEventIndex;
+        var invalidationCount = this._invalidationEvents.length;
+        for (; index < invalidationCount; index++) {
+            var invalidation = this._invalidationEvents[index];
+            if (invalidation.type !== WebInspector.TracingTimelineModel.RecordType.StyleRecalcInvalidationTracking)
+                continue;
+            if (invalidation.frameId === recalcFrameId)
+                this._addInvalidationTrackingEvent(styleRecalcEvent, invalidation);
+        }
+
+        this._lastStyleRecalcEventIndex = invalidationCount;
+    },
+
+    /**
      * @param {!WebInspector.TracingModel.Event} paintEvent
      */
     didPaint: function(paintEvent)
     {
         this._didPaint = true;
 
         // If a paint doesn't have a corresponding graphics layer id, it paints
         // into its parent so add an effectivePaintId to these events.
         var layerId = paintEvent.args["data"]["layerId"];
         if (layerId)
             this._lastPaintWithLayer = paintEvent;
         if (!this._lastPaintWithLayer) {
             console.error("Failed to find the paint container for a paint event.");
             return;
         }
 
         var effectivePaintId = this._lastPaintWithLayer.args["data"]["nodeId"];
         var frameId = paintEvent.args["data"]["frame"];
-        this._invalidationEvents.forEach(recordInvalidationForPaint);
+        this._invalidationEvents.forEach(recordInvalidationForPaint.bind(this));
 
         function recordInvalidationForPaint(invalidation)
         {
-            if (invalidation.paintId === effectivePaintId && invalidation.frameId === frameId) {
-                if (!paintEvent.invalidationTrackingEvents)
-                    paintEvent.invalidationTrackingEvents = [];
-                paintEvent.invalidationTrackingEvents.push(invalidation);
-            }
+            if (invalidation.paintId === effectivePaintId && invalidation.frameId === frameId)
+                this._addInvalidationTrackingEvent(paintEvent, invalidation);
         }
     },
 
+    /**
+     * @param {!WebInspector.TracingModel.Event} event
+     * @param {!WebInspector.InvalidationTrackingEvent} invalidation
+     */
+    _addInvalidationTrackingEvent: function(event, invalidation)
+    {
+        if (!event.invalidationTrackingEvents)
+            event.invalidationTrackingEvents = [ invalidation ];
+        else
+            event.invalidationTrackingEvents.push(invalidation);
+    },
+
     _startNewFrameIfNeeded: function()
     {
         if (!this._didPaint)
             return;
 
         this._initializePerFrameState();
     },
 
     _initializePerFrameState: function()
     {
         this._invalidationEvents = [];
+        this._lastStyleRecalcEventIndex = 0;
         this._lastPaintWithLayer = undefined;
         this._didPaint = false;
     }
 }