DevTools: encapsulate presentation model in timeline view.

Source/devtools/front_end/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 16 matching lines @@
  * (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}
  */
 WebInspector.TimelineModel = function()
 {
-    this._payloads = [];
-    this._records = [];
-    this._minimumRecordTime = -1;
-    this._maximumRecordTime = -1;
-    this._stringPool = {};
+    this._filters = [];
     this._bindings = new WebInspector.TimelineModel.InterRecordBindings();
 
+    this.reset();
+
     WebInspector.timelineManager.addEventListener(WebInspector.TimelineManager.EventTypes.TimelineEventRecorded, this._onRecordAdded, this);
     WebInspector.timelineManager.addEventListener(WebInspector.TimelineManager.EventTypes.TimelineStarted, this._onStarted, this);
     WebInspector.timelineManager.addEventListener(WebInspector.TimelineManager.EventTypes.TimelineStopped, this._onStopped, this);
 }
 
 WebInspector.TimelineModel.TransferChunkLengthBytes = 5000000;
 
 WebInspector.TimelineModel.RecordType = {
     Root: "Root",
     Program: "Program",
@@ skipping 53 matching lines @@
     WebSocketReceiveHandshakeResponse : "WebSocketReceiveHandshakeResponse",
     WebSocketDestroy : "WebSocketDestroy",
 
     EmbedderCallback : "EmbedderCallback",
 }
 
 WebInspector.TimelineModel.Events = {
     RecordAdded: "RecordAdded",
     RecordsCleared: "RecordsCleared",
     RecordingStarted: "RecordingStarted",
-    RecordingStopped: "RecordingStopped"
+    RecordingStopped: "RecordingStopped",
+    RecordFilterChanged: "RecordFilterChanged"
 }
 
 /**
  * @param {!Array.<!WebInspector.TimelineModel.Record>} recordsArray
  * @param {?function(!WebInspector.TimelineModel.Record)|?function(!WebInspector.TimelineModel.Record,number)} preOrderCallback
  * @param {function(!WebInspector.TimelineModel.Record)|function(!WebInspector.TimelineModel.Record,number)=} postOrderCallback
+ * @return {boolean}
  */
 WebInspector.TimelineModel.forAllRecords = function(recordsArray, preOrderCallback, postOrderCallback)
 {
-    if (!recordsArray)
-        return;
-    var stack = [{array: recordsArray, index: 0}];
-    while (stack.length) {
-        var entry = stack[stack.length - 1];
-        var records = entry.array;
-        if (entry.index < records.length) {
-             var record = records[entry.index];
-             if (preOrderCallback && preOrderCallback(record, stack.length))
-                 return;
-             if (record.children)
-                 stack.push({array: record.children, index: 0, record: record});
-             else if (postOrderCallback && postOrderCallback(record, stack.length))
-                return;
-             ++entry.index;
-        } else {
-            if (entry.record && postOrderCallback && postOrderCallback(entry.record, stack.length))
-                return;
-            stack.pop();
+    /**
+     * @param {!Array.<!WebInspector.TimelineModel.Record>} records
+     * @param {number} depth
+     * @return {boolean}
+     */
+    function processRecords(records, depth)
+    {
+        for (var i = 0; i < records.length; ++i) {
+            var record = records[i];
+            if (preOrderCallback && preOrderCallback(record, depth))
+                return true;
+            if (processRecords(record.children, depth + 1))
+                return true;
+            if (postOrderCallback && postOrderCallback(record, depth))
+                return true;
         }
+        return false;
     }
+    return processRecords(recordsArray, 0);
 }
 
 WebInspector.TimelineModel.prototype = {
     /**
      * @param {?function(!WebInspector.TimelineModel.Record)|?function(!WebInspector.TimelineModel.Record,number)} preOrderCallback
      * @param {function(!WebInspector.TimelineModel.Record)|function(!WebInspector.TimelineModel.Record,number)=} postOrderCallback
      */
     forAllRecords: function(preOrderCallback, postOrderCallback)
     {
         WebInspector.TimelineModel.forAllRecords(this._records, preOrderCallback, postOrderCallback);
     },
 
     /**
+     * @param {!WebInspector.TimelineModel.Filter} filter
+     */
+    addFilter: function(filter)
+    {
+        this._filters.push(filter);
+        filter._model = this;
+    },
+
+    /**
+     * @param {function(!WebInspector.TimelineModel.Record)|function(!WebInspector.TimelineModel.Record,number)} callback
+     */
+    forAllFilteredRecords: function(callback)
+    {
+        /**
+         * @param {!WebInspector.TimelineModel.Record} record
+         * @param {number} depth
+         * @this {WebInspector.TimelineModel}
+         * @return {boolean}
+         */
+        function processRecord(record, depth)
+        {
+            var visible = this.isVisible(record);
+            if (visible) {
+                if (callback(record, depth))
+                    return true;
+            }
+
+            for (var i = 0; i < record.children.length; ++i) {
+                if (processRecord.call(this, record.children[i], visible ? depth + 1 : depth))
+                    return true;
+            }
+            return false;
+        }
+
+        for (var i = 0; i < this._records.length; ++i)
+            processRecord.call(this, this._records[i], 0);
+    },
+
+    /**
+     * @param {!WebInspector.TimelineModel.Record} record
+     * @return {boolean}
+     */
+    isVisible: function(record)
+    {
+        for (var i = 0; i < this._filters.length; ++i) {
+            if (!this._filters[i].accept(record))
+                return false;
+        }
+        return true;
+    },
+
+    _filterChanged: function()
+    {
+        this.dispatchEventToListeners(WebInspector.TimelineModel.Events.RecordFilterChanged);
+    },
+
+    /**
      * @param {boolean=} includeCounters
      */
     startRecording: function(includeCounters)
     {
         this._clientInitiatedRecording = true;
         this.reset();
         var maxStackFrames = WebInspector.settings.timelineCaptureStacks.get() ? 30 : 0;
         var includeGPUEvents = WebInspector.experimentsSettings.gpuTimeline.isEnabled();
         WebInspector.timelineManager.start(maxStackFrames, includeCounters, includeGPUEvents, this._fireRecordingStarted.bind(this));
     },
@@ skipping 74 matching lines @@
      * @param {!TimelineAgent.TimelineEvent} payload
      */
     _addRecord: function(payload)
     {
         this._internStrings(payload);
         this._payloads.push(payload);
         this._updateBoundaries(payload);
 
         var record = this._innerAddRecord(payload, null);
         this._records.push(record);
+        if (record.type === WebInspector.TimelineModel.RecordType.Program)
+            this._mainThreadTasks.push(record);
+        if (record.type === WebInspector.TimelineModel.RecordType.GPUTask)
+            this._gpuThreadTasks.push(record);
 
         this.dispatchEventToListeners(WebInspector.TimelineModel.Events.RecordAdded, record);
     },
 
     /**
      * @param {!TimelineAgent.TimelineEvent} payload
      * @param {?WebInspector.TimelineModel.Record} parentRecord
      * @return {!WebInspector.TimelineModel.Record}
      * @this {!WebInspector.TimelineModel}
      */
     _innerAddRecord: function(payload, parentRecord)
     {
         var record = new WebInspector.TimelineModel.Record(this, payload, parentRecord);
+        if (WebInspector.TimelineUIUtils.isEventDivider(record))
+            this._eventDividerRecords.push(record);
+
         for (var i = 0; payload.children && i < payload.children.length; ++i)
             this._innerAddRecord.call(this, payload.children[i], record);
 
         record.calculateAggregatedStats();
         if (parentRecord)
             parentRecord._selfTime -= record.endTime - record.startTime;
         return record;
     },
 
     /**
@@ skipping 50 matching lines @@
     },
 
     reset: function()
     {
         this._records = [];
         this._payloads = [];
         this._stringPool = {};
         this._minimumRecordTime = -1;
         this._maximumRecordTime = -1;
         this._bindings._reset();
+        /** @type {!Array.<!WebInspector.TimelineModel.Record>} */
+        this._mainThreadTasks =  [];
+        /** @type {!Array.<!WebInspector.TimelineModel.Record>} */
+        this._gpuThreadTasks = [];
+        /** @type {!Array.<!WebInspector.TimelineModel.Record>} */
+        this._eventDividerRecords = [];
         this.dispatchEventToListeners(WebInspector.TimelineModel.Events.RecordsCleared);
     },
 
     /**
      * @return {number}
      */
     minimumRecordTime: function()
     {
         return this._minimumRecordTime;
     },
@@ skipping 14 matching lines @@
         var startTime = record.startTime;
         var endTime = record.endTime;
 
         if (this._minimumRecordTime === -1 || startTime < this._minimumRecordTime)
             this._minimumRecordTime = startTime;
         if ((this._maximumRecordTime === -1 && endTime) || endTime > this._maximumRecordTime)
             this._maximumRecordTime = endTime;
     },
 
     /**
-     * @param {!Object} rawRecord
-     * @return {number}
+     * @return {!Array.<!WebInspector.TimelineModel.Record>}
      */
-    recordOffsetInMillis: function(rawRecord)
+    mainThreadTasks: function()
     {
-        return rawRecord.startTime - this._minimumRecordTime;
+        return this._mainThreadTasks;
     },
 
     /**
+     * @return {!Array.<!WebInspector.TimelineModel.Record>}
+     */
+    gpuThreadTasks: function()
+    {
+        return this._gpuThreadTasks;
+    },
+
+    /**
+     * @return {!Array.<!WebInspector.TimelineModel.Record>}
+     */
+    eventDividerRecords: function()
+    {
+        return this._eventDividerRecords;
+    },
+
+    /**
      * @param {!TimelineAgent.TimelineEvent} record
      */
     _internStrings: function(record)
     {
         for (var name in record) {
             var value = record[name];
             if (typeof value !== "string")
                 continue;
 
             var interned = this._stringPool[value];
@@ skipping 413 matching lines @@
      */
     testContentMatching: function(regExp)
     {
         var tokens = [this.title()];
         for (var key in this._record.data)
             tokens.push(this._record.data[key])
         return regExp.test(tokens.join("|"));
     }
 }
 
+
+/**
+ * @constructor
+ */
+WebInspector.TimelineModel.Filter = function()
+{
+    /** @type {!WebInspector.TimelineModel} */
+    this._model;
+}
+
+WebInspector.TimelineModel.Filter.prototype = {
+    /**
+     * @param {!WebInspector.TimelineModel.Record} record
+     * @return {boolean}
+     */
+    accept: function(record)
+    {
+        return true;
+    },
+
+    notifyFilterChanged: function()
+    {
+        this._model._filterChanged();
+    }
+}
+
 /**
  * @constructor
  * @implements {WebInspector.OutputStream}
  * @param {!WebInspector.TimelineModel} model
  * @param {!{cancel: function()}} reader
  * @param {!WebInspector.Progress} progress
  */
 WebInspector.TimelineModelLoader = function(model, reader, progress)
 {
     this._model = model;
@@ skipping 215 matching lines @@
 WebInspector.TimelineModel._quadFromRectData = function(data)
 {
     if (typeof data["x"] === "undefined" || typeof data["y"] === "undefined")
         return null;
     var x0 = data["x"];
     var x1 = data["x"] + data["width"];
     var y0 = data["y"];
     var y1 = data["y"] + data["height"];
     return [x0, y0, x1, y0, x1, y1, x0, y1];
 }