Move inspected target events calculation into TracingTimelineModel

Source/devtools/front_end/timeline/TracingTimelineModel.js

Index: Source/devtools/front_end/timeline/TracingTimelineModel.js
diff --git a/Source/devtools/front_end/timeline/TracingTimelineModel.js b/Source/devtools/front_end/timeline/TracingTimelineModel.js
index 3e1c67cac7b5f8d4d36e227f0d75f06b039f14f8..9242a642745d81ee2377f0f4363eb6c57cf11800 100644
--- a/Source/devtools/front_end/timeline/TracingTimelineModel.js
+++ b/Source/devtools/front_end/timeline/TracingTimelineModel.js
@@ -10,6 +10,7 @@ WebInspector.TracingTimelineModel = function(tracingModel)
 {
     this._tracingModel = tracingModel;
     this._mainThreadEvents = [];
+    this._inspectedTargetEvents = [];
 }
 
 WebInspector.TracingTimelineModel.RecordType = {
@@ -88,20 +89,35 @@ WebInspector.TracingTimelineModel.RecordType = {
     LayerTreeHostImplSnapshot: "cc::LayerTreeHostImpl"
 };
 
-
 WebInspector.TracingTimelineModel.prototype = {
     willStartRecordingTraceEvents: function()

[caseq, 2014/06/04 13:08:59]

nit: I wonder if we really need this one?

[yurys, 2014/06/04 13:22:16]

This will be merged with one on TimelineModel eventually.

     {
         this._mainThreadEvents = [];
+        this._inspectedTargetEvents = [];
     },
 
     didStopRecordingTraceEvents: function()

[caseq, 2014/06/04 13:08:59]

Can we get it as an event from TracingModel instead of an explicit call from the
top level?

[yurys, 2014/06/04 13:22:16]

I was going to do this in a separate change. TimelineFrameModel also needs to be
updated to use events.

     {
-        var events = this._tracingModel.inspectedTargetEvents();
+        var events = this._tracingModel.devtoolsMetadataEvents();
+        events.sort(WebInspector.TracingModel.Event.compareStartTime);
+
         this._resetProcessingState();
-        for (var i = 0, length = events.length; i < length; i++)
-            this._processEvent(events[i]);
+        for (var i = 0, length = events.length; i < length; i++) {
+            var event = events[i];
+            var process = event.thread.process();
+            var startTime = event.startTime;
+
+            var endTime = null;

[caseq, 2014/06/04 13:08:59]

nit: endTime = Infinity, so that you don't have special case it in comparison
below.

[yurys, 2014/06/04 13:22:16]

Done.

+            if (i + 1 < length)
+                endTime = events[i + 1].startTime;
+
+            this._mainThread = event.thread;

[caseq, 2014/06/04 13:08:59]

Can we rather bind this to processThreadEvents as well?

[yurys, 2014/06/04 13:22:16]

Done.

+            process.sortedThreads().forEach(this._processThreadEvents.bind(this, startTime, endTime));
+            this._mainThread = null;
+        }
         this._resetProcessingState();
+
+        this._inspectedTargetEvents.sort(WebInspector.TracingModel.Event.compareStartTime);
     },
 
     /**
@@ -125,7 +141,7 @@ WebInspector.TracingTimelineModel.prototype = {
      */
     inspectedTargetEvents: function()
     {
-        return this._tracingModel.inspectedTargetEvents();
+        return this._inspectedTargetEvents;
     },
 
     /**
@@ -138,6 +154,8 @@ WebInspector.TracingTimelineModel.prototype = {
 
     _resetProcessingState: function()
     {
+        this._mainThread = null;
+
         this._sendRequestEvents = {};
         this._timerEvents = {};
         this._requestAnimationFrameEvents = {};
@@ -152,6 +170,31 @@ WebInspector.TracingTimelineModel.prototype = {
     },
 
     /**
+     * @param {number} startTime
+     * @param {?number} endTime
+     * @param {!WebInspector.TracingModel.Thread} thread
+     */
+    _processThreadEvents: function(startTime, endTime, thread)
+    {
+        var events = thread.events();
+        var i = 0
+        var length = events.length;
+        while (i < length && events[i].startTime < startTime)

[caseq, 2014/06/04 13:08:59]

nit: i = events.upperBound(startTime, function (time, event) { return time <
event.startTime })

[yurys, 2014/06/04 13:22:16]

Done. Changed to use lowerBound

+            i++;
+
+        this._eventStack = [];

[caseq, 2014/06/04 13:08:59]

unused?

[yurys, 2014/06/04 13:22:16]

It is used. This is to make sure that event stack is empty when we start
processing a new thread.

+        for (; i < length; i++) {
+            var event = events[i];
+            if (endTime && event.startTime >= endTime)
+                break;
+            this._processEvent(event);
+            if (thread === this._mainThread)
+                this._mainThreadEvents.push(event);
+            this._inspectedTargetEvents.push(event);
+        }
+    },
+
+    /**
      * @param {!WebInspector.TracingModel.Event} event
      */
     _processEvent: function(event)
@@ -258,10 +301,6 @@ WebInspector.TracingTimelineModel.prototype = {
             this._inspectedTargetLayerTreeId = event.args["layerTreeId"];
             break;
 
-        case recordTypes.TracingStartedInPage:
-            this._mainThread = event.thread;
-            break;
-
         case recordTypes.Paint:
         case recordTypes.ScrollLayer:
             event.backendNodeId = event.args["data"]["nodeId"];
@@ -294,8 +333,6 @@ WebInspector.TracingTimelineModel.prototype = {
             event.imageURL = paintImageEvent.imageURL;
             break;
         }
-        if (this._mainThread === event.thread)
-            this._mainThreadEvents.push(event);
     },
 
     /**