DevTools: merge TracingTimelineModel into TimelineModel

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 37 matching lines @@
 }
 
 /**
  * @return {!Object.<string, !WebInspector.TimelineRecordStyle>}
  */
 WebInspector.TimelineUIUtils._initEventStyles = function()
 {
     if (WebInspector.TimelineUIUtils._eventStylesMap)
         return WebInspector.TimelineUIUtils._eventStylesMap;
 
-    var recordTypes = WebInspector.TracingTimelineModel.RecordType;
+    var recordTypes = WebInspector.TimelineModel.RecordType;
     var categories = WebInspector.TimelineUIUtils.categories();
 
     var eventStyles = {};
     eventStyles[recordTypes.Program] = new WebInspector.TimelineRecordStyle(WebInspector.UIString("Other"), categories["other"]);
     eventStyles[recordTypes.EventDispatch] = new WebInspector.TimelineRecordStyle(WebInspector.UIString("Event"), categories["scripting"]);
     eventStyles[recordTypes.RequestMainThreadFrame] = new WebInspector.TimelineRecordStyle(WebInspector.UIString("Request Main Thread Frame"), categories["rendering"], true);
     eventStyles[recordTypes.BeginFrame] = new WebInspector.TimelineRecordStyle(WebInspector.UIString("Frame Start"), categories["rendering"], true);
     eventStyles[recordTypes.BeginMainThreadFrame] = new WebInspector.TimelineRecordStyle(WebInspector.UIString("Frame Start (main thread)"), categories["rendering"], true);
     eventStyles[recordTypes.DrawFrame] = new WebInspector.TimelineRecordStyle(WebInspector.UIString("Draw Frame"), categories["rendering"], true);
     eventStyles[recordTypes.ScheduleStyleRecalculation] = new WebInspector.TimelineRecordStyle(WebInspector.UIString("Schedule Style Recalculation"), categories["rendering"], true);
@@ skipping 34 matching lines @@
     eventStyles[recordTypes.WebSocketReceiveHandshakeResponse] = new WebInspector.TimelineRecordStyle(WebInspector.UIString("Receive WebSocket Handshake"), categories["scripting"]);
     eventStyles[recordTypes.WebSocketDestroy] = new WebInspector.TimelineRecordStyle(WebInspector.UIString("Destroy WebSocket"), categories["scripting"]);
     eventStyles[recordTypes.EmbedderCallback] = new WebInspector.TimelineRecordStyle(WebInspector.UIString("Embedder Callback"), categories["scripting"]);
     eventStyles[recordTypes.DecodeImage] = new WebInspector.TimelineRecordStyle(WebInspector.UIString("Image Decode"), categories["painting"]);
     eventStyles[recordTypes.ResizeImage] = new WebInspector.TimelineRecordStyle(WebInspector.UIString("Image Resize"), categories["painting"]);
     WebInspector.TimelineUIUtils._eventStylesMap = eventStyles;
     return eventStyles;
 }
 
 WebInspector.TimelineUIUtils._coalescableRecordTypes = {};
-WebInspector.TimelineUIUtils._coalescableRecordTypes[WebInspector.TracingTimelineModel.RecordType.Layout] = 1;
-WebInspector.TimelineUIUtils._coalescableRecordTypes[WebInspector.TracingTimelineModel.RecordType.Paint] = 1;
-WebInspector.TimelineUIUtils._coalescableRecordTypes[WebInspector.TracingTimelineModel.RecordType.RasterTask] = 1;
-WebInspector.TimelineUIUtils._coalescableRecordTypes[WebInspector.TracingTimelineModel.RecordType.DecodeImage] = 1;
-WebInspector.TimelineUIUtils._coalescableRecordTypes[WebInspector.TracingTimelineModel.RecordType.ResizeImage] = 1;
+WebInspector.TimelineUIUtils._coalescableRecordTypes[WebInspector.TimelineModel.RecordType.Layout] = 1;
+WebInspector.TimelineUIUtils._coalescableRecordTypes[WebInspector.TimelineModel.RecordType.Paint] = 1;
+WebInspector.TimelineUIUtils._coalescableRecordTypes[WebInspector.TimelineModel.RecordType.RasterTask] = 1;
+WebInspector.TimelineUIUtils._coalescableRecordTypes[WebInspector.TimelineModel.RecordType.DecodeImage] = 1;
+WebInspector.TimelineUIUtils._coalescableRecordTypes[WebInspector.TimelineModel.RecordType.ResizeImage] = 1;
 
 /**
  * @param {string} recordType
  * @return {boolean}
  */
 WebInspector.TimelineUIUtils.isCoalescable = function(recordType)
 {
     return !!WebInspector.TimelineUIUtils._coalescableRecordTypes[recordType];
 }
 
 /**
  * @param {!WebInspector.TimelineModel.Record} record
  * @return {?Object}
  */
 WebInspector.TimelineUIUtils.isCoalescable.countersForRecord = function(record)
 {
-    return record.type() === WebInspector.TracingTimelineModel.RecordType.UpdateCounters ? record.data() : null;
+    return record.type() === WebInspector.TimelineModel.RecordType.UpdateCounters ? record.data() : null;
 }
 
 /**
  * @param {!WebInspector.TimelineModel.Record} record
  * @param {!RegExp} regExp
  * @return {boolean}
  */
 WebInspector.TimelineUIUtils.testContentMatching = function(record, regExp)
 {
     var traceEvent = record.traceEvent();
@@ skipping 41 matching lines @@
 WebInspector.TimelineUIUtils.markerEventColor = function(event)
 {
     var red = "rgb(255, 0, 0)";
     var blue = "rgb(0, 0, 255)";
     var orange = "rgb(255, 178, 23)";
     var green = "rgb(0, 130, 0)";
 
     if (event.category === WebInspector.TracingModel.ConsoleEventCategory)
         return orange;
 
-    var recordTypes = WebInspector.TracingTimelineModel.RecordType;
+    var recordTypes = WebInspector.TimelineModel.RecordType;
     var eventName = event.name;
     switch (eventName) {
     case recordTypes.MarkDOMContent: return blue;
     case recordTypes.MarkLoad: return red;
     case recordTypes.MarkFirstPaint: return green;
     case recordTypes.TimeStamp: return orange;
     }
     return green;
 }
 
@@ skipping 10 matching lines @@
 /**
  * @param {!WebInspector.TracingModel.Event} event
  * @param {!WebInspector.TimelineModel} model
  * @return {string}
  */
 WebInspector.TimelineUIUtils.eventTitle = function(event, model)
 {
     var title = WebInspector.TimelineUIUtils.eventStyle(event).title;
     if (event.category === WebInspector.TracingModel.ConsoleEventCategory)
         return title;
-    if (event.name === WebInspector.TracingTimelineModel.RecordType.TimeStamp)
+    if (event.name === WebInspector.TimelineModel.RecordType.TimeStamp)
         return WebInspector.UIString("%s: %s", title, event.args["data"]["message"]);
     if (WebInspector.TimelineUIUtils.isMarkerEvent(event)) {
         var startTime = Number.millisToString(event.startTime - model.minimumRecordTime());
         return WebInspector.UIString("%s at %s", title, startTime);
     }
     return title;
 }
 
 /**
  * @param {!WebInspector.TracingModel.Event} event
  * @return {boolean}
  */
 WebInspector.TimelineUIUtils.isMarkerEvent = function(event)
 {
-    var recordTypes = WebInspector.TracingTimelineModel.RecordType;
+    var recordTypes = WebInspector.TimelineModel.RecordType;
     switch (event.name) {
     case recordTypes.TimeStamp:
     case recordTypes.MarkFirstPaint:
         return true;
     case recordTypes.MarkDOMContent:
     case recordTypes.MarkLoad:
         return event.args["data"]["isMainFrame"];
     default:
         return false;
     }
 }
 
 /**
  * @param {!WebInspector.TracingModel.Event} event
  * @return {boolean}
  */
 WebInspector.TimelineUIUtils.isTallMarkerEvent = function(event)
 {
-    return event.name !== WebInspector.TracingTimelineModel.RecordType.TimeStamp;
+    return event.name !== WebInspector.TimelineModel.RecordType.TimeStamp;
 }
 
 /**
  * @param {!WebInspector.TracingModel.Event} event
  * @param {!WebInspector.Linkifier} linkifier
  * @return {?Node}
  */
 WebInspector.TimelineUIUtils.buildDetailsNodeForTraceEvent = function(event, linkifier)
 {
-    var recordType = WebInspector.TracingTimelineModel.RecordType;
+    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:
@@ skipping 108 matching lines @@
                 stackTrace = initiator.stackTrace;
         }
         if (!stackTrace || !stackTrace.length)
             return null;
         return linkifier.linkifyConsoleCallFrame(target, stackTrace[0], "timeline-details");
     }
 }
 
 /**
  * @param {!WebInspector.TracingModel.Event} event
- * @param {!WebInspector.TracingTimelineModel} model
+ * @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 relatedNode = null;
     var barrier = new CallbackBarrier();
     if (!event.previewElement) {
         if (event.imageURL && target)
@@ skipping 51 matching lines @@
     }
 
     function callbackWrapper()
     {
         callback(WebInspector.TimelineUIUtils._buildTraceEventDetailsSynchronously(event, model, linkifier, relatedNode));
     }
 }
 
 /**
  * @param {!WebInspector.TracingModel.Event} event
- * @param {!WebInspector.TracingTimelineModel} model
+ * @param {!WebInspector.TimelineModel} model
  * @param {!WebInspector.Linkifier} linkifier
  * @param {?WebInspector.DOMNode} relatedNode
  * @return {!DocumentFragment}
  */
 WebInspector.TimelineUIUtils._buildTraceEventDetailsSynchronously = function(event, model, linkifier, relatedNode)
 {
     var fragment = createDocumentFragment();
     var stats = {};
     var hasChildren = WebInspector.TimelineUIUtils._aggregatedStatsForTraceEvent(stats, model, event);
 
     var selfTime = event.selfTime;
     var selfCategory = WebInspector.TimelineUIUtils.eventStyle(event).category;
     // JSFrame events have 0 selfTime so we need to work around this below and add the event's time to scripting category.
-    if (event.name === WebInspector.TracingTimelineModel.RecordType.JSFrame && !event.selfTime && event.duration) {
+    if (event.name === WebInspector.TimelineModel.RecordType.JSFrame && !event.selfTime && event.duration) {
         selfTime = event.duration;
         for (var categoryName in stats)
             selfTime -= stats[categoryName];
         stats[selfCategory.name] = selfTime + (stats[selfCategory.name] || 0);
     }
 
     var pieChart = hasChildren ?
         WebInspector.TimelineUIUtils.generatePieChart(stats, selfCategory, selfTime) :
         WebInspector.TimelineUIUtils.generatePieChart(stats);
 
-    var recordTypes = WebInspector.TracingTimelineModel.RecordType;
+    var recordTypes = WebInspector.TimelineModel.RecordType;
 
     // This message may vary per event.name;
     var relatedNodeLabel;
 
     var contentHelper = new WebInspector.TimelineDetailsContentHelper(event.thread.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"];
@@ skipping 121 matching lines @@
 
     return fragment;
 }
 
 /**
  * @param {!WebInspector.TracingModel.Event} event
  * @param {!WebInspector.TimelineDetailsContentHelper} contentHelper
  */
 WebInspector.TimelineUIUtils._generateCauses = function(event, contentHelper)
 {
-    var recordTypes = WebInspector.TracingTimelineModel.RecordType;
+    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:
@@ skipping 47 matching lines @@
 /**
  * @param {string} type
  * @param {?WebInspector.Target} target
  * @param {!Object} invalidationEvents
  * @param {!WebInspector.TimelineDetailsContentHelper} contentHelper
  */
 WebInspector.TimelineUIUtils._generateInvalidationsForType = function(type, target, invalidationEvents, contentHelper)
 {
     var title;
     switch (type) {
-    case WebInspector.TracingTimelineModel.RecordType.StyleRecalcInvalidationTracking:
+    case WebInspector.TimelineModel.RecordType.StyleRecalcInvalidationTracking:
         title = WebInspector.UIString("Style invalidations");
         break;
-    case WebInspector.TracingTimelineModel.RecordType.LayoutInvalidationTracking:
+    case WebInspector.TimelineModel.RecordType.LayoutInvalidationTracking:
         title = WebInspector.UIString("Layout invalidations");
         break;
     default:
         title = WebInspector.UIString("Other invalidations");
         break;
     }
 
     var detailsNode = createElementWithClass("div", "timeline-details-view-row");
     var titleElement = detailsNode.createChild("span", "timeline-details-view-row-title");
     titleElement.textContent = WebInspector.UIString("%s: ", title);
@@ skipping 52 matching lines @@
     });
 }
 
 /**
  * @param {!Object} total
  * @param {!WebInspector.TimelineModel.Record} record
  */
 WebInspector.TimelineUIUtils.aggregateTimeForRecord = function(total, record)
 {
     var traceEvent = record.traceEvent();
-    var model = record._model;
+    var model = record.timelineModel();
     WebInspector.TimelineUIUtils._aggregatedStatsForTraceEvent(total, model, traceEvent);
 }
 
 /**
  * @param {!Object} total
- * @param {!WebInspector.TracingTimelineModel} model
+ * @param {!WebInspector.TimelineModel} model
  * @param {!WebInspector.TracingModel.Event} event
  * @return {boolean}
  */
 WebInspector.TimelineUIUtils._aggregatedStatsForTraceEvent = function(total, model, event)
 {
     var events = model.inspectedTargetEvents();
     /**
      * @param {number} startTime
      * @param {!WebInspector.TracingModel.Event} e
      * @return {number}
@@ skipping 73 matching lines @@
 
 /**
  * @param {string} recordType
  * @param {string=} title
  * @return {!Element}
  */
 WebInspector.TimelineUIUtils.createEventDivider = function(recordType, title)
 {
     var eventDivider = createElement("div");
     eventDivider.className = "resources-event-divider";
-    var recordTypes = WebInspector.TracingTimelineModel.RecordType;
+    var recordTypes = WebInspector.TimelineModel.RecordType;
 
     if (recordType === recordTypes.MarkDOMContent)
         eventDivider.className += " resources-blue-divider";
     else if (recordType === recordTypes.MarkLoad)
         eventDivider.className += " resources-red-divider";
     else if (recordType === recordTypes.MarkFirstPaint)
         eventDivider.className += " resources-green-divider";
     else if (recordType === recordTypes.TimeStamp || recordType === recordTypes.ConsoleTime)
         eventDivider.className += " resources-orange-divider";
     else if (recordType === recordTypes.BeginFrame)
@@ skipping 21 matching lines @@
     var eventStyles = WebInspector.TimelineUIUtils._initEventStyles();
     var result = [];
     for (var name in eventStyles) {
         if (!eventStyles[name].hidden)
             result.push(name);
     }
     return result;
 }
 
 /**
- * @return {!WebInspector.TracingTimelineModel.Filter}
+ * @return {!WebInspector.TraceEventFilter}
  */
 WebInspector.TimelineUIUtils.hiddenEventsFilter = function()
 {
-    return new WebInspector.TracingTimelineModel.InclusiveEventNameFilter(WebInspector.TimelineUIUtils._visibleTypes());
+    return new WebInspector.InclusiveTraceEventNameFilter(WebInspector.TimelineUIUtils._visibleTypes());
 }
 
 /**
  * @return {!Object.<string, !WebInspector.TimelineCategory>}
  */
 WebInspector.TimelineUIUtils.categories = function()
 {
     if (WebInspector.TimelineUIUtils._categories)
         return WebInspector.TimelineUIUtils._categories;
     WebInspector.TimelineUIUtils._categories = {
@@ skipping 380 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);
         }
     }
 }