Implement 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 29 matching lines @@
     UpdateLayer: "UpdateLayer",
     UpdateLayerTree: "UpdateLayerTree",
     PaintSetup: "PaintSetup",
     Paint: "Paint",
     PaintImage: "PaintImage",
     Rasterize: "Rasterize",
     RasterTask: "RasterTask",
     ScrollLayer: "ScrollLayer",
     CompositeLayers: "CompositeLayers",
 
+    StyleRecalcInvalidationTracking: "StyleRecalcInvalidationTracking",
+    LayoutInvalidationTracking: "LayoutInvalidationTracking",
+    LayerInvalidationTracking: "LayerInvalidationTracking",
+    PaintInvalidationTracking: "PaintInvalidationTracking",
+
     ParseHTML: "ParseHTML",
 
     TimerInstall: "TimerInstall",
     TimerRemove: "TimerRemove",
     TimerFire: "TimerFire",
 
     XHRReadyStateChange: "XHRReadyStateChange",
     XHRLoad: "XHRLoad",
     EvaluateScript: "EvaluateScript",
 
@@ skipping 78 matching lines @@
             WebInspector.TracingModel.ConsoleEventCategory
         ];
         if (captureCauses) {
             categoriesArray.push(disabledByDefault("devtools.timeline.stack"));
             if (Runtime.experiments.isEnabled("timelineJSCPUProfile")) {
                 this._jsProfilerStarted = true;
                 this._currentTarget = WebInspector.context.flavor(WebInspector.Target);
                 this._configureCpuProfilerSamplingInterval();
                 this._currentTarget.profilerAgent().start();
             }
+            if (Runtime.experiments.isEnabled("timelineInvalidationTracking"))
+                categoriesArray.push(disabledByDefault("devtools.timeline.invalidationTracking"));
         }
         if (capturePictures) {
             categoriesArray = categoriesArray.concat([
                 disabledByDefault("devtools.timeline.layers"),
                 disabledByDefault("devtools.timeline.picture"),
                 disabledByDefault("blink.graphics_context_annotations")]);
         }
         var categories = categoriesArray.join(",");
         this._startRecordingWithCategories(categories);
     },
@@ skipping 310 matching lines @@
         if (record.type() === WebInspector.TracingTimelineModel.RecordType.GPUTask)
             this._gpuThreadTasks.push(record);
         this.dispatchEventToListeners(WebInspector.TimelineModel.Events.RecordAdded, record);
     },
 
     _resetProcessingState: function()
     {
         this._sendRequestEvents = {};
         this._timerEvents = {};
         this._requestAnimationFrameEvents = {};
+        this._invalidationTracker = new WebInspector.InvalidationTracker();
         this._layoutInvalidate = {};
         this._lastScheduleStyleRecalculation = {};
         this._webSocketCreateEvents = {};
         this._paintImageEventByPixelRefId = {};
         this._lastPaintForLayer = {};
         this._lastRecalculateStylesEvent = null;
         this._currentScriptEvent = null;
         this._eventStack = [];
     },
 
@@ skipping 96 matching lines @@
 
         case recordTypes.ScheduleStyleRecalculation:
             this._lastScheduleStyleRecalculation[event.args["frame"]] = event;
             break;
 
         case recordTypes.RecalculateStyles:
             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;
+
         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["frame"];
             if (!this._layoutInvalidate[frameId] && this._lastRecalculateStylesEvent && this._lastRecalculateStylesEvent.endTime >  event.startTime)
                 layoutInitator = this._lastRecalculateStylesEvent.initiator;
             this._layoutInvalidate[frameId] = layoutInitator;
             break;
 
@@ skipping 24 matching lines @@
         case recordTypes.FunctionCall:
             if (!this._currentScriptEvent)
                 this._currentScriptEvent = event;
             break;
 
         case recordTypes.SetLayerTreeId:
             this._inspectedTargetLayerTreeId = event.args["layerTreeId"];
             break;
 
         case recordTypes.Paint:
+            this._invalidationTracker.didPaint(event);
             event.highlightQuad = event.args["data"]["clip"];
             event.backendNodeId = event.args["data"]["nodeId"];
             var layerUpdateEvent = this._findAncestorEvent(recordTypes.UpdateLayer);
             if (!layerUpdateEvent || layerUpdateEvent.args["layerTreeId"] !== this._inspectedTargetLayerTreeId)
                 break;
             // Only keep layer paint events, skip paints for subframes that get painted to the same layer as parent.
             if (!event.args["data"]["layerId"])
                 break;
             this._lastPaintForLayer[layerUpdateEvent.args["layerId"]] = event;
             break;
@@ skipping 448 matching lines @@
      * @param {!WebInspector.ChunkedReader} reader
      */
     onChunkTransferred: function(reader) { },
 
     /**
      * @param {!WebInspector.ChunkedReader} reader
      * @param {!Event} event
      */
     onError: function(reader, event) { },
 }
+
+/**
+ * @constructor
+ * @param {!Event} event
+ */
+WebInspector.InvalidationTrackingEvent = function(event)
+{
+    this.type = event.name;
+    this.frameId = event.args["data"]["frame"];
+    this.nodeId = event.args["data"]["nodeId"];
+    this.nodeName = event.args["data"]["nodeName"];
+    this.paintId = event.args["data"]["paintId"];
+    this.reason = event.args["data"]["reason"];
+    this.stackTrace = event.args["data"]["stackTrace"];
+}
+
+/**
+ * @constructor
+ */
+WebInspector.InvalidationTracker = function()
+{
+    this._initializePerFrameState();
+}
+
+WebInspector.InvalidationTracker.prototype = {
+    /**
+     * @param {!Event} event
+     */
+    addInvalidation: function(event)
+    {
+        var invalidation = new WebInspector.InvalidationTrackingEvent(event);
+
+        this._startNewFrameIfNeeded();
+        if (!invalidation.nodeId && !invalidation.paintId) {
+            console.error("Invalidation lacks node information.");
+            console.error(invalidation);
+        }
+
+        // Record the paintIds for style recalc or layout invalidations.
+        // FIXME: This O(n^2) loop could be optimized with a map.
+        var recordTypes = WebInspector.TracingTimelineModel.RecordType;
+        if (invalidation.type == recordTypes.PaintInvalidationTracking)
+            this._invalidationEvents.forEach(updatePaintId);
+        else
+            this._invalidationEvents.push(invalidation);
+
+        function updatePaintId(invalidationToUpdate)
+        {
+            if (invalidationToUpdate.nodeId !== invalidation.nodeId)
+                return;
+            if (invalidationToUpdate.type === recordTypes.StyleRecalcInvalidationTracking
+                    || invalidationToUpdate.type === recordTypes.LayoutInvalidationTracking) {
+                invalidationToUpdate.paintId = invalidation.paintId;
+            }
+        }
+    },
+
+    /**
+     * @param {!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;

[caseq, 2014/10/17 15:48:55]

args["data"]["nodeId"]

[pdr., 2014/10/20 21:38:05]

Done.

+        var frameId = paintEvent.args["data"]["frame"];
+        this._invalidationEvents.forEach(recordInvalidationForPaint);
+
+        function recordInvalidationForPaint(invalidation)
+        {
+            if (invalidation.paintId === effectivePaintId && invalidation.frameId === frameId) {
+                if (!paintEvent.invalidationTrackingEvents)
+                    paintEvent.invalidationTrackingEvents = [];
+                paintEvent.invalidationTrackingEvents.push(invalidation);
+            }
+        }
+    },
+
+    _startNewFrameIfNeeded: function()
+    {
+        if (!this._didPaint)
+            return;
+
+        this._initializePerFrameState();
+    },
+
+    _initializePerFrameState: function()
+    {
+        this._invalidationEvents = [];
+        this._lastPaintWithLayer = undefined;
+        this._didPaint = false;
+    }
+}