DevTools: extract TimelineModel.Record from TimelinePresentationModel.Record.

Source/devtools/front_end/TimelineFrameModel.js

 /*
  * Copyright (C) 2013 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 20 matching lines @@
 /**
  * @constructor
  * @extends {WebInspector.Object}
  * @param {!WebInspector.TimelineModel} model
  */
 WebInspector.TimelineFrameModel = function(model)
 {
     this._model = model;
 
     this.reset();
-    var records = model.records;
+    var records = model.records();
     for (var i = 0; i < records.length; ++i)
         this.addRecord(records[i]);
 }
 
 WebInspector.TimelineFrameModel.Events = {
     FrameAdded: "FrameAdded"
 }
 
 WebInspector.TimelineFrameModel.prototype = {
     /**
@@ skipping 30 matching lines @@
         this._frames = [];
         this._lastFrame = null;
         this._hasThreadedCompositing = false;
         this._mainFrameCommitted = false;
         this._mainFrameRequested = false;
         this._aggregatedMainThreadWork = null;
         this._mergingBuffer = new WebInspector.TimelineMergingRecordBuffer();
     },
 
     /**
-     * @param {!TimelineAgent.TimelineEvent} record
+     * @param {!WebInspector.TimelineModel.Record} record
      */
     addRecord: function(record)
     {
         var recordTypes = WebInspector.TimelineModel.RecordType;
         var programRecord = record.type === recordTypes.Program ? record : null;
 
         // Start collecting main frame
         if (programRecord) {
             if (!this._aggregatedMainThreadWork && this._findRecordRecursively([recordTypes.ScheduleStyleRecalculation, recordTypes.InvalidateLayout, recordTypes.BeginFrame], programRecord))
                 this._aggregatedMainThreadWork = {};
         }
 
         var records = this._mergingBuffer.process(record.thread, programRecord ? record.children || [] : [record]);
         for (var i = 0; i < records.length; ++i) {
             if (records[i].thread)
                 this._addBackgroundRecord(records[i]);
             else
                 this._addMainThreadRecord(programRecord, records[i]);
         }
     },
 
     /**
-     * @param {!TimelineAgent.TimelineEvent} record
+     * @param {!WebInspector.TimelineModel.Record} record
      */
     _addBackgroundRecord: function(record)
     {
         var recordTypes = WebInspector.TimelineModel.RecordType;
         if (!this._lastFrame) {
             if (record.type === recordTypes.BeginFrame || record.type === recordTypes.DrawFrame)
                 this._startBackgroundFrame(record);
             return;
         }
 
         if (record.type === recordTypes.DrawFrame) {
             // - if it wasn't drawn, it didn't happen!
             // - only show frames that either did not wait for the main thread frame or had one committed.
             if (this._mainFrameCommitted || !this._mainFrameRequested)
                 this._startBackgroundFrame(record);
             this._mainFrameCommitted = false;
         } else if (record.type === recordTypes.RequestMainThreadFrame) {
             this._mainFrameRequested = true;
         } else if (record.type === recordTypes.ActivateLayerTree) {
             this._mainFrameRequested = false;
             this._mainFrameCommitted = true;
             this._lastFrame._addTimeForCategories(this._aggregatedMainThreadWorkToAttachToBackgroundFrame);
             this._aggregatedMainThreadWorkToAttachToBackgroundFrame = {};
         }
         this._lastFrame._addTimeFromRecord(record);
     },
 
     /**
-     * @param {?TimelineAgent.TimelineEvent} programRecord
-     * @param {!TimelineAgent.TimelineEvent} record
+     * @param {?WebInspector.TimelineModel.Record} programRecord
+     * @param {!WebInspector.TimelineModel.Record} record
      */
     _addMainThreadRecord: function(programRecord, record)
     {
         var recordTypes = WebInspector.TimelineModel.RecordType;
         if (!this._hasThreadedCompositing) {
             if (record.type === recordTypes.BeginFrame)
                 this._startMainThreadFrame(record);
 
             if (!this._lastFrame)
                 return;
@@ skipping 15 matching lines @@
         if (programRecord.children[0] === record)
             this._deriveOtherTime(programRecord, this._aggregatedMainThreadWork);
 
         if (record.type === recordTypes.CompositeLayers) {
             this._aggregatedMainThreadWorkToAttachToBackgroundFrame = this._aggregatedMainThreadWork;
             this._aggregatedMainThreadWork = null;
         }
     },
 
     /**
-     * @param {!TimelineAgent.TimelineEvent} programRecord
+     * @param {!WebInspector.TimelineModel.Record} programRecord
      * @param {!Object} timeByCategory
      */
     _deriveOtherTime: function(programRecord, timeByCategory)
     {
         var accounted = 0;
         for (var i = 0; i < programRecord.children.length; ++i)
             accounted += programRecord.children[i].endTime - programRecord.children[i].startTime;
         var otherTime = programRecord.endTime - programRecord.startTime - accounted;
         timeByCategory["other"] = (timeByCategory["other"] || 0) + otherTime;
     },
 
     /**
-     * @param {!TimelineAgent.TimelineEvent} record
+     * @param {!WebInspector.TimelineModel.Record} record
      */
     _startBackgroundFrame: function(record)
     {
         if (!this._hasThreadedCompositing) {
             this._lastFrame = null;
             this._hasThreadedCompositing = true;
         }
         if (this._lastFrame)
             this._flushFrame(this._lastFrame, record);
 
         this._lastFrame = new WebInspector.TimelineFrame(this, record);
     },
 
     /**
-     * @param {!TimelineAgent.TimelineEvent} record
+     * @param {!WebInspector.TimelineModel.Record} record
      */
     _startMainThreadFrame: function(record)
     {
         if (this._lastFrame)
             this._flushFrame(this._lastFrame, record);
         this._lastFrame = new WebInspector.TimelineFrame(this, record);
     },
 
     /**
      * @param {!WebInspector.TimelineFrame} frame
      * @param {!Object} record
      */
     _flushFrame: function(frame, record)
     {
         frame._setEndTime(record.startTime);
         this._frames.push(frame);
         this.dispatchEventToListeners(WebInspector.TimelineFrameModel.Events.FrameAdded, frame);
     },
 
     /**
      * @param {!Array.<string>} types
-     * @param {!TimelineAgent.TimelineEvent} record
-     * @return {?TimelineAgent.TimelineEvent} record
+     * @param {!WebInspector.TimelineModel.Record} record
+     * @return {?WebInspector.TimelineModel.Record} record
      */
     _findRecordRecursively: function(types, record)
     {
         if (types.indexOf(record.type) >= 0)
             return record;
         if (!record.children)
             return null;
         for (var i = 0; i < record.children.length; ++i) {
             var result = this._findRecordRecursively(types, record.children[i]);
             if (result)
@@ skipping 53 matching lines @@
     /**
      * @param {number} endTime
      */
     _setEndTime: function(endTime)
     {
         this.endTime = endTime;
         this.duration = this.endTime - this.startTime;
     },
 
     /**
-     * @param {!TimelineAgent.TimelineEvent} record
+     * @param {!WebInspector.TimelineModel.Record} record
      */
     _addTimeFromRecord: function(record)
     {
         if (!record.endTime)
             return;
         WebInspector.TimelineUIUtils.aggregateTimeForRecord(this.timeByCategory, record);
         this._updateCpuTime();
     },
 
     /**
      * @param {!Object} timeByCategory
      */
     _addTimeForCategories: function(timeByCategory)
     {
         WebInspector.TimelineUIUtils.aggregateTimeByCategory(this.timeByCategory, timeByCategory);
         this._updateCpuTime();
     },
 
     _updateCpuTime: function()
     {
         this.cpuTime = 0;
         for (var key in this.timeByCategory)
             this.cpuTime += this.timeByCategory[key];
     }
 }