Timeline: add moar attributes in frame instrumentation

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 259 matching lines @@
    * @return {!WebInspector.TimelineModel.MetadataEvents}
    */
   _processMetadataEvents(tracingModel, produceTraceStartedInPage) {
     var metadataEvents = tracingModel.devToolsMetadataEvents();
 
     var pageDevToolsMetadataEvents = [];
     var workersDevToolsMetadataEvents = [];
     for (var event of metadataEvents) {
       if (event.name === WebInspector.TimelineModel.DevToolsMetadataEvent.TracingStartedInPage) {
         pageDevToolsMetadataEvents.push(event);
-        var frames = (event.args['data'] && event.args['data']['frames']) || [];
-        for (var frame of frames) {
-          var processId = event.thread.process().id();
-          var frameId = `${processId}.${frame.frame}`;
-          var frameData = {
-            url: frame['url'] || '',
-            name: frame['name'] || '',
-            processId: processId,
-            frameId: frame['frame']
-          };
-          this._pageFrames.set(frameId, frameData);
-        }
+        var frames = ((event.args['data'] && event.args['data']['frames']) || []);
+        frames.forEach(payload => this._addPageFrame(event, payload));
       } else if (event.name === WebInspector.TimelineModel.DevToolsMetadataEvent.TracingSessionIdForWorker) {
         workersDevToolsMetadataEvents.push(event);
       } else if (event.name === WebInspector.TimelineModel.DevToolsMetadataEvent.TracingStartedInBrowser) {
         console.assert(!this._mainFrameNodeId, 'Multiple sessions in trace');
         this._mainFrameNodeId = event.args['frameTreeNodeId'];
       }
     }
     if (!pageDevToolsMetadataEvents.length) {
       // The trace is probably coming not from DevTools. Make a mock Metadata event.
       var pageMetaEvent = produceTraceStartedInPage ? this._makeMockPageMetadataEvent(tracingModel) : null;
@@ skipping 348 matching lines @@
     if (eventData['stackTrace'])
       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 < timelineData.stackTrace.length; ++i) {
         --timelineData.stackTrace[i].lineNumber;
         --timelineData.stackTrace[i].columnNumber;
       }
     }
-
+    var pageFrameId = WebInspector.TimelineModel.eventFrameId(event);
+    if (!pageFrameId && eventStack.length)
+      pageFrameId = WebInspector.TimelineData.forEvent(eventStack.peekLast()).frameId;
+    timelineData.frameId = pageFrameId || WebInspector.TimelineData.mainFrameId;
     this._asyncEventTracker.processEvent(event);
     switch (event.name) {
       case recordTypes.ResourceSendRequest:
       case recordTypes.WebSocketCreate:
         timelineData.setInitiator(eventStack.peekLast() || null);
         timelineData.url = eventData['url'];
         break;
 
       case recordTypes.ScheduleStyleRecalculation:
         this._lastScheduleStyleRecalculation[eventData['frame']] = event;
@@ skipping 128 matching lines @@
           return false;
         break;
 
       case recordTypes.CommitLoad:
         var frameId = WebInspector.TimelineModel.eventFrameId(event);
         var pageFrame = this._pageFrames.get(frameId);
         if (pageFrame) {
           pageFrame.url = eventData.url || '';
           pageFrame.name = eventData.name || '';
         } else {
-          var processId = event.thread.process().id();
-          this._pageFrames.set(frameId, {url: eventData.url || '', processId: processId, frameId: eventData.frame, name: eventData.name || ''});
+          this._addPageFrame(event, eventData);
         }
         var page = eventData['page'];
         if (page && page !== this._currentPage)
           return false;
         if (!eventData['isMainFrame'])
           break;
         this._hadCommitLoad = true;
         this._firstCompositeLayers = null;
         break;
 
@@ skipping 95 matching lines @@
    * @param {!Map<!WebInspector.TimelineModel.AsyncEventGroup, !Array<!WebInspector.TracingModel.AsyncEvent>>} source
    */
   _mergeAsyncEvents(target, source) {
     for (var group of source.keys()) {
       var events = target.get(group) || [];
       events = events.mergeOrdered(source.get(group) || [], WebInspector.TracingModel.Event.compareStartAndEndTime);
       target.set(group, events);
     }
   }
 
+  /**
+   * @param {!WebInspector.TracingModel.Event} event
+   * @param {!Object} payload
+   */
+  _addPageFrame(event, payload) {
+    var processId = event.thread.process().id();
+    var pageFrame = new WebInspector.TimelineModel.PageFrame(this.targetByEvent(event), processId, payload);
+    this._pageFrames.set(pageFrame.id, pageFrame);
+    var parent = payload['parent'] && this._pageFrames.get(`${processId}.${payload['parent']}`);
+    if (parent)
+      parent.addChild(pageFrame);
+  }
+
   reset() {
     this._virtualThreads = [];
     /** @type {!Array<!WebInspector.TracingModel.Event>} */
     this._mainThreadEvents = [];
     /** @type {!Map<!WebInspector.TimelineModel.AsyncEventGroup, !Array<!WebInspector.TracingModel.AsyncEvent>>} */
     this._mainThreadAsyncEventsByGroup = new Map();
     /** @type {!Array<!WebInspector.TracingModel.Event>} */
     this._inspectedTargetEvents = [];
     /** @type {!Array<!WebInspector.TimelineModel.Record>} */
     this._records = [];
@@ skipping 26 matching lines @@
   }
 
   /**
    * @return {number}
    */
   maximumRecordTime() {
     return this._maximumRecordTime;
   }
 
   /**
-   * @return {!Array.<!WebInspector.TracingModel.Event>}
+   * @return {!Array<!WebInspector.TracingModel.Event>}
    */
   inspectedTargetEvents() {
     return this._inspectedTargetEvents;
   }
 
   /**
-   * @return {!Array.<!WebInspector.TracingModel.Event>}
+   * @return {!Array<!WebInspector.TracingModel.Event>}
    */
   mainThreadEvents() {
     return this._mainThreadEvents;
   }
 
   /**
-   * @param {!Array.<!WebInspector.TracingModel.Event>} events
+   * @param {!Array<!WebInspector.TracingModel.Event>} events
    */
   _setMainThreadEvents(events) {
     this._mainThreadEvents = events;
   }
 
   /**
    * @return {!Map<!WebInspector.TimelineModel.AsyncEventGroup, !Array.<!WebInspector.TracingModel.AsyncEvent>>}
    */
   mainThreadAsyncEvents() {
     return this._mainThreadAsyncEventsByGroup;
   }
 
   /**
-   * @return {!Array.<!WebInspector.TimelineModel.VirtualThread>}
+   * @return {!Array<!WebInspector.TimelineModel.VirtualThread>}
    */
   virtualThreads() {
     return this._virtualThreads;
   }
 
   /**
    * @return {boolean}
    */
   isEmpty() {
     return this.minimumRecordTime() === 0 && this.maximumRecordTime() === 0;
@@ skipping 334 matching lines @@
     this._children.push(child);
     child.parent = this;
   }
 };
 
 
 /** @typedef {!{page: !Array<!WebInspector.TracingModel.Event>, workers: !Array<!WebInspector.TracingModel.Event>}} */
 WebInspector.TimelineModel.MetadataEvents;
 
 
-/** @typedef {!{url: string, processId: number, frameId: string, name: string}} */
-WebInspector.TimelineModel.PageFrame;
+WebInspector.TimelineModel.PageFrame = class {
+  /**
+   * @param {?WebInspector.Target} target
+   * @param {number} pid
+   * @param {!Object} payload
+   */
+  constructor(target, pid, payload) {
+    this.frameId = payload['frame'];
+    this.url = payload['url'];
+    this.name = payload['name'];
+    this.processId = pid;
+    this.children = [];
+    /** @type {?WebInspector.TimelineModel.PageFrame} */
+    this.parent = null;
+    this.id = `${this.processId}.${this.frameId}`;
+    this.ownerNode = target && payload['nodeId'] ? new WebInspector.DeferredDOMNode(target, payload['nodeId']) : null;
+  }
+
+  /**
+   * @param {!WebInspector.TimelineModel.PageFrame} child
+   */
+  addChild(child) {
+    this.children.push(child);
+    child.parent = this;
+  }
+};
 
 /**
  * @unrestricted
  */
 WebInspector.TimelineModel.NetworkRequest = class {
   /**
    * @param {!WebInspector.TracingModel.Event} event
    */
   constructor(event) {
     this.startTime = event.name === WebInspector.TimelineModel.RecordType.ResourceSendRequest ? event.startTime : 0;
@@ skipping 496 matching lines @@
     /** @type {?string} */
     this.url = null;
     /** @type {number} */
     this.backendNodeId = 0;
     /** @type {?Array<!Protocol.Runtime.CallFrame>} */
     this.stackTrace = null;
     /** @type {?WebInspector.TracingModel.ObjectSnapshot} */
     this.picture = null;
     /** @type {?WebInspector.TracingModel.Event} */
     this._initiator = null;
+    this.frameId = '';
     /** @type {number|undefined} */
     this.timeWaitingForMainThread;
   }
 
   /**
    * @param {!WebInspector.TracingModel.Event} initiator
    */
   setInitiator(initiator) {
     this._initiator = initiator;
     if (!initiator || this.url)
@@ skipping 32 matching lines @@
   static forEvent(event) {
     var data = event[WebInspector.TimelineData._symbol];
     if (!data) {
       data = new WebInspector.TimelineData();
       event[WebInspector.TimelineData._symbol] = data;
     }
     return data;
   }
 };
 
+WebInspector.TimelineData.mainFrameId = '';
 WebInspector.TimelineData._symbol = Symbol('timelineData');