Move inspected target events calculation into TracingTimelineModel

Source/devtools/front_end/timeline/TracingTimelineModel.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.
 
 /**
  * @param {!WebInspector.TracingModel} tracingModel
  * @constructor
  */
 WebInspector.TracingTimelineModel = function(tracingModel)
 {
     this._tracingModel = tracingModel;
     this._mainThreadEvents = [];
+    this._inspectedTargetEvents = [];
 }
 
 WebInspector.TracingTimelineModel.RecordType = {
     Program: "Program",
     EventDispatch: "EventDispatch",
 
     GPUTask: "GPUTask",
 
     RequestMainThreadFrame: "RequestMainThreadFrame",
     BeginFrame: "BeginFrame",
@@ skipping 58 matching lines @@
 
     DecodeImage: "Decode Image",
     ResizeImage: "Resize Image",
     DrawLazyPixelRef: "Draw LazyPixelRef",
     DecodeLazyPixelRef: "Decode LazyPixelRef",
 
     LazyPixelRef: "LazyPixelRef",
     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);
     },
 
     /**
      * @return {?number}
      */
     minimumRecordTime: function()
     {
         return this._tracingModel.minimumRecordTime();
     },
 
     /**
      * @return {?number}
      */
     maximumRecordTime: function()
     {
         return this._tracingModel.maximumRecordTime();
     },
 
     /**
      * @return {!Array.<!WebInspector.TracingModel.Event>}
      */
     inspectedTargetEvents: function()
     {
-        return this._tracingModel.inspectedTargetEvents();
+        return this._inspectedTargetEvents;
     },
 
     /**
      * @return {!Array.<!WebInspector.TracingModel.Event>}
      */
     mainThreadEvents: function()
     {
         return this._mainThreadEvents;
     },
 
     _resetProcessingState: function()
     {
+        this._mainThread = null;
+
         this._sendRequestEvents = {};
         this._timerEvents = {};
         this._requestAnimationFrameEvents = {};
         this._layoutInvalidate = {};
         this._lastScheduleStyleRecalculation = {};
         this._webSocketCreateEvents = {};
         this._paintImageEventByPixelRefId = {};
 
         this._lastRecalculateStylesEvent = null;
         this._currentScriptEvent = null;
         this._eventStack = [];
     },
 
     /**
+     * @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)
     {
         var recordTypes = WebInspector.TracingTimelineModel.RecordType;
 
         var eventStack = this._eventStack;
         while (eventStack.length && eventStack.peekLast().endTime < event.startTime)
             eventStack.pop();
         var duration = event.duration;
@@ skipping 86 matching lines @@
         case recordTypes.EvaluateScript:
         case recordTypes.FunctionCall:
             if (!this._currentScriptEvent)
                 this._currentScriptEvent = event;
             break;
 
         case recordTypes.SetLayerTreeId:
             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"];
             break;
 
         case recordTypes.PaintImage:
             event.backendNodeId = event.args["data"]["nodeId"];
             event.imageURL = event.args["data"]["url"];
             break;
 
@@ skipping 12 matching lines @@
 
         case recordTypes.DrawLazyPixelRef:
             var paintImageEvent = this._findAncestorEvent(recordTypes.PaintImage);
             if (!paintImageEvent)
                 break;
             this._paintImageEventByPixelRefId[event.args["LazyPixelRef"]] = paintImageEvent;
             event.backendNodeId = paintImageEvent.backendNodeId;
             event.imageURL = paintImageEvent.imageURL;
             break;
         }
-        if (this._mainThread === event.thread)
-            this._mainThreadEvents.push(event);
     },
 
     /**
      * @param {string} name
      * @return {?WebInspector.TracingModel.Event}
      */
     _findAncestorEvent: function(name)
     {
         for (var i = this._eventStack.length - 1; i >= 0; --i) {
             var event = this._eventStack[i];
             if (event.name === name)
                 return event;
         }
         return null;
     }
 }