Timeline: remove TimelineModel inferred properties from TracingModel.Event

third_party/WebKit/Source/devtools/front_end/timeline_model/TimelineModel.js

 /*
  * Copyright (C) 2012 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 603 matching lines @@
     var eventStack = this._eventStack;
     while (eventStack.length && eventStack.peekLast().endTime <= event.startTime)
       eventStack.pop();
 
     var recordTypes = WebInspector.TimelineModel.RecordType;
 
     if (this._currentScriptEvent && event.startTime > this._currentScriptEvent.endTime)
       this._currentScriptEvent = null;
 
     var eventData = event.args['data'] || event.args['beginData'] || {};
+    var timelineData = WebInspector.TimelineData.forEvent(event);
     if (eventData['stackTrace'])
-      event.stackTrace = eventData['stackTrace'];
-    if (event.stackTrace && event.name !== recordTypes.JSSample) {
+      timelineData.stackTrace = eventData['stackTrace'];
+    if (timelineData.stackTrace && event.name !== recordTypes.JSSample) {
       // TraceEvents come with 1-based line & column numbers. The frontend code
       // requires 0-based ones. Adjust the values.
-      for (var i = 0; i < event.stackTrace.length; ++i) {
-        --event.stackTrace[i].lineNumber;
-        --event.stackTrace[i].columnNumber;
+      for (var i = 0; i < timelineData.stackTrace.length; ++i) {
+        --timelineData.stackTrace[i].lineNumber;
+        --timelineData.stackTrace[i].columnNumber;
       }
     }
 
-    if (eventStack.length && eventStack.peekLast().name === recordTypes.EventDispatch)
-      eventStack.peekLast().hasChildren = true;
     this._asyncEventTracker.processEvent(event);
-    if (event.initiator && event.initiator.url)
-      event.url = event.initiator.url;
     switch (event.name) {
       case recordTypes.ResourceSendRequest:
       case recordTypes.WebSocketCreate:
-        event.url = eventData['url'];
-        event.initiator = eventStack.peekLast() || null;
+        timelineData.setInitiator(eventStack.peekLast() || null);
+        timelineData.url = eventData['url'];
         break;
 
       case recordTypes.ScheduleStyleRecalculation:
         this._lastScheduleStyleRecalculation[eventData['frame']] = event;
         break;
 
       case recordTypes.UpdateLayoutTree:
       case recordTypes.RecalculateStyles:
         this._invalidationTracker.didRecalcStyle(event);
         if (event.args['beginData'])
-          event.initiator = this._lastScheduleStyleRecalculation[event.args['beginData']['frame']];
+          timelineData.setInitiator(this._lastScheduleStyleRecalculation[event.args['beginData']['frame']]);
         this._lastRecalculateStylesEvent = event;
         if (this._currentScriptEvent)
-          event.warning = WebInspector.TimelineModel.WarningType.ForcedStyle;
+          timelineData.warning = WebInspector.TimelineModel.WarningType.ForcedStyle;
         break;
 
       case recordTypes.ScheduleStyleInvalidationTracking:
       case recordTypes.StyleRecalcInvalidationTracking:
       case recordTypes.StyleInvalidatorInvalidationTracking:
       case recordTypes.LayoutInvalidationTracking:
       case recordTypes.LayerInvalidationTracking:
       case recordTypes.PaintInvalidationTracking:
       case recordTypes.ScrollInvalidationTracking:
         this._invalidationTracker.addInvalidation(new WebInspector.InvalidationTrackingEvent(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 = eventData['frame'];
         if (!this._layoutInvalidate[frameId] && this._lastRecalculateStylesEvent &&
             this._lastRecalculateStylesEvent.endTime > event.startTime)
-          layoutInitator = this._lastRecalculateStylesEvent.initiator;
+          layoutInitator = WebInspector.TimelineData.forEvent(this._lastRecalculateStylesEvent).initiator();
         this._layoutInvalidate[frameId] = layoutInitator;
         break;
 
       case recordTypes.Layout:
         this._invalidationTracker.didLayout(event);
         var frameId = event.args['beginData']['frame'];
-        event.initiator = this._layoutInvalidate[frameId];
+        timelineData.setInitiator(this._layoutInvalidate[frameId]);
         // In case we have no closing Layout event, endData is not available.
-        if (event.args['endData']) {
-          event.backendNodeId = event.args['endData']['rootNode'];
-          event.highlightQuad = event.args['endData']['root'];
-        }
+        if (event.args['endData'])
+          timelineData.backendNodeId = event.args['endData']['rootNode'];
         this._layoutInvalidate[frameId] = null;
         if (this._currentScriptEvent)
-          event.warning = WebInspector.TimelineModel.WarningType.ForcedLayout;
+          timelineData.warning = WebInspector.TimelineModel.WarningType.ForcedLayout;
         break;
 
       case recordTypes.FunctionCall:
         // Compatibility with old format.
         if (typeof eventData['scriptName'] === 'string')
           eventData['url'] = eventData['scriptName'];
         if (typeof eventData['scriptLine'] === 'number')
           eventData['lineNumber'] = eventData['scriptLine'];
       // Fallthrough.
       case recordTypes.EvaluateScript:
       case recordTypes.CompileScript:
         if (typeof eventData['lineNumber'] === 'number')
           --eventData['lineNumber'];
         if (typeof eventData['columnNumber'] === 'number')
           --eventData['columnNumber'];
       // Fallthrough intended.
       case recordTypes.RunMicrotasks:
         // Microtasks technically are not necessarily scripts, but for purpose of
         // forced sync style recalc or layout detection they are.
         if (!this._currentScriptEvent)
           this._currentScriptEvent = event;
         break;
 
       case recordTypes.SetLayerTreeId:
         this._inspectedTargetLayerTreeId = event.args['layerTreeId'] || event.args['data']['layerTreeId'];
         break;
 
       case recordTypes.Paint:
         this._invalidationTracker.didPaint(event);
-        event.highlightQuad = eventData['clip'];
-        event.backendNodeId = eventData['nodeId'];
+        timelineData.backendNodeId = eventData['nodeId'];
         // Only keep layer paint events, skip paints for subframes that get painted to the same layer as parent.
         if (!eventData['layerId'])
           break;
         var layerId = eventData['layerId'];
         this._lastPaintForLayer[layerId] = event;
         break;
 
       case recordTypes.DisplayItemListSnapshot:
       case recordTypes.PictureSnapshot:
         var layerUpdateEvent = this._findAncestorEvent(recordTypes.UpdateLayer);
         if (!layerUpdateEvent || layerUpdateEvent.args['layerTreeId'] !== this._inspectedTargetLayerTreeId)
           break;
         var paintEvent = this._lastPaintForLayer[layerUpdateEvent.args['layerId']];
         if (paintEvent)
-          paintEvent.picture = event;
+          WebInspector.TimelineData.forEvent(paintEvent).picture = event;
         break;
 
       case recordTypes.ScrollLayer:
-        event.backendNodeId = eventData['nodeId'];
+        timelineData.backendNodeId = eventData['nodeId'];
         break;
 
       case recordTypes.PaintImage:
-        event.backendNodeId = eventData['nodeId'];
-        event.url = eventData['url'];
+        timelineData.backendNodeId = eventData['nodeId'];
+        timelineData.url = eventData['url'];
         break;
 
       case recordTypes.DecodeImage:
       case recordTypes.ResizeImage:
         var paintImageEvent = this._findAncestorEvent(recordTypes.PaintImage);
         if (!paintImageEvent) {
           var decodeLazyPixelRefEvent = this._findAncestorEvent(recordTypes.DecodeLazyPixelRef);
           paintImageEvent = decodeLazyPixelRefEvent &&
               this._paintImageEventByPixelRefId[decodeLazyPixelRefEvent.args['LazyPixelRef']];
         }
         if (!paintImageEvent)
           break;
-        event.backendNodeId = paintImageEvent.backendNodeId;
-        event.url = paintImageEvent.url;
+        var paintImageData = WebInspector.TimelineData.forEvent(paintImageEvent);
+        timelineData.backendNodeId = paintImageData.backendNodeId;
+        timelineData.url = paintImageData.url;
         break;
 
       case recordTypes.DrawLazyPixelRef:
         var paintImageEvent = this._findAncestorEvent(recordTypes.PaintImage);
         if (!paintImageEvent)
           break;
         this._paintImageEventByPixelRefId[event.args['LazyPixelRef']] = paintImageEvent;
-        event.backendNodeId = paintImageEvent.backendNodeId;
-        event.url = paintImageEvent.url;
+        var paintImageData = WebInspector.TimelineData.forEvent(paintImageEvent);
+        event.backendNodeId = paintImageData.backendNodeId;
+        event.url = paintImageData.url;
         break;
 
       case recordTypes.MarkDOMContent:
       case recordTypes.MarkLoad:
         var page = eventData['page'];
         if (page && page !== this._currentPage)
           return false;
         break;
 
       case recordTypes.CommitLoad:
         var page = eventData['page'];
         if (page && page !== this._currentPage)
           return false;
         if (!eventData['isMainFrame'])
           break;
         this._hadCommitLoad = true;
         this._firstCompositeLayers = null;
         break;
 
       case recordTypes.CompositeLayers:
         if (!this._firstCompositeLayers && this._hadCommitLoad)
           this._firstCompositeLayers = event;
         break;
 
       case recordTypes.FireIdleCallback:
         if (event.duration > eventData['allottedMilliseconds']) {
-          event.warning = WebInspector.TimelineModel.WarningType.IdleDeadlineExceeded;
+          timelineData.warning = WebInspector.TimelineModel.WarningType.IdleDeadlineExceeded;
         }
         break;
     }
     if (WebInspector.TracingModel.isAsyncPhase(event.phase))
       return true;
     var duration = event.duration;
     if (!duration)
       return true;
     if (eventStack.length) {
       var parent = eventStack.peekLast();
@@ skipping 44 matching lines @@
       var data = lastStep.args['data'];
       asyncEvent.causedFrame = !!(data && data['INPUT_EVENT_LATENCY_RENDERER_SWAP_COMPONENT']);
       if (asyncEvent.hasCategory(WebInspector.TimelineModel.Category.LatencyInfo)) {
         if (!this._knownInputEvents.has(lastStep.id))
           return null;
         if (asyncEvent.name === WebInspector.TimelineModel.RecordType.InputLatencyMouseMove && !asyncEvent.causedFrame)
           return null;
         var rendererMain = data['INPUT_EVENT_LATENCY_RENDERER_MAIN_COMPONENT'];
         if (rendererMain) {
           var time = rendererMain['time'] / 1000;
-          asyncEvent.steps[0].timeWaitingForMainThread = time - asyncEvent.steps[0].startTime;
+          WebInspector.TimelineData.forEvent(asyncEvent.steps[0]).timeWaitingForMainThread = time - asyncEvent.steps[0].startTime;
         }
       }
       return groups.input;
     }
     return null;
   }
 
   /**
    * @param {string} name
    * @return {?WebInspector.TracingModel.Event}
@@ skipping 410 matching lines @@
   }
 
   /**
    * @return {!WebInspector.TimelineModel.RecordType}
    */
   type() {
     return WebInspector.TimelineModel._eventType(this._event);
   }
 
   /**
-   * @param {string} key
-   * @return {?Object}
-   */
-  getUserObject(key) {
-    if (key === 'TimelineUIUtils::preview-element')
-      return this._event.previewElement;
-    throw new Error('Unexpected key: ' + key);
-  }
-
-  /**
-   * @param {string} key
-   * @param {?Object|undefined} value
-   */
-  setUserObject(key, value) {
-    if (key !== 'TimelineUIUtils::preview-element')
-      throw new Error('Unexpected key: ' + key);
-    this._event.previewElement = /** @type {?Element} */ (value);
-  }
-
-  /**
    * @return {!WebInspector.TracingModel.Event}
    */
   traceEvent() {
     return this._event;
   }
 
   /**
    * @param {!WebInspector.TimelineModel.Record} child
    */
   _addChild(child) {
@@ skipping 169 matching lines @@
   constructor() {
     /** @type {?WebInspector.TracingModel.Event} */
     this._lastRecalcStyle = null;
     /** @type {?WebInspector.TracingModel.Event} */
     this._lastPaintWithLayer = null;
     this._didPaint = false;
     this._initializePerFrameState();
   }
 
   /**
+   * @param {!WebInspector.TracingModel.Event} event
+   * @return {?Array<!WebInspector.InvalidationTrackingEvent>}
+   */
+  static invalidationEventsFor(event) {
+    return event[WebInspector.InvalidationTracker._invalidationTrackingEventsSymbol] || null;
+  }
+
+  /**
    * @param {!WebInspector.InvalidationTrackingEvent} invalidation
    */
   addInvalidation(invalidation) {
     this._startNewFrameIfNeeded();
 
     if (!invalidation.nodeId && !invalidation.paintId) {
       console.error('Invalidation lacks node information.');
       console.error(invalidation);
       return;
     }
@@ skipping 181 matching lines @@
   }
 
   /**
    * @param {!WebInspector.TracingModel.Event} event
    * @param {number} eventFrameId
    * @param {!WebInspector.InvalidationTrackingEvent} invalidation
    */
   _addInvalidationToEvent(event, eventFrameId, invalidation) {
     if (eventFrameId !== invalidation.frame)
       return;
-    if (!event.invalidationTrackingEvents)
-      event.invalidationTrackingEvents = [invalidation];
+    if (!event[WebInspector.InvalidationTracker._invalidationTrackingEventsSymbol])
+      event[WebInspector.InvalidationTracker._invalidationTrackingEventsSymbol] = [invalidation];
     else
-      event.invalidationTrackingEvents.push(invalidation);
+      event[WebInspector.InvalidationTracker._invalidationTrackingEventsSymbol].push(invalidation);
   }
 
   /**
    * @param {!Array.<string>=} types
    * @return {!Iterator.<!WebInspector.InvalidationTrackingEvent>}
    */
   _invalidationsOfTypes(types) {
     var invalidations = this._invalidations;
     if (!types)
       types = Object.keys(invalidations);
@@ skipping 19 matching lines @@
     this._invalidations = {};
     /** @type {!Object.<number, !Array.<!WebInspector.InvalidationTrackingEvent>>} */
     this._invalidationsByNodeId = {};
 
     this._lastRecalcStyle = null;
     this._lastPaintWithLayer = null;
     this._didPaint = false;
   }
 };
 
+WebInspector.InvalidationTracker._invalidationTrackingEventsSymbol = Symbol('invalidationTrackingEvents');
+
 /**
  * @unrestricted
  */
 WebInspector.TimelineAsyncEventTracker = class {
   constructor() {
     WebInspector.TimelineAsyncEventTracker._initialize();
     /** @type {!Map<!WebInspector.TimelineModel.RecordType, !Map<string, !WebInspector.TracingModel.Event>>} */
     this._initiatorByType = new Map();
     for (var initiator of WebInspector.TimelineAsyncEventTracker._asyncEvents.keys())
       this._initiatorByType.set(initiator, new Map());
@@ skipping 39 matching lines @@
     if (!initiatorInfo)
       return;
     var id = event.args['data'][initiatorInfo.joinBy];
     if (!id)
       return;
     /** @type {!Map<string, !WebInspector.TracingModel.Event>|undefined} */
     var initiatorMap = this._initiatorByType.get(initiatorType);
     if (isInitiator)
       initiatorMap.set(id, event);
     else
-      event.initiator = initiatorMap.get(id) || null;
+      WebInspector.TimelineData.forEvent(event).setInitiator(initiatorMap.get(id) || null);
   }
 };
+
+
+WebInspector.TimelineData = class {
+  constructor() {
+    /** @type {?string} */
+    this.warning = null;
+    /** @type {?Element} */
+    this.previewElement = null;
+    /** @type {?string} */
+    this.url = null;
+    /** @type {number} */
+    this.backendNodeId = 0;
+    /** @type {?Array<!Protocol.Runtime.CallFrame>} */
+    this.stackTrace = null;
+    /** @type {?WebInspector.TracingModel.Event} */
+    this._initiator = null;
+    /** @type {number|undefined} */
+    this.timeWaitingForMainThread;
+  }
+
+  /**
+   * @param {!WebInspector.TracingModel.Event} initiator
+   */
+  setInitiator(initiator) {
+    this._initiator = initiator;
+    if (!initiator || this.url)
+      return;
+    var initiatorURL = WebInspector.TimelineData.forEvent(initiator).url;
+    if (initiatorURL)
+      this.url = initiatorURL;
+  }
+
+  /**
+   * @return {?WebInspector.TracingModel.Event}
+   */
+  initiator() {
+    return this._initiator;
+  }
+
+  /**
+   * @return {?Protocol.Runtime.CallFrame}
+   */
+  topFrame() {
+    var stackTrace = this.stackTraceForSelfOrInitiator();
+    return stackTrace && stackTrace[0] || null;
+  }
+
+  /**
+   * @return {?Array<!Protocol.Runtime.CallFrame>}
+   */
+  stackTraceForSelfOrInitiator() {
+    return this.stackTrace || (this._initiator && WebInspector.TimelineData.forEvent(this._initiator).stackTrace);
+  }
+
+  /**
+   * @return !{WebInspector.TimelineData}

[alph, 2016/11/09 00:46:22]

@param

+   */
+  static forEvent(event) {
+    var data = event[WebInspector.TimelineData._symbol];
+    if (!data) {
+      data = new WebInspector.TimelineData();
+      event[WebInspector.TimelineData._symbol] = data;
+    }
+    return data;
+  }
+};
+
+WebInspector.TimelineData._symbol = Symbol('timelineData');