Timeline: remove TimelineModel inferred properties from TracingModel.Event

third_party/WebKit/Source/devtools/front_end/timeline/TimelineUIUtils.js

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  * Copyright (C) 2012 Intel 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.
@@ skipping 213 matching lines @@
   }
 
   /**
    * @param {!WebInspector.TracingModel.Event} traceEvent
    * @param {!RegExp} regExp
    * @return {boolean}
    */
   static testContentMatching(traceEvent, regExp) {
     var title = WebInspector.TimelineUIUtils.eventStyle(traceEvent).title;
     var tokens = [title];
-    if (traceEvent.url)
-      tokens.push(traceEvent.url);
+    var url = WebInspector.TimelineData.forEvent(traceEvent).url;
+    if (url)
+      tokens.push(url);
     for (var argName in traceEvent.args) {
       var argValue = traceEvent.args[argName];
       for (var key in argValue)
         tokens.push(argValue[key]);
     }
     return regExp.test(tokens.join('|'));
   }
 
   /**
    * @param {!WebInspector.TimelineModel.Record} record
@@ skipping 53 matching lines @@
       return title;
     if (event.name === WebInspector.TimelineModel.RecordType.TimeStamp)
       return WebInspector.UIString('%s: %s', title, event.args['data']['message']);
     if (event.name === WebInspector.TimelineModel.RecordType.Animation && event.args['data'] &&
         event.args['data']['name'])
       return WebInspector.UIString('%s: %s', title, event.args['data']['name']);
     return title;
   }
 
   /**
-   * @param {!WebInspector.TracingModel.Event} event
-   * @return {?string}
-   */
-  static eventURL(event) {
-    if (event.url)
-      return event.url;
-    var data = event.args['data'] || event.args['beginData'];
-    return data && data.url || null;
-  }
-
-  /**
    * !Map<!WebInspector.TimelineIRModel.Phases, !{color: string, label: string}>
    */
   static _interactionPhaseStyles() {
     var map = WebInspector.TimelineUIUtils._interactionPhaseStylesMap;
     if (!map) {
       map = new Map([
         [WebInspector.TimelineIRModel.Phases.Idle, {color: 'white', label: 'Idle'}],
         [
           WebInspector.TimelineIRModel.Phases.Response,
           {color: 'hsl(43, 83%, 64%)', label: WebInspector.UIString('Response')}
@@ skipping 39 matching lines @@
 
   /**
    * @param {!Protocol.Runtime.CallFrame} frame
    * @return {boolean}
    */
   static isUserFrame(frame) {
     return frame.scriptId !== '0' && !(frame.url && frame.url.startsWith('native '));
   }
 
   /**
-   * @param {!WebInspector.TracingModel.Event} event
-   * @return {?Protocol.Runtime.CallFrame}
-   */
-  static topStackFrame(event) {
-    var stackTrace = event.stackTrace || event.initiator && event.initiator.stackTrace;
-    return stackTrace && stackTrace.length ? stackTrace[0] : null;
-  }
-
-  /**
    * @param {!WebInspector.TimelineModel.NetworkRequest} request
    * @return {!WebInspector.TimelineUIUtils.NetworkCategory}
    */
   static networkRequestCategory(request) {
     var categories = WebInspector.TimelineUIUtils.NetworkCategory;
     switch (request.mimeType) {
       case 'text/html':
         return categories.HTML;
       case 'application/javascript':
       case 'application/x-javascript':
@@ skipping 99 matching lines @@
       case recordType.WebSocketReceiveHandshakeResponse:
       case recordType.WebSocketDestroy:
       case recordType.ResourceSendRequest:
       case recordType.ResourceReceivedData:
       case recordType.ResourceReceiveResponse:
       case recordType.ResourceFinish:
       case recordType.PaintImage:
       case recordType.DecodeImage:
       case recordType.ResizeImage:
       case recordType.DecodeLazyPixelRef:
-        if (event.url)
-          detailsText = WebInspector.displayNameForURL(event.url);
+        var url = WebInspector.TimelineData.forEvent(event).url;
+        if (url)
+          detailsText = WebInspector.displayNameForURL(url);
         break;
 
       case recordType.EmbedderCallback:
         detailsText = eventData['callbackName'];
         break;
 
       case recordType.Animation:
         detailsText = eventData && eventData['name'];
         break;
 
@@ skipping 33 matching lines @@
       if (!rawLocation)
         return null;
       var uiLocation = WebInspector.debuggerWorkspaceBinding.rawLocationToUILocation(rawLocation);
       return uiLocation.linkText();
     }
 
     /**
      * @return {?string}
      */
     function linkifyTopCallFrameAsText() {
-      var frame = WebInspector.TimelineUIUtils.topStackFrame(event);
+      var frame = WebInspector.TimelineData.forEvent(event).topFrame();
       if (!frame)
         return null;
       var text = linkifyLocationAsText(frame.scriptId, frame.lineNumber, frame.columnNumber);
       if (!text) {
         text = frame.url;
         if (typeof frame.lineNumber === 'number')
           text += ':' + (frame.lineNumber + 1);
       }
       return text;
     }
@@ skipping 31 matching lines @@
       case recordType.PaintImage:
       case recordType.DecodeImage:
       case recordType.ResizeImage:
       case recordType.DecodeLazyPixelRef:
       case recordType.XHRReadyStateChange:
       case recordType.XHRLoad:
       case recordType.ResourceSendRequest:
       case recordType.ResourceReceivedData:
       case recordType.ResourceReceiveResponse:
       case recordType.ResourceFinish:
-        if (event.url)
-          details = WebInspector.linkifyResourceAsNode(event.url);
+        var url = WebInspector.TimelineData.forEvent(event).url;
+        if (url)
+          details = WebInspector.linkifyResourceAsNode(url);
         break;
       case recordType.FunctionCall:
       case recordType.JSFrame:
         details = createElement('span');
         details.createTextChild(WebInspector.beautifyFunctionName(eventData['functionName']));
         var location = linkifyLocation(
             eventData['scriptId'], eventData['url'], eventData['lineNumber'], eventData['columnNumber']);
         if (location) {
           details.createTextChild(' @ ');
           details.appendChild(location);
@@ skipping 30 matching lines @@
      * @return {?Element}
      */
     function linkifyLocation(scriptId, url, lineNumber, columnNumber) {
       return linkifier.linkifyScriptLocation(target, scriptId, url, lineNumber, columnNumber, 'timeline-details');
     }
 
     /**
      * @return {?Element}
      */
     function linkifyTopCallFrame() {
-      var frame = WebInspector.TimelineUIUtils.topStackFrame(event);
+      var frame = WebInspector.TimelineData.forEvent(event).topFrame();
       return frame ? linkifier.maybeLinkifyConsoleCallFrame(target, frame, 'timeline-details') : null;
     }
   }
 
   /**
    * @param {!WebInspector.TracingModel.Event} event
    * @param {!WebInspector.TimelineModel} model
    * @param {!WebInspector.Linkifier} linkifier
    * @param {boolean} detailed
    * @param {function(!DocumentFragment)} callback
    */
   static buildTraceEventDetails(event, model, linkifier, detailed, callback) {
     var target = model.targetByEvent(event);
     if (!target) {
       callbackWrapper();
       return;
     }
     var relatedNodes = null;
     var barrier = new CallbackBarrier();
-    if (!event.previewElement) {
-      if (event.url)
+    if (!event[WebInspector.TimelineUIUtils._previewElementSymbol]) {
+      var url = WebInspector.TimelineData.forEvent(event).url;
+      if (url) {
         WebInspector.DOMPresentationUtils.buildImagePreviewContents(
-            target, event.url, false, barrier.createCallback(saveImage));
-      else if (event.picture)
+            target, url, false, barrier.createCallback(saveImage));
+      } else if (WebInspector.TimelineData.forEvent(event).picture)

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

need {}

         WebInspector.TimelineUIUtils.buildPicturePreviewContent(event, target, barrier.createCallback(saveImage));
     }
     var nodeIdsToResolve = new Set();
-    if (event.backendNodeId)
-      nodeIdsToResolve.add(event.backendNodeId);
-    if (event.invalidationTrackingEvents)
-      WebInspector.TimelineUIUtils._collectInvalidationNodeIds(nodeIdsToResolve, event.invalidationTrackingEvents);
+    var timelineData = WebInspector.TimelineData.forEvent(event);
+    if (timelineData.backendNodeId)
+      nodeIdsToResolve.add(timelineData.backendNodeId);
+    var invalidationTrackingEvents = WebInspector.InvalidationTracker.invalidationEventsFor(event);
+    if (invalidationTrackingEvents)
+      WebInspector.TimelineUIUtils._collectInvalidationNodeIds(nodeIdsToResolve, invalidationTrackingEvents);
     if (nodeIdsToResolve.size) {
       var domModel = WebInspector.DOMModel.fromTarget(target);
       if (domModel)
         domModel.pushNodesByBackendIdsToFrontend(nodeIdsToResolve, barrier.createCallback(setRelatedNodeMap));
     }
     barrier.callWhenDone(callbackWrapper);
 
     /**
      * @param {!Element=} element
      */
     function saveImage(element) {
-      event.previewElement = element || null;
+      event[WebInspector.TimelineUIUtils._previewElementSymbol] = element || null;
     }
 
     /**
      * @param {?Map<number, ?WebInspector.DOMNode>} nodeMap
      */
     function setRelatedNodeMap(nodeMap) {
       relatedNodes = nodeMap;
     }
 
     function callbackWrapper() {
       callback(WebInspector.TimelineUIUtils._buildTraceEventDetailsSynchronously(
           event, model, linkifier, detailed, relatedNodes));
     }
   }
 
   /**
    * @param {!WebInspector.TracingModel.Event} event
    * @param {!WebInspector.TimelineModel} model
    * @param {!WebInspector.Linkifier} linkifier
    * @param {boolean} detailed
    * @param {?Map<number, ?WebInspector.DOMNode>} relatedNodesMap
    * @return {!DocumentFragment}
    */
   static _buildTraceEventDetailsSynchronously(event, model, linkifier, detailed, relatedNodesMap) {
-    var stats = {};
     var recordTypes = WebInspector.TimelineModel.RecordType;
-
     // This message may vary per event.name;
     var relatedNodeLabel;
 
     var contentHelper = new WebInspector.TimelineDetailsContentHelper(model.targetByEvent(event), linkifier);
     contentHelper.addSection(
         WebInspector.TimelineUIUtils.eventTitle(event), WebInspector.TimelineUIUtils.eventStyle(event).category);
 
     var eventData = event.args['data'];
-    var initiator = event.initiator;
+    var timelineData = WebInspector.TimelineData.forEvent(event);
+    var initiator = timelineData.initiator();
 
-    if (event.warning)
+    if (timelineData.warning)
       contentHelper.appendWarningRow(event);
     if (event.name === recordTypes.JSFrame && eventData['deoptReason'])
       contentHelper.appendWarningRow(event, WebInspector.TimelineModel.WarningType.V8Deopt);
 
     if (detailed) {
       contentHelper.appendTextRow(WebInspector.UIString('Self Time'), Number.millisToString(event.selfTime, true));
       contentHelper.appendTextRow(
           WebInspector.UIString('Total Time'), Number.millisToString(event.duration || 0, true));
     }
 
@@ skipping 20 matching lines @@
           contentHelper.appendTextRow(WebInspector.UIString('Repeats'), !eventData['singleShot']);
         }
         break;
       case recordTypes.FireAnimationFrame:
         contentHelper.appendTextRow(WebInspector.UIString('Callback ID'), eventData['id']);
         break;
       case recordTypes.ResourceSendRequest:
       case recordTypes.ResourceReceiveResponse:
       case recordTypes.ResourceReceivedData:
       case recordTypes.ResourceFinish:
-        var url = (event.name === recordTypes.ResourceSendRequest) ? eventData['url'] :
-                                                                     initiator && initiator.args['data']['url'];
+        var url = timelineData.url;
         if (url)
           contentHelper.appendElementRow(WebInspector.UIString('Resource'), WebInspector.linkifyResourceAsNode(url));
         if (eventData['requestMethod'])
           contentHelper.appendTextRow(WebInspector.UIString('Request Method'), eventData['requestMethod']);
         if (typeof eventData['statusCode'] === 'number')
           contentHelper.appendTextRow(WebInspector.UIString('Status Code'), eventData['statusCode']);
         if (eventData['mimeType'])
           contentHelper.appendTextRow(WebInspector.UIString('MIME Type'), eventData['mimeType']);
         if ('priority' in eventData) {
           var priority = WebInspector.uiLabelForPriority(eventData['priority']);
@@ skipping 25 matching lines @@
       case recordTypes.Rasterize:
       case recordTypes.ScrollLayer:
         relatedNodeLabel = WebInspector.UIString('Layer Root');
         break;
       case recordTypes.PaintImage:
       case recordTypes.DecodeLazyPixelRef:
       case recordTypes.DecodeImage:
       case recordTypes.ResizeImage:
       case recordTypes.DrawLazyPixelRef:
         relatedNodeLabel = WebInspector.UIString('Owner Element');
-        if (event.url)
+        if (timelineData.url)
           contentHelper.appendElementRow(
-              WebInspector.UIString('Image URL'), WebInspector.linkifyResourceAsNode(event.url));
+              WebInspector.UIString('Image URL'), WebInspector.linkifyResourceAsNode(timelineData.url));
         break;
       case recordTypes.ParseAuthorStyleSheet:
         var url = eventData['styleSheetUrl'];
         if (url)
           contentHelper.appendElementRow(
               WebInspector.UIString('Stylesheet URL'), WebInspector.linkifyResourceAsNode(url));
         break;
       case recordTypes.UpdateLayoutTree:  // We don't want to see default details.
       case recordTypes.RecalculateStyles:
         contentHelper.appendTextRow(WebInspector.UIString('Elements Affected'), event.args['elementCount']);
@@ skipping 51 matching lines @@
         break;
 
       default:
         var detailsNode =
             WebInspector.TimelineUIUtils.buildDetailsNodeForTraceEvent(event, model.targetByEvent(event), linkifier);
         if (detailsNode)
           contentHelper.appendElementRow(WebInspector.UIString('Details'), detailsNode);
         break;
     }
 
-    if (event.timeWaitingForMainThread)
+    if (timelineData.timeWaitingForMainThread)
       contentHelper.appendTextRow(
           WebInspector.UIString('Time Waiting for Main Thread'),
-          Number.millisToString(event.timeWaitingForMainThread, true));
+          Number.millisToString(timelineData.timeWaitingForMainThread, true));
 
-    var relatedNode = relatedNodesMap && relatedNodesMap.get(event.backendNodeId);
+    var relatedNode = relatedNodesMap && relatedNodesMap.get(timelineData.backendNodeId);
     if (relatedNode)
       contentHelper.appendElementRow(
           relatedNodeLabel || WebInspector.UIString('Related Node'),
           WebInspector.DOMPresentationUtils.linkifyNodeReference(relatedNode));
 
-    if (event.previewElement) {
+    if (event[WebInspector.TimelineUIUtils._previewElementSymbol]) {
       contentHelper.addSection(WebInspector.UIString('Preview'));
-      contentHelper.appendElementRow('', event.previewElement);
+      contentHelper.appendElementRow('', event[WebInspector.TimelineUIUtils._previewElementSymbol]);
     }
 
-    if (event.stackTrace || (event.initiator && event.initiator.stackTrace) || event.invalidationTrackingEvents)
+    if (timelineData.stackTraceForSelfOrInitiator() || WebInspector.InvalidationTracker.invalidationEventsFor(event))
       WebInspector.TimelineUIUtils._generateCauses(event, model.targetByEvent(event), relatedNodesMap, contentHelper);
 
+    var stats = {};
     var showPieChart = detailed && WebInspector.TimelineUIUtils._aggregatedStatsForTraceEvent(stats, model, event);
     if (showPieChart) {
       contentHelper.addSection(WebInspector.UIString('Aggregated Time'));
       var pieChart = WebInspector.TimelineUIUtils.generatePieChart(
           stats, WebInspector.TimelineUIUtils.eventStyle(event).category, event.selfTime);
       contentHelper.appendElementRow('', pieChart);
     }
 
     return contentHelper.fragment;
   }
@@ skipping 98 matching lines @@
       contentHelper.appendTextRow(WebInspector.UIString('Request Method'), request.requestMethod);
     if (typeof request.priority === 'string') {
       var priority = WebInspector.uiLabelForPriority(/** @type {!Protocol.Network.ResourcePriority} */ (request.priority));
       contentHelper.appendTextRow(WebInspector.UIString('Priority'), priority);
     }
     if (request.mimeType)
       contentHelper.appendTextRow(WebInspector.UIString('Mime Type'), request.mimeType);
 
     var title = WebInspector.UIString('Initiator');
     var sendRequest = request.children[0];
-    var topFrame = WebInspector.TimelineUIUtils.topStackFrame(sendRequest);
+    var topFrame = WebInspector.TimelineData.forEvent(sendRequest).topFrame();
     if (topFrame) {
       var link = linkifier.maybeLinkifyConsoleCallFrame(target, topFrame);
       if (link)
         contentHelper.appendElementRow(title, link);
-    } else if (sendRequest.initiator) {
-      var initiatorURL = WebInspector.TimelineUIUtils.eventURL(sendRequest.initiator);
-      if (initiatorURL) {
-        var link = linkifier.maybeLinkifyScriptLocation(target, null, initiatorURL, 0);
-        if (link)
-          contentHelper.appendElementRow(title, link);
+    } else {
+      var initiator = WebInspector.TimelineData.forEvent(sendRequest);
+       if (initiator) {
+        var initiatorURL = WebInspector.TimelineData.forEvent(initiator).url;
+        if (initiatorURL) {
+          var link = linkifier.maybeLinkifyScriptLocation(target, null, initiatorURL, 0);
+          if (link)
+            contentHelper.appendElementRow(title, link);
+        }
       }
     }
 
     /**
      * @param {function(?Element)} fulfill
      */
     function action(fulfill) {
       WebInspector.DOMPresentationUtils.buildImagePreviewContents(
           /** @type {!WebInspector.Target} */ (target), request.url, false, saveImage);
       /**
@@ skipping 33 matching lines @@
    * @param {!WebInspector.TracingModel.Event} event
    * @param {?WebInspector.Target} target
    * @param {?Map<number, ?WebInspector.DOMNode>} relatedNodesMap
    * @param {!WebInspector.TimelineDetailsContentHelper} contentHelper
    */
   static _generateCauses(event, target, relatedNodesMap, contentHelper) {
     var recordTypes = WebInspector.TimelineModel.RecordType;
 
     var callSiteStackLabel;
     var stackLabel;
-    var initiator = event.initiator;
 
     switch (event.name) {
       case recordTypes.TimerFire:
         callSiteStackLabel = WebInspector.UIString('Timer Installed');
         break;
       case recordTypes.FireAnimationFrame:
         callSiteStackLabel = WebInspector.UIString('Animation Frame Requested');
         break;
       case recordTypes.FireIdleCallback:
         callSiteStackLabel = WebInspector.UIString('Idle Callback Requested');
         break;
       case recordTypes.UpdateLayoutTree:
       case recordTypes.RecalculateStyles:
         stackLabel = WebInspector.UIString('Recalculation Forced');
         break;
       case recordTypes.Layout:
         callSiteStackLabel = WebInspector.UIString('First Layout Invalidation');
         stackLabel = WebInspector.UIString('Layout Forced');
         break;
     }
 
+    var timelineData = WebInspector.TimelineData.forEvent(event);
     // Direct cause.
-    if (event.stackTrace && event.stackTrace.length) {
+    if (timelineData.stackTrace && timelineData.stackTrace.length) {
       contentHelper.addSection(WebInspector.UIString('Call Stacks'));
       contentHelper.appendStackTrace(
           stackLabel || WebInspector.UIString('Stack Trace'),
-          WebInspector.TimelineUIUtils._stackTraceFromCallFrames(event.stackTrace));
+          WebInspector.TimelineUIUtils._stackTraceFromCallFrames(timelineData.stackTrace));
     }
 
+    var initiator = WebInspector.TimelineData.forEvent(event).initiator();
     // Indirect causes.
-    if (event.invalidationTrackingEvents && target) {  // Full invalidation tracking (experimental).
+    if (WebInspector.InvalidationTracker.invalidationEventsFor(event) && target) {  // Full invalidation tracking (experimental).
       contentHelper.addSection(WebInspector.UIString('Invalidations'));
       WebInspector.TimelineUIUtils._generateInvalidations(event, target, relatedNodesMap, contentHelper);
-    } else if (initiator && initiator.stackTrace) {  // Partial invalidation tracking.
-      contentHelper.appendStackTrace(
-          callSiteStackLabel || WebInspector.UIString('First Invalidated'),
-          WebInspector.TimelineUIUtils._stackTraceFromCallFrames(initiator.stackTrace));
+    } else if (initiator) {  // Partial invalidation tracking.
+      var initiatorStackTrace = WebInspector.TimelineData.forEvent(initiator).stackTrace;
+      if (initiatorStackTrace) {
+        contentHelper.appendStackTrace(
+            callSiteStackLabel || WebInspector.UIString('First Invalidated'),
+            WebInspector.TimelineUIUtils._stackTraceFromCallFrames(initiatorStackTrace));
+      }
     }
   }
 
   /**
    * @param {!WebInspector.TracingModel.Event} event
    * @param {!WebInspector.Target} target
    * @param {?Map<number, ?WebInspector.DOMNode>} relatedNodesMap
    * @param {!WebInspector.TimelineDetailsContentHelper} contentHelper
    */
   static _generateInvalidations(event, target, relatedNodesMap, contentHelper) {
-    if (!event.invalidationTrackingEvents)
-      return;
-
+    var invalidationTrackingEvents = WebInspector.InvalidationTracker.invalidationEventsFor(event);
     var invalidations = {};
-    event.invalidationTrackingEvents.forEach(function(invalidation) {
+    invalidationTrackingEvents.forEach(function(invalidation) {
       if (!invalidations[invalidation.type])
         invalidations[invalidation.type] = [invalidation];
       else
         invalidations[invalidation.type].push(invalidation);
     });
 
     Object.keys(invalidations).forEach(function(type) {
       WebInspector.TimelineUIUtils._generateInvalidationsForType(
           type, target, invalidations[type], relatedNodesMap, contentHelper);
     });
@@ skipping 535 matching lines @@
     }
     return WebInspector.TimelineUIUtils.colorForURL._colorGenerator.colorForID(url);
   }
 
   /**
    * @param {!WebInspector.TracingModel.Event} event
    * @param {string=} warningType
    * @return {?Element}
    */
   static eventWarning(event, warningType) {
-    var warning = warningType || event.warning;
+    var timelineData = WebInspector.TimelineData.forEvent(event);
+    var warning = warningType || timelineData.warning;
     if (!warning)
       return null;
     var warnings = WebInspector.TimelineModel.WarningType;
     var span = createElement('span');
     var eventData = event.args['data'];
 
     switch (warning) {
       case warnings.ForcedStyle:
       case warnings.ForcedLayout:
         span.appendChild(WebInspector.linkifyDocumentationURLAsNode(
@@ skipping 199 matching lines @@
       nodeSpan.textContent = WebInspector.UIString('[ %s ]', invalidation.nodeName);
       return nodeSpan;
     }
     if (showUnknownNodes) {
       var nodeSpan = createElement('span');
       return nodeSpan.createTextChild(WebInspector.UIString('[ unknown node ]'));
     }
   }
 };
 
+WebInspector.TimelineUIUtils._previewElementSymbol = Symbol('previewElement');
 
 /**
  * @unrestricted
  */
 WebInspector.TimelineUIUtils.EventDispatchTypeDescriptor = class {
   /**
    * @param {number} priority
    * @param {string} color
    * @param {!Array.<string>} eventTypes
    */
@@ skipping 272 matching lines @@
   /**
    * @param {!WebInspector.TracingModel.Event} event
    * @param {string=} warningType
    */
   appendWarningRow(event, warningType) {
     var warning = WebInspector.TimelineUIUtils.eventWarning(event, warningType);
     if (warning)
       this.appendElementRow(WebInspector.UIString('Warning'), warning, true);
   }
 };