Timeline: unify frame computation for threaded and single-thread scenarios

third_party/WebKit/Source/devtools/front_end/timeline/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 180 matching lines @@
         }
     },
 
     reset: function()
     {
         this._minimumRecordTime = Infinity;
         this._frames = [];
         this._frameById = {};
         this._lastFrame = null;
         this._lastLayerTree = null;
-        this._hasThreadedCompositing = false;
         this._mainFrameCommitted = false;
         this._mainFrameRequested = false;
         this._framePendingCommit = null;
         this._lastBeginFrame = null;
         this._lastNeedsBeginFrame = null;
     },
 
     /**
      * @param {number} startTime
      */
     handleBeginFrame: function(startTime)
     {
         if (!this._lastFrame)
-            this._startBackgroundFrame(startTime);
+            this._startFrame(startTime);
         this._lastBeginFrame = startTime;
     },
 
     /**
      * @param {number} startTime
      */
     handleDrawFrame: function(startTime)
     {
         if (!this._lastFrame) {
-            this._startBackgroundFrame(startTime);
+            this._startFrame(startTime);
             return;
         }
 
         // - 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) {
             if (this._lastNeedsBeginFrame) {
                 this._lastFrame.idle = true;
                 var idleTimeEnd = this._framePendingActivation ? this._framePendingActivation.triggerTime : (this._lastBeginFrame || this._lastNeedsBeginFrame);
-                this._startBackgroundFrame(idleTimeEnd);
+                this._startFrame(idleTimeEnd);
                 if (this._framePendingActivation)
                     this._commitPendingFrame();
                 this._lastNeedsBeginFrame = null;
                 this._lastBeginFrame = null;
             }
-            this._startBackgroundFrame(startTime);
+            this._startFrame(startTime);
         }
         this._mainFrameCommitted = false;
     },
 
     handleActivateLayerTree: function()
     {
         if (!this._lastFrame)
             return;
         if (this._framePendingActivation && !this._lastNeedsBeginFrame)
             this._commitPendingFrame();
     },
 
     handleRequestMainThreadFrame: function()
     {
         if (!this._lastFrame)
             return;
         this._mainFrameRequested = true;
     },
 
     handleCompositeLayers: function()
     {
-        if (!this._hasThreadedCompositing || !this._framePendingCommit)
+        if (!this._framePendingCommit)
             return;
         this._framePendingActivation = this._framePendingCommit;
         this._framePendingCommit = null;
         this._mainFrameRequested = false;
         this._mainFrameCommitted = true;
     },
 
     /**
      * @param {!WebInspector.DeferredLayerTree} layerTree
      */
     handleLayerTreeSnapshot: function(layerTree)
     {
         this._lastLayerTree = layerTree;
     },
 
     /**
      * @param {number} startTime
      * @param {boolean} needsBeginFrame
      */
     handleNeedFrameChanged: function(startTime, needsBeginFrame)
     {
         if (needsBeginFrame)
             this._lastNeedsBeginFrame = startTime;
     },
 
     /**
      * @param {number} startTime
      */
-    _startBackgroundFrame: function(startTime)
-    {
-        if (!this._hasThreadedCompositing) {
-            this._lastFrame = null;
-            this._hasThreadedCompositing = true;
-        }
-        if (this._lastFrame)
-            this._flushFrame(this._lastFrame, startTime);
-
-        this._lastFrame = new WebInspector.TimelineFrame(startTime, startTime - this._minimumRecordTime);
-    },
-
-    /**
-     * @param {number} startTime
-     * @param {number=} frameId
-     */
-    _startMainThreadFrame: function(startTime, frameId)
+    _startFrame: function(startTime)
     {
         if (this._lastFrame)
             this._flushFrame(this._lastFrame, startTime);
         this._lastFrame = new WebInspector.TimelineFrame(startTime, startTime - this._minimumRecordTime);
-        this._lastFrame._mainFrameId = frameId;
     },
 
     /**
      * @param {!WebInspector.TimelineFrame} frame
      * @param {number} endTime
      */
     _flushFrame: function(frame, endTime)
     {
         frame._setLayerTree(this._lastLayerTree);
         frame._setEndTime(endTime);
@@ skipping 81 matching lines @@
 
         if (event.name === eventNames.SetLayerTreeId) {
             var sessionId = event.args["sessionId"] || event.args["data"]["sessionId"];
             if (this._sessionId === sessionId)
                 this._layerTreeId = event.args["layerTreeId"] || event.args["data"]["layerTreeId"];
         } else if (event.name === eventNames.TracingStartedInPage) {
             this._mainThread = event.thread;
         } else if (event.phase === WebInspector.TracingModel.Phase.SnapshotObject && event.name === eventNames.LayerTreeHostImplSnapshot && parseInt(event.id, 0) === this._layerTreeId) {
             var snapshot = /** @type {!WebInspector.TracingModel.ObjectSnapshot} */ (event);
             this.handleLayerTreeSnapshot(new WebInspector.DeferredTracingLayerTree(snapshot, this._target));
-        } else if (event.thread === this._mainThread) {
-            this._addMainThreadTraceEvent(event);
         } else {
-            this._addBackgroundTraceEvent(event);
+            this._processCompositorEvents(event);
+            if (event.thread === this._mainThread)
+                this._addMainThreadTraceEvent(event);
+            else if (this._lastFrame && event.selfTime && !WebInspector.TracingModel.isTopLevelEvent(event))
+                this._lastFrame._addTimeForCategory(WebInspector.TimelineUIUtils.eventStyle(event).category.name, event.selfTime);
         }
     },
 
     /**
      * @param {!WebInspector.TracingModel.Event} event
      */
-    _addBackgroundTraceEvent: function(event)
+    _processCompositorEvents: function(event)
     {
         var eventNames = WebInspector.TimelineModel.RecordType;
-        if (this._lastFrame && event.selfTime && !WebInspector.TracingModel.isTopLevelEvent(event))
-            this._lastFrame._addTimeForCategory(WebInspector.TimelineUIUtils.eventStyle(event).category.name, event.selfTime);
 
         if (event.args["layerTreeId"] !== this._layerTreeId)
             return;
 
         var timestamp = event.startTime;
         if (event.name === eventNames.BeginFrame)
             this.handleBeginFrame(timestamp);
         else if (event.name === eventNames.DrawFrame)
             this.handleDrawFrame(timestamp);
         else if (event.name === eventNames.ActivateLayerTree)
             this.handleActivateLayerTree();
         else if (event.name === eventNames.RequestMainThreadFrame)
             this.handleRequestMainThreadFrame();
         else if (event.name === eventNames.NeedsBeginFrameChanged)
             this.handleNeedFrameChanged(timestamp, event.args["data"] && event.args["data"]["needsBeginFrame"]);
     },
 
     /**
      * @param {!WebInspector.TracingModel.Event} event
      */
     _addMainThreadTraceEvent: function(event)
     {
         var eventNames = WebInspector.TimelineModel.RecordType;
         var timestamp = event.startTime;
         var selfTime = event.selfTime || 0;
 
-        if (!this._hasThreadedCompositing) {
-            if (event.name === eventNames.BeginMainThreadFrame)
-                this._startMainThreadFrame(timestamp, event.args["data"] && event.args["data"]["frameId"]);
-            if (!this._lastFrame)
-                return;
-            if (!selfTime)
-                return;
-
-            var categoryName = WebInspector.TimelineUIUtils.eventStyle(event).category.name;
-            this._lastFrame._addTimeForCategory(categoryName, selfTime);
-            if (event.name === eventNames.Paint && event.args["data"]["layerId"] && event.picture && this._target)
-                this._lastFrame.paints.push(new WebInspector.LayerPaintEvent(event, this._target));
-            return;
-        }
-
         if (WebInspector.TracingModel.isTopLevelEvent(event)) {
             this._currentTaskTimeByCategory = {};
             this._lastTaskBeginTime = event.startTime;
         }
         if (!this._framePendingCommit && WebInspector.TracingTimelineFrameModel._mainFrameMarkers.indexOf(event.name) >= 0)
             this._framePendingCommit = new WebInspector.PendingFrame(this._lastTaskBeginTime, this._currentTaskTimeByCategory);
         if (!this._framePendingCommit) {
             this._addTimeForCategory(this._currentTaskTimeByCategory, event);
             return;
         }
@@ skipping 211 matching lines @@
 WebInspector.PendingFrame = function(triggerTime, timeByCategory)
 {
     /** @type {!Object.<string, number>} */
     this.timeByCategory = timeByCategory;
     /** @type {!Array.<!WebInspector.LayerPaintEvent>} */
     this.paints = [];
     /** @type {number|undefined} */
     this.mainFrameId = undefined;
     this.triggerTime = triggerTime;
 }