Timeline: do not imply event.thread.target is the main target

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 197 matching lines @@
             var result = this._findRecordRecursively(types, record.children()[i]);
             if (result)
                 return result;
         }
         return null;
     }
 }
 
 /**
  * @constructor
+ * @param {?WebInspector.Target} target
  * @extends {WebInspector.TimelineFrameModelBase}
  */
-WebInspector.TracingTimelineFrameModel = function()
+WebInspector.TracingTimelineFrameModel = function(target)
 {
     WebInspector.TimelineFrameModelBase.call(this);
+    this._target = target;
 }
 
 WebInspector.TracingTimelineFrameModel._mainFrameMarkers = [
     WebInspector.TimelineModel.RecordType.ScheduleStyleRecalculation,
     WebInspector.TimelineModel.RecordType.InvalidateLayout,
     WebInspector.TimelineModel.RecordType.BeginMainThreadFrame,
     WebInspector.TimelineModel.RecordType.ScrollLayer
 ];
 
 WebInspector.TracingTimelineFrameModel.prototype = {
@@ skipping 15 matching lines @@
     /**
      * @param {!WebInspector.TracingModel.Event} event
      */
     _addTraceEvent: function(event)
     {
         var eventNames = WebInspector.TimelineModel.RecordType;
 
         if (event.name === eventNames.SetLayerTreeId) {
             if (this._sessionId === event.args["sessionId"])
                 this._layerTreeId = event.args["layerTreeId"];
-            return;
+        } 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);
         }
-        if (event.name === eventNames.TracingStartedInPage) {
-            this._mainThread = event.thread;
-            return;
+        else {

[alph, 2014/11/13 11:11:40]

should be on the previous line

+            this._addBackgroundTraceEvent(event);
         }
-        if (event.thread === this._mainThread)
-            this._addMainThreadTraceEvent(event);
-        else
-            this._addBackgroundTraceEvent(event);
     },
 
     /**
      * @param {!WebInspector.TracingModel.Event} event
      */
     _addBackgroundTraceEvent: function(event)
     {
         var eventNames = WebInspector.TimelineModel.RecordType;
-        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));
-            return;
-        }
         if (this._lastFrame && event.selfTime)
             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)
@@ skipping 23 matching lines @@
 
             var categoryName = WebInspector.TimelineUIUtils.eventStyle(event).category.name;
             this._lastFrame._addTimeForCategory(categoryName, selfTime);
             return;
         }
 
         if (!this._framePendingCommit && WebInspector.TracingTimelineFrameModel._mainFrameMarkers.indexOf(event.name) >= 0)
             this._framePendingCommit = new WebInspector.PendingFrame();
         if (!this._framePendingCommit)
             return;
-        if (event.name === eventNames.Paint && event.args["data"]["layerId"] && event.picture)
-            this._framePendingCommit.paints.push(new WebInspector.LayerPaintEvent(event));
+        if (event.name === eventNames.Paint && event.args["data"]["layerId"] && event.picture && this._target)
+            this._framePendingCommit.paints.push(new WebInspector.LayerPaintEvent(event, this._target));
 
         if (selfTime) {
             var categoryName = WebInspector.TimelineUIUtils.eventStyle(event).category.name;
             this._framePendingCommit.timeByCategory[categoryName] = (this._framePendingCommit.timeByCategory[categoryName] || 0) + selfTime;
         }
         if (event.name === eventNames.CompositeLayers && event.args["layerTreeId"] === this._layerTreeId)
             this.handleCompositeLayers();
     },
 
     __proto__: WebInspector.TimelineFrameModelBase.prototype
 }
 
 /**
  * @constructor
  * @extends {WebInspector.DeferredLayerTree}
  * @param {!WebInspector.TracingModel.ObjectSnapshot} snapshot
+ * @param {?WebInspector.Target} target
  */
-WebInspector.DeferredTracingLayerTree = function(snapshot)
+WebInspector.DeferredTracingLayerTree = function(snapshot, target)
 {
-    WebInspector.DeferredLayerTree.call(this, snapshot.thread.target());
+    WebInspector.DeferredLayerTree.call(this, target);
     this._snapshot = snapshot;
 }
 
 WebInspector.DeferredTracingLayerTree.prototype = {
     /**
      * @param {function(!WebInspector.LayerTreeBase)} callback
      */
     resolve: function(callback)
     {
         this._snapshot.requestObject(onGotObject.bind(this));
@@ skipping 108 matching lines @@
     _addTimeForCategory: function(category, time)
     {
         this.timeByCategory[category] = (this.timeByCategory[category] || 0) + time;
         this.cpuTime += time;
     },
 }
 
 /**
  * @constructor
  * @param {!WebInspector.TracingModel.Event} event
+ * @param {!WebInspector.Target} target
  */
-WebInspector.LayerPaintEvent = function(event)
+WebInspector.LayerPaintEvent = function(event, target)
 {
     this._event = event;
+    this._target = target;
 }
 
 WebInspector.LayerPaintEvent.prototype = {
     /**
      * @return {string}
      */
     layerId: function()
     {
         return this._event.args["data"]["layerId"];
     },
 
     /**
      * @return {!WebInspector.TracingModel.Event}
      */
     event: function()
     {
         return this._event;
     },
 
     /**
      * @param {function(?Array.<number>, ?WebInspector.PaintProfilerSnapshot)} callback
      */
     loadPicture: function(callback)
     {
-        var target = this._event.thread.target();
-        this._event.picture.requestObject(onGotObject);
+        this._event.picture.requestObject(onGotObject.bind(this));
         /**
          * @param {?Object} result
+         * @this {WebInspector.LayerPaintEvent}
          */
         function onGotObject(result)
         {
-            if (!result || !result["skp64"] || !target) {
+            if (!result || !result["skp64"]) {
                 callback(null, null);
                 return;
             }
             var rect = result["params"] && result["params"]["layer_rect"];
-            WebInspector.PaintProfilerSnapshot.load(target, result["skp64"], callback.bind(null, rect));
+            WebInspector.PaintProfilerSnapshot.load(this._target, result["skp64"], callback.bind(null, rect));
         }
     }
 };
 
 /**
  * @constructor
  */
 WebInspector.PendingFrame = function()
 {
     /** @type {!Object.<string, number>} */
     this.timeByCategory = {};
     /** @type {!Array.<!WebInspector.LayerPaintEvent>} */
     this.paints = [];
 }