Introduce TracingTimelineModel

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 651 matching lines @@
  * @param {!Array.<number>} quad
  * @return {number}
  */
 WebInspector.TimelineUIUtils._quadWidth = function(quad)
 {
     return Math.round(Math.sqrt(Math.pow(quad[0] - quad[2], 2) + Math.pow(quad[1] - quad[3], 2)));
 }
 
 /**
  * @param {!WebInspector.TracingModel.Event} event
- * @param {!WebInspector.TracingModel} model
+ * @param {!WebInspector.TracingTimelineModel} model
  * @param {!WebInspector.Linkifier} linkifier
  * @param {function(!DocumentFragment)} callback
  * @param {boolean} loadedFromFile
- * @param {?WebInspector.TimelineTraceEventBindings} bindings
  * @param {!WebInspector.Target} target
  */
-WebInspector.TimelineUIUtils.buildTraceEventDetails = function(event, model, linkifier, callback, loadedFromFile, bindings, target)
+WebInspector.TimelineUIUtils.buildTraceEventDetails = function(event, model, linkifier, callback, loadedFromFile, target)
 {
     var relatedNode = null;
     var barrier = new CallbackBarrier();
     if (event.imageURL && !event.previewElement)
         WebInspector.DOMPresentationUtils.buildImagePreviewContents(target, event.imageURL, false, barrier.createCallback(saveImage));
     if (event.backendNodeId)
         target.domModel.pushNodesByBackendIdsToFrontend([event.backendNodeId], barrier.createCallback(setRelatedNode));
     barrier.callWhenDone(callbackWrapper);
 
     /**
      * @param {!Element=} element
      */
     function saveImage(element)
     {
         event.previewElement = element || null;
     }
 
     /**
      * @param {?Array.<!DOMAgent.NodeId>} nodeIds
      */
     function setRelatedNode(nodeIds)
     {
         if (nodeIds)
             relatedNode = target.domModel.nodeForId(nodeIds[0]);
     }
 
     function callbackWrapper()
     {
-        callback(WebInspector.TimelineUIUtils._buildTraceEventDetailsSynchronously(event, model, linkifier, relatedNode, loadedFromFile, bindings, target));
+        callback(WebInspector.TimelineUIUtils._buildTraceEventDetailsSynchronously(event, model, linkifier, relatedNode, loadedFromFile, target));
     }
 }
 
 /**
  * @param {!WebInspector.TracingModel.Event} event
- * @param {!WebInspector.TracingModel} model
+ * @param {!WebInspector.TracingTimelineModel} model
  * @param {!WebInspector.Linkifier} linkifier
  * @param {?WebInspector.DOMNode} relatedNode
  * @param {boolean} loadedFromFile
- * @param {?WebInspector.TimelineTraceEventBindings} bindings
  * @param {!WebInspector.Target} target
  * @return {!DocumentFragment}
  */
-WebInspector.TimelineUIUtils._buildTraceEventDetailsSynchronously = function(event, model, linkifier, relatedNode, loadedFromFile, bindings, target)
+WebInspector.TimelineUIUtils._buildTraceEventDetailsSynchronously = function(event, model, linkifier, relatedNode, loadedFromFile, target)
 {
     var fragment = document.createDocumentFragment();
     var stats = WebInspector.TimelineUIUtils._aggregatedStatsForTraceEvent(model, event);
     var pieChart = stats.hasChildren ?
         WebInspector.TimelineUIUtils.generatePieChart(stats.aggregatedStats, WebInspector.TimelineUIUtils.styleForTimelineEvent(event.name).category, event.selfTime / 1000) :
         WebInspector.TimelineUIUtils.generatePieChart(stats.aggregatedStats);
     fragment.appendChild(pieChart);
 
-    var recordTypes = WebInspector.TimelineTraceEventBindings.RecordType;
+    var recordTypes = WebInspector.TracingTimelineModel.RecordType;
 
     // The messages may vary per event.name;
     var callSiteStackTraceLabel;
     var callStackLabel;
     var relatedNodeLabel;
 
     var contentHelper = new WebInspector.TimelineDetailsContentHelper(target, linkifier, true);
     contentHelper.appendTextRow(WebInspector.UIString("Self Time"), Number.millisToString(event.selfTime / 1000, true));
     contentHelper.appendTextRow(WebInspector.UIString("Start Time"), Number.millisToString((event.startTime - model.minimumRecordTime()) / 1000));
     var eventData = event.args.data;
@@ skipping 97 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, loadedFromFile, bindings, target);
+        var detailsNode = WebInspector.TimelineUIUtils.buildDetailsNodeForTraceEvent(event, linkifier, loadedFromFile, target);
         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"]);
@@ skipping 11 matching lines @@
     if (warning) {
         var div = document.createElement("div");
         div.textContent = warning;
         contentHelper.appendElementRow(WebInspector.UIString("Warning"), div);
     }
     fragment.appendChild(contentHelper.element);
     return fragment;
 }
 
 /**
- * @param {!WebInspector.TracingModel} model
+ * @param {!WebInspector.TracingTimelineModel} model
  * @param {!WebInspector.TracingModel.Event} event
  * @return {!{ aggregatedStats: !Object, hasChildren: boolean }}
  */
 WebInspector.TimelineUIUtils._aggregatedStatsForTraceEvent = function(model, event)
 {
     var events = model.inspectedTargetEvents();
     /**
      * @param {number} startTime
      * @param {!WebInspector.TracingModel.Event} e
      * @return {number}
@@ skipping 160 matching lines @@
         if (record.callSiteStackTrace())
             return linkifyCallFrame(record.callSiteStackTrace()[0]);
         return null;
     }
 }
 
 /**
  * @param {!WebInspector.TracingModel.Event} event
  * @param {!WebInspector.Linkifier} linkifier
  * @param {boolean} loadedFromFile
- * @param {?WebInspector.TimelineTraceEventBindings} bindings
  * @param {!WebInspector.Target} target
  * @return {?Node}
  */
-WebInspector.TimelineUIUtils.buildDetailsNodeForTraceEvent = function(event, linkifier, loadedFromFile, bindings, target)
+WebInspector.TimelineUIUtils.buildDetailsNodeForTraceEvent = function(event, linkifier, loadedFromFile, target)
 {
-    var recordType = WebInspector.TimelineTraceEventBindings.RecordType;
+    var recordType = WebInspector.TracingTimelineModel.RecordType;
 
     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:
@@ skipping 108 matching lines @@
     function linkifyCallFrame(callFrame)
     {
         return linkifyLocation(callFrame.scriptId, callFrame.url, callFrame.lineNumber, callFrame.columnNumber);
     }
 
     /**
      * @return {?Element}
      */
     function linkifyTopCallFrame()
     {
-        if (!bindings)
-            return null;
         var stackTrace = event.stackTrace;
         if (!stackTrace) {
             var initiator = event.initiator;
             if (initiator)
                 stackTrace = initiator.stackTrace;
         }
         if (!stackTrace || !stackTrace.length)
             return null;
         return linkifyCallFrame(stackTrace[0]);
     }
@@ skipping 185 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.linkifyLocation(this._target, stackFrame.url, stackFrame.lineNumber - 1);
             row.appendChild(urlElement);
         }
     }
 }