DevTools: remove timeline presentation model dependency from record.

Source/devtools/front_end/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 14 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 /**
  * @constructor
  * @extends {WebInspector.Object}
+ * @param {!WebInspector.TimelineModel} model
  */
-WebInspector.TimelinePresentationModel = function()
+WebInspector.TimelinePresentationModel = function(model)
 {
+    this._model = model;
     this._filters = [];
+    this._bindings = new WebInspector.TimelinePresentationModel.InterRecordBindings();
     this.reset();
 }
 
 /**
  * @param {!Array.<*>} recordsArray
  * @param {?function(*)|?function(*,number)} preOrderCallback
  * @param {function(*)|function(*,number)=} postOrderCallback
  */
 WebInspector.TimelinePresentationModel.forAllRecords = function(recordsArray, preOrderCallback, postOrderCallback)
 {
@@ skipping 58 matching lines @@
     /**
      * @return {!WebInspector.TimelinePresentationModel.Record}
      */
     rootRecord: function()
     {
         return this._rootRecord;
     },
 
     reset: function()
     {
-        this._rootRecord = new WebInspector.TimelinePresentationModel.Record(this, { type: WebInspector.TimelineModel.RecordType.Root }, null);
-        this._sendRequestRecords = {};
-        this._timerRecords = {};
-        this._requestAnimationFrameRecords = {};
+        var rootPayload = { type: WebInspector.TimelineModel.RecordType.Root };
+        this._rootRecord = new WebInspector.TimelinePresentationModel.Record(this._model, this._bindings, /** @type {!TimelineAgent.TimelineEvent} */ (rootPayload), null);
         this._eventDividerRecords = [];
         this._minimumRecordTime = -1;
-        this._layoutInvalidateStack = {};
-        this._lastScheduleStyleRecalculation = {};
-        this._webSocketCreateRecords = {};
         this._coalescingBuckets = {};
         this._mergingBuffer = new WebInspector.TimelineMergingRecordBuffer();
 
         /** @type {!Array.<!TimelineAgent.TimelineEvent>} */
         this._mainThreadTasks =  ([]);
         /** @type {!Array.<!TimelineAgent.TimelineEvent>} */
         this._gpuThreadTasks = ([]);
+
+        this._bindings._reset();
     },
 
     /**
      * @return {number}
      */
     minimumRecordTime: function()
     {
         return this._minimumRecordTime;
     },
 
@@ skipping 71 matching lines @@
         // 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;
 
         if (WebInspector.TimelineUIUtils.isEventDivider(record))
             this._eventDividerRecords.push(record);
 
-        var formattedRecord = new WebInspector.TimelinePresentationModel.Record(this, record, parentRecord);
+        var formattedRecord = new WebInspector.TimelinePresentationModel.Record(this._model, this._bindings, record, parentRecord);
         if (record.type in WebInspector.TimelinePresentationModel._hiddenRecords) {
             parentRecord.children.pop();
             return null;
         }
 
         formattedRecord.collapsed = parentRecord === this._rootRecord;
         if (coalescingBucket)
             this._coalescingBuckets[coalescingBucket] = formattedRecord;
 
         for (var i = 0; record.children && i < record.children.length; ++i)
@@ skipping 47 matching lines @@
             type: record._record.type,
             startTime: record._record.startTime,
             endTime: record._record.endTime,
             data: { }
         };
         if (record._record.thread)
             rawRecord.thread = "aggregated";
         if (record.type === WebInspector.TimelineModel.RecordType.TimeStamp)
             rawRecord.data.message = record.data.message;
 
-        var coalescedRecord = new WebInspector.TimelinePresentationModel.Record(this, rawRecord, null);
+        var coalescedRecord = new WebInspector.TimelinePresentationModel.Record(this._model, this._bindings, rawRecord, null);
         var parent = record.parent;
 
         coalescedRecord.coalesced = true;
         coalescedRecord.collapsed = true;
         coalescedRecord._children.push(record);
         record.parent = coalescedRecord;
         if (record.hasWarnings() || record.childHasWarnings())
             coalescedRecord._childHasWarnings = true;
 
         coalescedRecord.parent = parent;
@@ skipping 103 matching lines @@
                 return false;
         }
         return !this._searchFilter || this._searchFilter.accept(record);
     },
 
     __proto__: WebInspector.Object.prototype
 }
 
 /**
  * @constructor
- * @param {!WebInspector.TimelinePresentationModel} presentationModel
- * @param {!Object} record
+ */
+WebInspector.TimelinePresentationModel.InterRecordBindings = function()
+{
+    this._reset();
+}
+
+WebInspector.TimelinePresentationModel.InterRecordBindings.prototype = {
+    _reset: function()
+    {
+        this._sendRequestRecords = {};
+        this._timerRecords = {};
+        this._requestAnimationFrameRecords = {};
+        this._layoutInvalidateStack = {};
+        this._lastScheduleStyleRecalculation = {};
+        this._webSocketCreateRecords = {};
+    }
+}
+
+/**
+ * @constructor
+ * @param {!WebInspector.TimelineModel} model
+ * @param {!WebInspector.TimelinePresentationModel.InterRecordBindings} bindings
+ * @param {!TimelineAgent.TimelineEvent} record
  * @param {?WebInspector.TimelinePresentationModel.Record} parentRecord
  */
-WebInspector.TimelinePresentationModel.Record = function(presentationModel, record, parentRecord)
+WebInspector.TimelinePresentationModel.Record = function(model, bindings, record, parentRecord)
 {
-    this._presentationModel = presentationModel;
+    this._model = model;
     this._aggregatedStats = {};
     this._record = /** @type {!TimelineAgent.TimelineEvent} */ (record);
     this._children = [];
     if (parentRecord) {
         this.parent = parentRecord;
         parentRecord.children.push(this);
     }
 
     this._selfTime = this.endTime - this.startTime;
     this._lastChildEndTime = this.endTime;
-    this._startTimeOffset = this.startTime - presentationModel._minimumRecordTime;
+    this._startTimeOffset = this.startTime - model.minimumRecordTime();
 
     if (record.data) {
         if (record.data["url"])
             this.url = record.data["url"];
         if (record.data["rootNode"])
             this._relatedBackendNodeId = record.data["rootNode"];
         else if (record.data["elementId"])
             this._relatedBackendNodeId = record.data["elementId"];
         if (record.data["scriptName"]) {
             this.scriptName = record.data["scriptName"];
             this.scriptLine = record.data["scriptLine"];
         }
     }
 
     if (parentRecord && parentRecord.callSiteStackTrace)
         this.callSiteStackTrace = parentRecord.callSiteStackTrace;
 
     var recordTypes = WebInspector.TimelineModel.RecordType;
     switch (record.type) {
     case recordTypes.ResourceSendRequest:
         // Make resource receive record last since request was sent; make finish record last since response received.
-        presentationModel._sendRequestRecords[record.data["requestId"]] = this;
+        bindings._sendRequestRecords[record.data["requestId"]] = this;
         break;
 
     case recordTypes.ResourceReceiveResponse:
-        var sendRequestRecord = presentationModel._sendRequestRecords[record.data["requestId"]];
+        var sendRequestRecord = bindings._sendRequestRecords[record.data["requestId"]];
         if (sendRequestRecord) // False if we started instrumentation in the middle of request.
             this.url = sendRequestRecord.url;
         break;
 
     case recordTypes.ResourceReceivedData:
     case recordTypes.ResourceFinish:
-        var sendRequestRecord = presentationModel._sendRequestRecords[record.data["requestId"]];
+        var sendRequestRecord = bindings._sendRequestRecords[record.data["requestId"]];
         if (sendRequestRecord) // False for main resource.
             this.url = sendRequestRecord.url;
         break;
 
     case recordTypes.TimerInstall:
         this.timeout = record.data["timeout"];
         this.singleShot = record.data["singleShot"];
-        presentationModel._timerRecords[record.data["timerId"]] = this;
+        bindings._timerRecords[record.data["timerId"]] = this;
         break;
 
     case recordTypes.TimerFire:
-        var timerInstalledRecord = presentationModel._timerRecords[record.data["timerId"]];
+        var timerInstalledRecord = bindings._timerRecords[record.data["timerId"]];
         if (timerInstalledRecord) {
             this.callSiteStackTrace = timerInstalledRecord.stackTrace;
             this.timeout = timerInstalledRecord.timeout;
             this.singleShot = timerInstalledRecord.singleShot;
         }
         break;
 
     case recordTypes.RequestAnimationFrame:
-        presentationModel._requestAnimationFrameRecords[record.data["id"]] = this;
+        bindings._requestAnimationFrameRecords[record.data["id"]] = this;
         break;
 
     case recordTypes.FireAnimationFrame:
-        var requestAnimationRecord = presentationModel._requestAnimationFrameRecords[record.data["id"]];
+        var requestAnimationRecord = bindings._requestAnimationFrameRecords[record.data["id"]];
         if (requestAnimationRecord)
             this.callSiteStackTrace = requestAnimationRecord.stackTrace;
         break;
 
     case recordTypes.ConsoleTime:
         var message = record.data["message"];
         break;
 
     case recordTypes.ScheduleStyleRecalculation:
-        presentationModel._lastScheduleStyleRecalculation[this.frameId] = this;
+        bindings._lastScheduleStyleRecalculation[this.frameId] = this;
         break;
 
     case recordTypes.RecalculateStyles:
-        var scheduleStyleRecalculationRecord = presentationModel._lastScheduleStyleRecalculation[this.frameId];
+        var scheduleStyleRecalculationRecord = bindings._lastScheduleStyleRecalculation[this.frameId];
         if (!scheduleStyleRecalculationRecord)
             break;
         this.callSiteStackTrace = scheduleStyleRecalculationRecord.stackTrace;
         break;
 
     case recordTypes.InvalidateLayout:
         // Consider style recalculation as a reason for layout invalidation,
         // but only if we had no earlier layout invalidation records.
         var styleRecalcStack;
-        if (!presentationModel._layoutInvalidateStack[this.frameId]) {
-            for (var outerRecord = parentRecord; outerRecord; outerRecord = record.parent) {
-                if (outerRecord.type === recordTypes.RecalculateStyles) {
-                    styleRecalcStack = outerRecord.callSiteStackTrace;
-                    break;
-                }
-            }
+        if (!bindings._layoutInvalidateStack[this.frameId]) {
+            if (parentRecord.type === recordTypes.RecalculateStyles)
+                styleRecalcStack = parentRecord.callSiteStackTrace;
         }
-        presentationModel._layoutInvalidateStack[this.frameId] = styleRecalcStack || this.stackTrace;
+        bindings._layoutInvalidateStack[this.frameId] = styleRecalcStack || this.stackTrace;
         break;
 
     case recordTypes.Layout:
-        var layoutInvalidateStack = presentationModel._layoutInvalidateStack[this.frameId];
+        var layoutInvalidateStack = bindings._layoutInvalidateStack[this.frameId];
         if (layoutInvalidateStack)
             this.callSiteStackTrace = layoutInvalidateStack;
         if (this.stackTrace)
             this.addWarning(WebInspector.UIString("Forced synchronous layout is a possible performance bottleneck."));
 
-        presentationModel._layoutInvalidateStack[this.frameId] = null;
+        bindings._layoutInvalidateStack[this.frameId] = null;
         this.highlightQuad = record.data.root || WebInspector.TimelinePresentationModel.quadFromRectData(record.data);
         this._relatedBackendNodeId = record.data["rootNode"];
         break;
 
     case recordTypes.AutosizeText:
         if (record.data.needsRelayout && parentRecord.type === recordTypes.Layout)
             parentRecord.addWarning(WebInspector.UIString("Layout required two passes due to text autosizing, consider setting viewport."));
         break;
 
     case recordTypes.Paint:
         this.highlightQuad = record.data.clip || WebInspector.TimelinePresentationModel.quadFromRectData(record.data);
         break;
 
     case recordTypes.WebSocketCreate:
         this.webSocketURL = record.data["url"];
         if (typeof record.data["webSocketProtocol"] !== "undefined")
             this.webSocketProtocol = record.data["webSocketProtocol"];
-        presentationModel._webSocketCreateRecords[record.data["identifier"]] = this;
+        bindings._webSocketCreateRecords[record.data["identifier"]] = this;
         break;
 
     case recordTypes.WebSocketSendHandshakeRequest:
     case recordTypes.WebSocketReceiveHandshakeResponse:
     case recordTypes.WebSocketDestroy:
-        var webSocketCreateRecord = presentationModel._webSocketCreateRecords[record.data["identifier"]];
+        var webSocketCreateRecord = bindings._webSocketCreateRecords[record.data["identifier"]];
         if (webSocketCreateRecord) { // False if we started instrumentation in the middle of request.
             this.webSocketURL = webSocketCreateRecord.webSocketURL;
             if (typeof webSocketCreateRecord.webSocketProtocol !== "undefined")
                 this.webSocketProtocol = webSocketCreateRecord.webSocketProtocol;
         }
         break;
 
     case recordTypes.EmbedderCallback:
         this.embedderCallbackName = record.data["callbackName"];
         break;
@@ skipping 59 matching lines @@
     get category()
     {
         return WebInspector.TimelineUIUtils.categoryForRecord(this._record);
     },
 
     /**
      * @return {string}
      */
     title: function()
     {
-        return WebInspector.TimelineUIUtils.recordTitle(this._presentationModel, this._record);
+        return WebInspector.TimelineUIUtils.recordTitle(this._model, this._record);
     },
 
     /**
      * @return {number}
      */
     get startTime()
     {
         return this._record.startTime;
     },
 
@@ skipping 551 matching lines @@
 {
 }
 
 WebInspector.TimelinePresentationModel.Filter.prototype = {
     /**
      * @param {!WebInspector.TimelinePresentationModel.Record} record
      * @return {boolean}
      */
     accept: function(record) { return false; }
 }