Move inspected target events calculation into TracingTimelineModel

Source/devtools/front_end/timeline/TracingModel.js

 /*
  * Copyright 2014 The Chromium Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /**
  * @constructor
  * @extends {WebInspector.TargetAwareObject}
  */
@@ skipping 59 matching lines @@
 WebInspector.TracingModel.FrameLifecycleEventCategory = "cc,devtools";
 
 WebInspector.TracingModel.DevToolsMetadataEvent = {
     TracingStartedInPage: "TracingStartedInPage",
 };
 
 WebInspector.TracingModel.prototype = {
     /**
      * @return {!Array.<!WebInspector.TracingModel.Event>}
      */
-    inspectedTargetEvents: function()
+    devtoolsMetadataEvents: function()
     {
-        return this._inspectedTargetEvents;
+        return this._devtoolsMetadataEvents;
     },
 
     /**
      * @param {string} categoryFilter
      * @param {string} options
      * @param {function(?string)=} callback
      */
     start: function(categoryFilter, options, callback)
     {
         this.reset();
@@ skipping 55 matching lines @@
      */
     _eventsCollected: function(events)
     {
         for (var i = 0; i < events.length; ++i)
             this._addEvent(events[i]);
     },
 
     _tracingComplete: function()
     {
         this._active = false;
-
-        /**
-         * @param {!WebInspector.TracingModel.Event} a
-         * @param {!WebInspector.TracingModel.Event} b
-         */
-        function compareStartTime(a, b)
-        {
-            return a.startTime - b.startTime;
-        }
-
-        this._inspectedTargetEvents.sort(compareStartTime);
         if (!this._pendingStopCallback)
             return;
         this._pendingStopCallback();
         this._pendingStopCallback = null;
     },
 
     reset: function()
     {
         this._processById = {};
         this._minimumRecordTime = null;
         this._maximumRecordTime = null;
         this._sessionId = null;
-        this._inspectedTargetProcessId = null;
-        this._inspectedTargetEvents = [];
+        this._devtoolsMetadataEvents = [];
     },
 
     /**
       * @param {!WebInspector.TracingModel.EventPayload} payload
       */
     _addEvent: function(payload)
     {
         var process = this._processById[payload.pid];
         if (!process) {
             process = new WebInspector.TracingModel.Process(payload.pid);
             this._processById[payload.pid] = process;
         }
         var thread = process.threadById(payload.tid);
         if (payload.ph === WebInspector.TracingModel.Phase.SnapshotObject) {
-            var event = new WebInspector.TracingModel.Event(payload, 0, thread);
+            var event = thread.addEvent(payload);
             process.addObject(event);
-            if (payload.pid === this._inspectedTargetProcessId)
-                this._inspectedTargetEvents.push(event);
             return;
         }
         if (payload.ph !== WebInspector.TracingModel.Phase.Metadata) {
             var timestamp = payload.ts;
             // We do allow records for unrelated threads to arrive out-of-order,
             // so there's a chance we're getting records from the past.
             if (timestamp && (!this._minimumRecordTime || timestamp < this._minimumRecordTime))
                 this._minimumRecordTime = timestamp;
             if (!this._maximumRecordTime || timestamp > this._maximumRecordTime)
                 this._maximumRecordTime = timestamp;
-            if (payload.cat === WebInspector.TracingModel.DevToolsMetadataEventCategory)
-                this._processDevToolsMetadataEvent(payload);
             var event = thread.addEvent(payload);
-            if (event && payload.pid === this._inspectedTargetProcessId)
-                this._inspectedTargetEvents.push(event);
+            if (event && event.name === WebInspector.TracingModel.DevToolsMetadataEvent.TracingStartedInPage &&
+                event.category === WebInspector.TracingModel.DevToolsMetadataEventCategory &&
+                event.args["sessionId"] === this._sessionId)
+                this._devtoolsMetadataEvents.push(event);
             return;
         }
         switch (payload.name) {
         case WebInspector.TracingModel.MetadataEvent.ProcessSortIndex:
             process._setSortIndex(payload.args["sort_index"]);
             break;
         case WebInspector.TracingModel.MetadataEvent.ProcessName:
             process._setName(payload.args["name"]);
             break;
         case WebInspector.TracingModel.MetadataEvent.ThreadSortIndex:
             thread._setSortIndex(payload.args["sort_index"]);
             break;
         case WebInspector.TracingModel.MetadataEvent.ThreadName:
             thread._setName(payload.args["name"]);
             break;
         }
     },
 
-     /**
-      * @param {!WebInspector.TracingModel.EventPayload} payload
-      */
-    _processDevToolsMetadataEvent: function(payload)
-    {
-        if (payload.args["sessionId"] !== this._sessionId || payload.name !== WebInspector.TracingModel.DevToolsMetadataEvent.TracingStartedInPage)
-            return;
-        this._inspectedTargetProcessId = payload.pid;
-    },
-
     /**
      * @return {?number}
      */
     minimumRecordTime: function()
     {
         return this._minimumRecordTime;
     },
 
     /**
      * @return {?number}
@@ skipping 80 matching lines @@
         var duration = payload.ts - this.startTime;
         if (duration < 0) {
             console.assert(false, "Event out of order: " + this.name);
             return;
         }
         this._setDuration(duration);
     }
 }
 
 /**
+ * @param {!WebInspector.TracingModel.Event} a
+ * @param {!WebInspector.TracingModel.Event} b
+ * @return {number}
+ */
+WebInspector.TracingModel.Event.compareStartTime = function (a, b)
+{
+    return a.startTime - b.startTime;
+}
+
+/**
  * @constructor
  */
 WebInspector.TracingModel.NamedObject = function()
 {
 }
 
 WebInspector.TracingModel.NamedObject.prototype =
 {
     /**
      * @param {string} name
@@ skipping 51 matching lines @@
 
 WebInspector.TracingModel.Process.prototype = {
     /**
      * @param {number} id
      * @return {!WebInspector.TracingModel.Thread}
      */
     threadById: function(id)
     {
         var thread = this._threads[id];
         if (!thread) {
-            thread = new WebInspector.TracingModel.Thread(id);
+            thread = new WebInspector.TracingModel.Thread(this, id);
             this._threads[id] = thread;
         }
         return thread;
     },
 
     /**
      * @param {!WebInspector.TracingModel.Event} event
      */
     addObject: function(event)
     {
@@ skipping 29 matching lines @@
     {
         return WebInspector.TracingModel.NamedObject._sort(Object.values(this._threads));
     },
 
     __proto__: WebInspector.TracingModel.NamedObject.prototype
 }
 
 /**
  * @constructor
  * @extends {WebInspector.TracingModel.NamedObject}
+ * @param {!WebInspector.TracingModel.Process} process
  * @param {number} id
  */
-WebInspector.TracingModel.Thread = function(id)
+WebInspector.TracingModel.Thread = function(process, id)
 {
     WebInspector.TracingModel.NamedObject.call(this);
+    this._process = process;
     this._setName("Thread " + id);
     this._events = [];
     this._stack = [];
     this._maxStackDepth = 0;
 }
 
 WebInspector.TracingModel.Thread.prototype = {
     /**
      * @param {!WebInspector.TracingModel.EventPayload} payload
      * @return {?WebInspector.TracingModel.Event} event
@@ skipping 20 matching lines @@
             if (this._maxStackDepth < this._stack.length)
                 this._maxStackDepth = this._stack.length;
         }
         if (this._events.length && this._events.peekLast().startTime > event.startTime)
             console.assert(false, "Event is our of order: " + event.name);
         this._events.push(event);
         return event;
     },
 
     /**
+     * @return {!WebInspector.TracingModel.Process}
+     */
+    process: function()
+    {
+        return this._process;
+    },
+
+    /**
      * @return {!Array.<!WebInspector.TracingModel.Event>}
      */
     events: function()
     {
         return this._events;
     },
 
     /**
      * @return {number}
      */
@@ skipping 32 matching lines @@
     dataCollected: function(data)
     {
         this._tracingModel._eventsCollected(data);
     },
 
     tracingComplete: function()
     {
         this._tracingModel._tracingComplete();
     }
 }