DevTools: remove most convenience wrappers from WI.TimelineModel.Record

Source/devtools/front_end/timeline/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 29 matching lines @@
 {
     WebInspector.Object.call(this);
     this._filters = [];
     this._tracingModel = tracingModel;
     this._recordFilter = recordFilter;
     this._targets = [];
     this.reset();
     WebInspector.targetManager.observeTargets(this);
 }
 
+/**
+ * @enum {string}
+ */
 WebInspector.TimelineModel.RecordType = {
     Task: "Task",
     Program: "Program",
     EventDispatch: "EventDispatch",
 
     GPUTask: "GPUTask",
 
     Animation: "Animation",
     RequestMainThreadFrame: "RequestMainThreadFrame",
     BeginFrame: "BeginFrame",
@@ skipping 187 matching lines @@
      * @return {boolean}
      */
     isWorker: function()
     {
         return this.name === WebInspector.TimelineModel.WorkerThreadName;
     }
 }
 
 /**
  * @constructor
- * @param {!WebInspector.TimelineModel} model
  * @param {!WebInspector.TracingModel.Event} traceEvent
  */
-WebInspector.TimelineModel.Record = function(model, traceEvent)
+WebInspector.TimelineModel.Record = function(traceEvent)
 {
-    this._model = model;
     this._event = traceEvent;
-    traceEvent._timelineRecord = this;
     this._children = [];
 }
 
 /**
  * @param {!WebInspector.TimelineModel.Record} a
  * @param {!WebInspector.TimelineModel.Record} b
  * @return {number}
  */
 WebInspector.TimelineModel.Record._compareStartTime = function(a, b)
 {
     // Never return 0 as otherwise equal records would be merged.
     return a.startTime() <= b.startTime() ? -1 : 1;
 }
 
 WebInspector.TimelineModel.Record.prototype = {
     /**
-     * @return {?Array.<!ConsoleAgent.CallFrame>}
-     */
-    callSiteStackTrace: function()
-    {
-        var initiator = this._event.initiator;
-        return initiator ? initiator.stackTrace : null;
-    },
-
-    /**
-     * @return {?WebInspector.TimelineModel.Record}
-     */
-    initiator: function()
-    {
-        var initiator = this._event.initiator;
-        return initiator ? initiator._timelineRecord : null;
-    },
-
-    /**
      * @return {?WebInspector.Target}
      */
     target: function()
     {
         var threadName = this._event.thread.name();
         //FIXME: correctly specify target
         return threadName === WebInspector.TimelineModel.RendererMainThreadName ? WebInspector.targetManager.targets()[0] || null : null;
     },
 
     /**
-     * @return {number}
-     */
-    selfTime: function()
-    {
-        return this._event.selfTime;
-    },
-
-    /**
      * @return {!Array.<!WebInspector.TimelineModel.Record>}
      */
     children: function()
     {
         return this._children;
     },
 
     /**
      * @return {number}
      */
     startTime: function()
     {
         return this._event.startTime;
     },
 
     /**
+     * @return {number}
+     */
+    endTime: function()
+    {
+        return this._event.endTime || this._event.startTime;
+    },
+
+    /**
      * @return {string}
      */
     thread: function()
     {
         if (this._event.thread.name() === WebInspector.TimelineModel.RendererMainThreadName)
             return WebInspector.TimelineModel.MainThreadName;
         return this._event.thread.name();
     },
 
     /**
-     * @return {number}
-     */
-    endTime: function()
-    {
-        return this._endTime || this._event.endTime || this._event.startTime;
-    },
-
-    /**
-     * @param {number} endTime
-     */
-    setEndTime: function(endTime)
-    {
-        this._endTime = endTime;
-    },
-
-    /**
-     * @return {!Object}
-     */
-    data: function()
-    {
-        return this._event.args["data"];
-    },
-
-    /**
-     * @return {string}
+     * @return {!WebInspector.TimelineModel.RecordType}
      */
     type: function()
     {
         if (this._event.hasCategory(WebInspector.TracingModel.ConsoleEventCategory))
             return WebInspector.TimelineModel.RecordType.ConsoleTime;
-        return this._event.name;
+        return /** @type !WebInspector.TimelineModel.RecordType */ (this._event.name);
     },
 
     /**
-     * @return {string}
-     */
-    frameId: function()
-    {
-        switch (this._event.name) {
-        case WebInspector.TimelineModel.RecordType.UpdateLayoutTree:
-        case WebInspector.TimelineModel.RecordType.RecalculateStyles:
-        case WebInspector.TimelineModel.RecordType.Layout:
-            return this._event.args["beginData"]["frame"];
-        default:
-            var data = this._event.args["data"];
-            return (data && data["frame"]) || "";
-        }
-    },
-
-    /**
-     * @return {?Array.<!ConsoleAgent.CallFrame>}
-     */
-    stackTrace: function()
-    {
-        return this._event.stackTrace;
-    },
-
-    /**
      * @param {string} key
      * @return {?Object}
      */
     getUserObject: function(key)
     {
         if (key === "TimelineUIUtils::preview-element")
             return this._event.previewElement;
         throw new Error("Unexpected key: " + key);
     },
 
     /**
      * @param {string} key
      * @param {?Object|undefined} value
      */
     setUserObject: function(key, value)
     {
         if (key !== "TimelineUIUtils::preview-element")
             throw new Error("Unexpected key: " + key);
         this._event.previewElement = /** @type {?Element} */ (value);
     },
 
     /**
-     * @return {?Array.<string>}
-     */
-    warnings: function()
-    {
-        if (this._event.warning)
-            return [this._event.warning];
-        return null;
-    },
-
-    /**
      * @return {!WebInspector.TracingModel.Event}
      */
     traceEvent: function()
     {
         return this._event;
     },
 
     /**
      * @param {!WebInspector.TimelineModel.Record} child
      */
     _addChild: function(child)
     {
         this._children.push(child);
         child.parent = this;
     },
-
-    /**
-     * @return {!WebInspector.TimelineModel}
-     */
-    timelineModel: function()
-    {
-        return this._model;
-    }
 }
 
 /** @typedef {!{page: !Array<!WebInspector.TracingModel.Event>, workers: !Array<!WebInspector.TracingModel.Event>}} */
 WebInspector.TimelineModel.MetadataEvents;
 
 WebInspector.TimelineModel.prototype = {
     /**
      * @param {boolean} captureCauses
      * @param {boolean} enableJSSampling
      * @param {boolean} captureMemory
@@ skipping 464 matching lines @@
 
         // First Paint is actually a DrawFrame that happened after first CompositeLayers following last CommitLoadEvent.
         var recordTypes = WebInspector.TimelineModel.RecordType;
         var i = insertionIndexForObjectInListSortedByFunction(this._firstCompositeLayers, this._inspectedTargetEvents, WebInspector.TracingModel.Event.compareStartTime);
         for (; i < this._inspectedTargetEvents.length && this._inspectedTargetEvents[i].name !== recordTypes.DrawFrame; ++i) { }
         if (i >= this._inspectedTargetEvents.length)
             return;
         var drawFrameEvent = this._inspectedTargetEvents[i];
         var firstPaintEvent = new WebInspector.TracingModel.Event(drawFrameEvent.categoriesString, recordTypes.MarkFirstPaint, WebInspector.TracingModel.Phase.Instant, drawFrameEvent.startTime, drawFrameEvent.thread);
         this._mainThreadEvents.splice(insertionIndexForObjectInListSortedByFunction(firstPaintEvent, this._mainThreadEvents, WebInspector.TracingModel.Event.compareStartTime), 0, firstPaintEvent);
-        var firstPaintRecord = new WebInspector.TimelineModel.Record(this, firstPaintEvent);
+        var firstPaintRecord = new WebInspector.TimelineModel.Record(firstPaintEvent);
         this._eventDividerRecords.splice(insertionIndexForObjectInListSortedByFunction(firstPaintRecord, this._eventDividerRecords, WebInspector.TimelineModel.Record._compareStartTime), 0, firstPaintRecord);
     },
 
     _buildTimelineRecords: function()
     {
         var topLevelRecords = this._buildTimelineRecordsForThread(this.mainThreadEvents());
         for (var i = 0; i < topLevelRecords.length; i++) {
             var record = topLevelRecords[i];
             if (WebInspector.TracingModel.isTopLevelEvent(record.traceEvent()))
                 this._mainThreadTasks.push(record);
@@ skipping 17 matching lines @@
         var gpuProcess = this._tracingModel.processByName("GPU Process");
         if (!gpuProcess)
             return;
         var mainThread = gpuProcess.threadByName("CrGpuMain");
         if (!mainThread)
             return;
         var events = mainThread.events();
         var recordTypes = WebInspector.TimelineModel.RecordType;
         for (var i = 0; i < events.length; ++i) {
             if (events[i].name === recordTypes.GPUTask)
-                this._gpuTasks.push(new WebInspector.TimelineModel.Record(this, events[i]));
+                this._gpuTasks.push(new WebInspector.TimelineModel.Record(events[i]));
         }
     },
 
     /**
      * @param {!Array.<!WebInspector.TracingModel.Event>} threadEvents
      * @return {!Array.<!WebInspector.TimelineModel.Record>}
      */
     _buildTimelineRecordsForThread: function(threadEvents)
     {
         var recordStack = [];
         var topLevelRecords = [];
 
         for (var i = 0, size = threadEvents.length; i < size; ++i) {
             var event = threadEvents[i];
             for (var top = recordStack.peekLast(); top && top._event.endTime <= event.startTime; top = recordStack.peekLast())
                 recordStack.pop();
             if (event.phase === WebInspector.TracingModel.Phase.AsyncEnd || event.phase === WebInspector.TracingModel.Phase.NestableAsyncEnd)
                 continue;
             var parentRecord = recordStack.peekLast();
             // Maintain the back-end logic of old timeline, skip console.time() / console.timeEnd() that are not properly nested.
             if (WebInspector.TracingModel.isAsyncBeginPhase(event.phase) && parentRecord && event.endTime > parentRecord._event.endTime)
                 continue;
-            var record = new WebInspector.TimelineModel.Record(this, event);
+            var record = new WebInspector.TimelineModel.Record(event);
             if (WebInspector.TimelineUIUtils.isMarkerEvent(event))
                 this._eventDividerRecords.push(record);
             if (!this._recordFilter.accept(record) && !WebInspector.TracingModel.isTopLevelEvent(event))
                 continue;
             if (parentRecord)
                 parentRecord._addChild(record);
             else
                 topLevelRecords.push(record);
             if (event.endTime)
                 recordStack.push(record);
@@ skipping 1444 matching lines @@
         /** @type {!Object.<string, !Array.<!WebInspector.InvalidationTrackingEvent>>} */
         this._invalidations = {};
         /** @type {!Object.<number, !Array.<!WebInspector.InvalidationTrackingEvent>>} */
         this._invalidationsByNodeId = {};
 
         this._lastRecalcStyle = undefined;
         this._lastPaintWithLayer = undefined;
         this._didPaint = false;
     }
 }