Don't create TimelineModel.RecordImpl in TimelinePresentationModel.js

Source/devtools/front_end/timeline/TimelinePresentationModel.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 65 matching lines @@
      * @return {!WebInspector.TimelinePresentationModel.Record}
      */
     rootRecord: function()
     {
         return this._rootRecord;
     },
 
     reset: function()
     {
         this._recordToPresentationRecord.clear();
-        var rootPayload = { type: WebInspector.TimelineModel.RecordType.Root };
-        var rootRecord = new WebInspector.TimelineModel.RecordImpl(this._model, /** @type {!TimelineAgent.TimelineEvent} */ (rootPayload), null);
-        this._rootRecord = new WebInspector.TimelinePresentationModel.Record(rootRecord, null);
+        this._rootRecord = new WebInspector.TimelinePresentationModel.RootRecord();
         /** @type {!Object.<string, !WebInspector.TimelinePresentationModel.Record>} */
         this._coalescingBuckets = {};
     },
 
     /**
      * @param {!WebInspector.TimelineModel.Record} record
      */
     addRecord: function(record)
     {
         var records;
@@ skipping 14 matching lines @@
     {
         var coalescingBucket;
 
         // On main thread, only coalesce if the last event is of same type.
         if (parentRecord === this._rootRecord)
             coalescingBucket = record.thread() ? record.type() : "mainThread";
         var coalescedRecord = this._findCoalescedParent(record, parentRecord, coalescingBucket);
         if (coalescedRecord)
             parentRecord = coalescedRecord;
 
-        var formattedRecord = new WebInspector.TimelinePresentationModel.Record(record, parentRecord);
+        var formattedRecord = new WebInspector.TimelinePresentationModel.ActualRecord(record, parentRecord);
         this._recordToPresentationRecord.put(record, formattedRecord);
 
         formattedRecord._collapsed = parentRecord === this._rootRecord;
         if (coalescingBucket)
             this._coalescingBuckets[coalescingBucket] = formattedRecord;
 
         for (var i = 0; record.children() && i < record.children().length; ++i)
             this._innerAddRecord(formattedRecord, record.children()[i]);
 
-        if (parentRecord._coalesced)
+        if (parentRecord.coalesced())
             this._updateCoalescingParent(formattedRecord);
     },
 
     /**
      * @param {!WebInspector.TimelineModel.Record} record
      * @param {!WebInspector.TimelinePresentationModel.Record} newParent
      * @param {string=} bucket
      * @return {?WebInspector.TimelinePresentationModel.Record}
      */
     _findCoalescedParent: function(record, newParent, bucket)
     {
         const coalescingThresholdMillis = 5;
 
         var lastRecord = bucket ? this._coalescingBuckets[bucket] : newParent._presentationChildren.peekLast();
-        if (lastRecord && lastRecord._coalesced)
+        if (lastRecord && lastRecord.coalesced())
             lastRecord = lastRecord._presentationChildren.peekLast();
         var startTime = record.startTime();
         var endTime = record.endTime();
         if (!lastRecord)
             return null;
         if (lastRecord.record().type() !== record.type())
             return null;
         if (!WebInspector.TimelinePresentationModel._coalescingRecords[record.type()])
             return null;
         if (lastRecord.record().endTime() + coalescingThresholdMillis < startTime)
             return null;
         if (endTime + coalescingThresholdMillis < lastRecord.record().startTime())
             return null;
-        if (lastRecord.presentationParent()._coalesced)
+        if (lastRecord.presentationParent().coalesced())
             return lastRecord.presentationParent();
         return this._replaceWithCoalescedRecord(lastRecord);
     },
 
     /**
      * @param {!WebInspector.TimelinePresentationModel.Record} presentationRecord
      * @return {!WebInspector.TimelinePresentationModel.Record}
      */
     _replaceWithCoalescedRecord: function(presentationRecord)
     {
         var record = presentationRecord.record();
-        var rawRecord = {
-            type: record.type(),
-            startTime: record.startTime(),
-            data: { }
-        };
-        if (record.thread())
-            rawRecord.thread = "aggregated";
-        if (record.type() === WebInspector.TimelineModel.RecordType.TimeStamp)
-            rawRecord.data["message"] = record.data().message;
+        var parent = presentationRecord._presentationParent;
+        var coalescedRecord = new WebInspector.TimelinePresentationModel.CoalescedRecord(record);
 
-        var modelRecord = new WebInspector.TimelineModel.RecordImpl(this._model, /** @type {!TimelineAgent.TimelineEvent} */ (rawRecord), null);
-        var coalescedRecord = new WebInspector.TimelinePresentationModel.Record(modelRecord, null);
-        var parent = presentationRecord._presentationParent;
-
-        coalescedRecord._coalesced = true;
         coalescedRecord._collapsed = true;
         coalescedRecord._presentationChildren.push(presentationRecord);
         presentationRecord._presentationParent = coalescedRecord;
         if (presentationRecord.hasWarnings() || presentationRecord.childHasWarnings())
             coalescedRecord._childHasWarnings = true;
 
         coalescedRecord._presentationParent = parent;
         parent._presentationChildren[parent._presentationChildren.indexOf(presentationRecord)] = coalescedRecord;
-        WebInspector.TimelineUIUtils.aggregateTimeByCategory(modelRecord.aggregatedStats(), record.aggregatedStats());
+        WebInspector.TimelineUIUtils.aggregateTimeByCategory(coalescedRecord.presentationAggregatedStats(), presentationRecord.presentationAggregatedStats());
 
         return coalescedRecord;
     },
 
     /**
      * @param {!WebInspector.TimelinePresentationModel.Record} presentationRecord
      */
     _updateCoalescingParent: function(presentationRecord)
     {
-        var record = presentationRecord.record();
-        var parentRecord = presentationRecord._presentationParent.record();
-        WebInspector.TimelineUIUtils.aggregateTimeByCategory(parentRecord.aggregatedStats(), record.aggregatedStats());
+        var record = presentationRecord;

[caseq, 2014/06/16 12:26:33]

nit: remove this and inline presentationRecord in the code below?

[yurys, 2014/06/16 12:32:37]

Done.

+        var parentRecord = presentationRecord._presentationParent;
+        WebInspector.TimelineUIUtils.aggregateTimeByCategory(parentRecord.presentationAggregatedStats(), record.presentationAggregatedStats());
         if (parentRecord.endTime() < record.endTime())
-            parentRecord.setEndTime(record.endTime());
+            parentRecord._endTime = record.endTime();
     },
 
     /**
      * @param {?RegExp} textFilter
      */
     setTextFilter: function(textFilter)
     {
         this._textFilter = textFilter;
     },
 
@@ skipping 28 matching lines @@
                 revealedDepth = depth;
             }
         }
 
         while (stack.length) {
             var entry = stack[stack.length - 1];
             var records = entry.children;
             if (records && entry.index < records.length) {
                 var record = records[entry.index];
                 ++entry.index;
-                var rawRecord = record.record();
-                if (rawRecord.startTime() < this._windowEndTime && rawRecord.endTime() > this._windowStartTime) {
-                    if (this._model.isVisible(rawRecord)) {
+                if (record.startTime() < this._windowEndTime && record.endTime() > this._windowStartTime) {
+                    if (this._model.isVisible(record.record())) {
                         record._presentationParent._expandable = true;
                         if (this._textFilter)
                             revealRecordsInStack();
                         if (!entry.parentIsCollapsed) {
                             recordsInWindow.push(record);
                             revealedDepth = stack.length;
                             entry.parentRecord._collapsed = false;
                         }
                     }
                 }
@@ skipping 14 matching lines @@
 
         this._filteredRecords = recordsInWindow;
         return recordsInWindow;
     },
 
     __proto__: WebInspector.Object.prototype
 }
 
 /**
  * @constructor
- * @param {!WebInspector.TimelineModel.Record} record
  * @param {?WebInspector.TimelinePresentationModel.Record} parentRecord
  */
-WebInspector.TimelinePresentationModel.Record = function(record, parentRecord)
+WebInspector.TimelinePresentationModel.Record = function(parentRecord)
 {
-    this._record = record;
     /**
      * @type {!Array.<!WebInspector.TimelinePresentationModel.Record>}
      */
     this._presentationChildren = [];
 
     if (parentRecord) {
         this._presentationParent = parentRecord;
         parentRecord._presentationChildren.push(this);
     }
-
-    if (this.hasWarnings()) {
-        for (var parent = this._presentationParent; parent && !parent._childHasWarnings; parent = parent._presentationParent)
-            parent._childHasWarnings = true;
-    }
 }
 
 WebInspector.TimelinePresentationModel.Record.prototype = {
     /**
+     * @return {number}
+     */
+    startTime: function()
+    {
+        throw new Error("Not implemented.");
+    },
+
+    /**
+     * @return {number}
+     */
+    endTime: function()
+    {
+        throw new Error("Not implemented.");
+    },
+
+    /**
+     * @return {number}
+     */
+    selfTime: function()
+    {
+        throw new Error("Not implemented.");
+    },
+
+    /**
      * @return {!WebInspector.TimelineModel.Record}
      */
     record: function()
     {
-        return this._record;
+        throw new Error("Not implemented.");
     },
 
     /**
+     * @return {!Object.<string, number>}
+     */
+    presentationAggregatedStats: function()
+    {
+        throw new Error("Not implemented.");
+    },
+
+    /**
      * @return {!Array.<!WebInspector.TimelinePresentationModel.Record>}
      */
     presentationChildren: function()
     {
         return this._presentationChildren;
     },
 
     /**
      * @return {boolean}
      */
     coalesced: function()
     {
-        return this._coalesced;
+        return false;
     },
 
     /**
      * @return {boolean}
      */
     collapsed: function()
     {
         return this._collapsed;
     },
 
@@ skipping 28 matching lines @@
     expandable: function()
     {
         return !!this._expandable;
     },
 
     /**
      * @return {boolean}
      */
     hasWarnings: function()
     {
-        return !!this._record.warnings();
+        return false;
     },
 
     /**
      * @return {boolean}
      */
     childHasWarnings: function()
     {
         return this._childHasWarnings;
     },
 
@@ skipping 20 matching lines @@
     {
         return this._graphRow;
     },
 
     /**
      * @param {!WebInspector.TimelineRecordGraphRow} graphRow
      */
     setGraphRow: function(graphRow)
     {
         this._graphRow = graphRow;
+    },
+
+    /**
+     * @return {string}
+     */
+    toString: function()
+    {
+        return "Record";
+    },
+
+    /**
+     * @param {string} prefix
+     * @return {string}
+     */
+    dump: function(prefix)

[caseq, 2014/06/16 12:26:33]

How is this used?

[yurys, 2014/06/16 12:32:37]

I used it for debugging. Removed.

+    {
+        prefix = prefix || "  ";
+        var result = prefix + this.toString();
+        result += "\n";
+        prefix += "  ";
+        for (var i = 0; i < this.presentationChildren().length; i++) {
+            result += this.presentationChildren()[i].dump(prefix);
+        }
+        return result;
     }
 }
+
+/**
+ * @constructor
+ * @extends {WebInspector.TimelinePresentationModel.Record}
+ * @param {!WebInspector.TimelineModel.Record} record
+ * @param {?WebInspector.TimelinePresentationModel.Record} parentRecord
+ */
+WebInspector.TimelinePresentationModel.ActualRecord = function(record, parentRecord)
+{
+    WebInspector.TimelinePresentationModel.Record.call(this, parentRecord);
+    this._record = record;
+
+    if (this.hasWarnings()) {
+        for (var parent = this._presentationParent; parent && !parent._childHasWarnings; parent = parent._presentationParent)
+            parent._childHasWarnings = true;
+    }
+}
+
+WebInspector.TimelinePresentationModel.ActualRecord.prototype = {
+    /**
+     * @return {number}
+     */
+    startTime: function()
+    {
+        return this._record.startTime();
+    },
+
+    /**
+     * @return {number}
+     */
+    endTime: function()
+    {
+        return this._record.endTime();
+    },
+
+    /**
+     * @return {number}
+     */
+    selfTime: function()
+    {
+        return this._record.selfTime();
+    },
+
+    /**
+     * @return {!WebInspector.TimelineModel.Record}
+     */
+    record: function()
+    {
+        return this._record;
+    },
+
+    /**
+     * @return {!Object.<string, number>}
+     */
+    presentationAggregatedStats: function()
+    {
+        return this._record.aggregatedStats();
+    },
+
+    /**
+     * @return {boolean}
+     */
+    hasWarnings: function()
+    {
+        return !!this._record.warnings();
+    },
+
+    /**
+     * @return {string}
+     */
+    toString: function()

[caseq, 2014/06/16 12:26:33]

is thus used?

[yurys, 2014/06/16 12:32:37]

Not anymore. Removed.

+    {
+        return "ActualRecord: " + this._record.type();
+    },
+
+    __proto__: WebInspector.TimelinePresentationModel.Record.prototype
+}
+
+/**
+ * @constructor
+ * @extends {WebInspector.TimelinePresentationModel.Record}
+ * @param {!WebInspector.TimelineModel.Record} record
+ */
+WebInspector.TimelinePresentationModel.CoalescedRecord = function(record)
+{
+    WebInspector.TimelinePresentationModel.Record.call(this, null);
+    this._startTime = record.startTime();
+    this._endTime = record.endTime();
+    this._aggregatedStats = {};
+}
+
+WebInspector.TimelinePresentationModel.CoalescedRecord.prototype = {
+    /**
+     * @return {number}
+     */
+    startTime: function()
+    {
+        return this._startTime;
+    },
+
+    /**
+     * @return {number}
+     */
+    endTime: function()
+    {
+        return this._endTime;
+    },
+
+    /**
+     * @return {number}
+     */
+    selfTime: function()
+    {
+        return 0;
+    },
+
+    /**
+     * @return {!WebInspector.TimelineModel.Record}
+     */
+    record: function()
+    {
+        return this._presentationChildren[0].record();
+    },
+
+    /**
+     * @return {!Object.<string, number>}
+     */
+    presentationAggregatedStats: function()
+    {
+        return this._aggregatedStats;
+    },
+
+    /**
+     * @return {boolean}
+     */
+    coalesced: function()
+    {
+        return true;
+    },
+
+    /**
+     * @return {boolean}
+     */
+    hasWarnings: function()
+    {
+        return false;
+    },
+
+    /**
+     * @return {string}
+     */
+    toString: function()
+    {
+        return "CoalescedRecord";
+    },
+
+    __proto__: WebInspector.TimelinePresentationModel.Record.prototype
+}
+
+/**
+ * @constructor
+ * @extends {WebInspector.TimelinePresentationModel.Record}
+ */
+WebInspector.TimelinePresentationModel.RootRecord = function()
+{
+    WebInspector.TimelinePresentationModel.Record.call(this, null);
+    this._aggregatedStats = {};
+}
+
+WebInspector.TimelinePresentationModel.RootRecord.prototype = {
+    /**
+     * @return {!Object.<string, number>}
+     */
+    presentationAggregatedStats: function()
+    {
+        return this._aggregatedStats;
+    },
+
+    /**
+     * @return {boolean}
+     */
+    hasWarnings: function()
+    {
+        return false;
+    },
+
+    /**
+     * @return {string}
+     */
+    toString: function()
+    {
+        return "RootRecord";
+    },
+
+    __proto__: WebInspector.TimelinePresentationModel.Record.prototype
+}