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

Source/devtools/front_end/timeline/TimelineUIUtils.js

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  * Copyright (C) 2012 Intel 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.
@@ skipping 246 matching lines @@
  * @param {!WebInspector.TracingModel.Event} event
  * @return {boolean}
  */
 WebInspector.TimelineUIUtils.isTallMarkerEvent = function(event)
 {
     return event.name !== WebInspector.TimelineModel.RecordType.TimeStamp;
 }
 
 /**
  * @param {!WebInspector.TracingModel.Event} event
+ * @param {?WebInspector.Target} target
  * @param {!WebInspector.Linkifier} linkifier
  * @return {?Node}
  */
-WebInspector.TimelineUIUtils.buildDetailsNodeForTraceEvent = function(event, linkifier)
+WebInspector.TimelineUIUtils.buildDetailsNodeForTraceEvent = function(event, target, linkifier)
 {
     var recordType = WebInspector.TimelineModel.RecordType;
-    var target = event.thread.target();
     var details;
     var detailsText;
     var eventData = event.args["data"];
     switch (event.name) {
     case recordType.GCEvent:
         var delta = event.args["usedHeapSizeBefore"] - event.args["usedHeapSizeAfter"];
         detailsText = WebInspector.UIString("%s collected", Number.bytesToString(delta));
         break;
     case recordType.TimerFire:
         detailsText = eventData["timerId"];
@@ skipping 113 matching lines @@
 }
 
 /**
  * @param {!WebInspector.TracingModel.Event} event
  * @param {!WebInspector.TimelineModel} model
  * @param {!WebInspector.Linkifier} linkifier
  * @param {function(!DocumentFragment)} callback
  */
 WebInspector.TimelineUIUtils.buildTraceEventDetails = function(event, model, linkifier, callback)
 {
-    var target = event.thread.target();
+    var target = model.target();
+    if (!target) {
+        callbackWrapper();
+        return;
+    }
     var relatedNode = null;
     var barrier = new CallbackBarrier();
     if (!event.previewElement) {
-        if (event.imageURL && target)
+        if (event.imageURL)
             WebInspector.DOMPresentationUtils.buildImagePreviewContents(target, event.imageURL, false, barrier.createCallback(saveImage));
         else if (event.picture)
-            WebInspector.TimelineUIUtils.buildPicturePreviewContent(event, barrier.createCallback(saveImage));
+            WebInspector.TimelineUIUtils.buildPicturePreviewContent(event, target, barrier.createCallback(saveImage));
     }
-    if (event.backendNodeId && target)
+    if (event.backendNodeId)
         target.domModel.pushNodesByBackendIdsToFrontend([event.backendNodeId], barrier.createCallback(setRelatedNode));
     if (event.invalidationTrackingEvents)
-        WebInspector.TimelineUIUtils._pushInvalidationNodeIdsToFrontend(event, barrier.createCallback(updateInvalidationNodeIds));
+        WebInspector.TimelineUIUtils._pushInvalidationNodeIdsToFrontend(event, target, barrier.createCallback(updateInvalidationNodeIds));
     barrier.callWhenDone(callbackWrapper);
 
     /**
      * @param {!Element=} element
      */
     function saveImage(element)
     {
         event.previewElement = element || null;
     }
 
@@ skipping 63 matching lines @@
 
     var pieChart = hasChildren ?
         WebInspector.TimelineUIUtils.generatePieChart(stats, selfCategory, selfTime) :
         WebInspector.TimelineUIUtils.generatePieChart(stats);
 
     var recordTypes = WebInspector.TimelineModel.RecordType;
 
     // This message may vary per event.name;
     var relatedNodeLabel;
 
-    var contentHelper = new WebInspector.TimelineDetailsContentHelper(event.thread.target(), linkifier, true);
+    var contentHelper = new WebInspector.TimelineDetailsContentHelper(model.target(), linkifier, true);
     contentHelper.appendTextRow(WebInspector.UIString("Type"), WebInspector.TimelineUIUtils.eventTitle(event, model));
     contentHelper.appendTextRow(WebInspector.UIString("Self Time"), Number.millisToString(event.selfTime, true));
     contentHelper.appendTextRow(WebInspector.UIString("Start Time"), Number.millisToString((event.startTime - model.minimumRecordTime())));
     contentHelper.appendElementRow(WebInspector.UIString("Aggregated Time"), pieChart);
     var eventData = event.args["data"];
     var initiator = event.initiator;
 
     switch (event.name) {
     case recordTypes.GCEvent:
         var delta = event.args["usedHeapSizeBefore"] - event.args["usedHeapSizeAfter"];
@@ skipping 86 matching lines @@
             contentHelper.appendTextRow(WebInspector.UIString("URL"), initiatorData["webSocketURL"]);
         if (typeof initiatorData["webSocketProtocol"] !== "undefined")
             contentHelper.appendTextRow(WebInspector.UIString("WebSocket Protocol"), initiatorData["webSocketProtocol"]);
         if (typeof eventData["message"] !== "undefined")
             contentHelper.appendTextRow(WebInspector.UIString("Message"), eventData["message"]);
         break;
     case recordTypes.EmbedderCallback:
         contentHelper.appendTextRow(WebInspector.UIString("Callback Function"), eventData["callbackName"]);
         break;
     default:
-        var detailsNode = WebInspector.TimelineUIUtils.buildDetailsNodeForTraceEvent(event, linkifier);
+        var detailsNode = WebInspector.TimelineUIUtils.buildDetailsNodeForTraceEvent(event, model.target(), linkifier);
         if (detailsNode)
             contentHelper.appendElementRow(WebInspector.UIString("Details"), detailsNode);
         break;
     }
 
     if (relatedNode)
         contentHelper.appendElementRow(relatedNodeLabel || WebInspector.UIString("Related node"), WebInspector.DOMPresentationUtils.linkifyNodeReference(relatedNode));
 
     if (eventData && eventData["scriptName"] && event.name !== recordTypes.FunctionCall)
         contentHelper.appendLocationRow(WebInspector.UIString("Function Call"), eventData["scriptName"], eventData["scriptLine"]);
 
     var warning = event.warning;
     if (warning) {
         var div = createElement("div");
         div.textContent = warning;
         contentHelper.appendElementRow(WebInspector.UIString("Warning"), div);
     }
     if (event.previewElement)
         contentHelper.appendElementRow(WebInspector.UIString("Preview"), event.previewElement);
 
     if (event.stackTrace || (event.initiator && event.initiator.stackTrace) || event.invalidationTrackingEvents)
-        WebInspector.TimelineUIUtils._generateCauses(event, contentHelper);
+        WebInspector.TimelineUIUtils._generateCauses(event, model.target(), contentHelper);
 
     fragment.appendChild(contentHelper.element);
 
     return fragment;
 }
 
 /**
  * @param {!WebInspector.TracingModel.Event} event
+ * @param {?WebInspector.Target} target
  * @param {!WebInspector.TimelineDetailsContentHelper} contentHelper
  */
-WebInspector.TimelineUIUtils._generateCauses = function(event, contentHelper)
+WebInspector.TimelineUIUtils._generateCauses = function(event, target, contentHelper)
 {
     var recordTypes = WebInspector.TimelineModel.RecordType;
 
     var callSiteStackLabel;
     var stackLabel;
     var initiator = event.initiator;
 
     switch (event.name) {
     case recordTypes.TimerFire:
         callSiteStackLabel = WebInspector.UIString("Timer installed");
         break;
     case recordTypes.FireAnimationFrame:
         callSiteStackLabel = WebInspector.UIString("Animation frame requested");
         break;
     case recordTypes.RecalculateStyles:
         stackLabel = WebInspector.UIString("Recalculation was forced");
         break;
     case recordTypes.Layout:
         callSiteStackLabel = WebInspector.UIString("First layout invalidation");
         stackLabel = WebInspector.UIString("Layout forced");
         break;
     }
 
     // Direct cause.
     if (event.stackTrace)
         contentHelper.appendStackTrace(stackLabel || WebInspector.UIString("Stack trace"), event.stackTrace);
 
     // Indirect causes.
     if (event.invalidationTrackingEvents) { // Full invalidation tracking (experimental).
-        WebInspector.TimelineUIUtils._generateInvalidations(event, contentHelper);
+        WebInspector.TimelineUIUtils._generateInvalidations(event, target, contentHelper);
     } else if (initiator && initiator.stackTrace) { // Partial invalidation tracking.
         contentHelper.appendStackTrace(callSiteStackLabel || WebInspector.UIString("First invalidated"), initiator.stackTrace);
     }
 }
 
 /**
  * @param {!WebInspector.TracingModel.Event} event
+ * @param {?WebInspector.Target} target
  * @param {!WebInspector.TimelineDetailsContentHelper} contentHelper
  */
-WebInspector.TimelineUIUtils._generateInvalidations = function(event, contentHelper)
+WebInspector.TimelineUIUtils._generateInvalidations = function(event, target, contentHelper)
 {
     if (!event.invalidationTrackingEvents)
         return;
 
-    var target = event.thread.target();
     var invalidations = {};
     event.invalidationTrackingEvents.forEach(function(invalidation) {
         if (!invalidations[invalidation.type])
             invalidations[invalidation.type] = [invalidation];
         else
             invalidations[invalidation.type].push(invalidation);
     });
 
     Object.keys(invalidations).forEach(function(type) {
         WebInspector.TimelineUIUtils._generateInvalidationsForType(
@@ skipping 49 matching lines @@
             reasonRow.textContent = WebInspector.UIString("Reason: %s.", reason);
         }
 
         if (invalidation.stackTrace)
             contentHelper.createChildStackTraceElement(row, invalidation.stackTrace);
     }
 }
 
 /**
  * @param {!WebInspector.TracingModel.Event} event
+ * @param {!WebInspector.Target} target
  * @param {function(?Array.<number>, ?Array.<number>)} callback
  */
-WebInspector.TimelineUIUtils._pushInvalidationNodeIdsToFrontend = function(event, callback)
+WebInspector.TimelineUIUtils._pushInvalidationNodeIdsToFrontend = function(event, target, callback)
 {
     var backendNodeIds = [];
+    var dedupedNodeIds = {};
 
-    var dedupedNodeIds = {};
     if (event.nodeId) {
         backendNodeIds.push(event.nodeId);
         dedupedNodeIds[event.nodeId] = true;
     }
     event.invalidationTrackingEvents.forEach(function(invalidation) {
         if (invalidation.nodeId && !dedupedNodeIds[invalidation.nodeId]) {
             backendNodeIds.push(invalidation.nodeId);
             dedupedNodeIds[invalidation.nodeId] = true;
         }
     });
 
-    var target = event.thread.target();
     target.domModel.pushNodesByBackendIdsToFrontend(backendNodeIds, function(frontendNodeIds) {
         callback(frontendNodeIds, backendNodeIds);
     });
 }
 
 /**
  * @param {!Object} total
  * @param {!WebInspector.TimelineModel.Record} record
  */
 WebInspector.TimelineUIUtils.aggregateTimeForRecord = function(total, record)
@@ skipping 46 matching lines @@
                 aggregatedTotal += total[categoryName];
             total["idle"] = Math.max(0, event.endTime - event.startTime - aggregatedTotal);
         }
         return false;
     }
     return hasChildren;
 }
 
 /**
  * @param {!WebInspector.TracingModel.Event} event
+ * @param {!WebInspector.Target} target
  * @param {function(!Element=)} callback
  */
-WebInspector.TimelineUIUtils.buildPicturePreviewContent = function(event, callback)
+WebInspector.TimelineUIUtils.buildPicturePreviewContent = function(event, target, callback)
 {
 
-    new WebInspector.LayerPaintEvent(event).loadPicture(onSnapshotLoaded);
+    new WebInspector.LayerPaintEvent(event, target).loadPicture(onSnapshotLoaded);
     /**
      * @param {?Array.<number>} rect
      * @param {?WebInspector.PaintProfilerSnapshot} snapshot
      */
     function onSnapshotLoaded(rect, snapshot)
     {
         if (!snapshot) {
             callback();
             return;
         }
@@ skipping 467 matching lines @@
         for (var i = 0; i < stackTrace.length; ++i) {
             var stackFrame = stackTrace[i];
             var row = stackTraceElement.createChild("div");
             row.createTextChild(stackFrame.functionName || WebInspector.UIString("(anonymous function)"));
             row.createTextChild(" @ ");
             var urlElement = this._linkifier.linkifyScriptLocation(this._target, stackFrame.scriptId, stackFrame.url, stackFrame.lineNumber - 1, stackFrame.columnNumber - 1);
             row.appendChild(urlElement);
         }
     }
 }