Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(135)

Side by Side Diff: Source/devtools/front_end/timeline/TimelineUIUtils.js

Issue 713913002: DevTools: merge TracingTimelineUIUtils into TimelineUIUtils (Closed) Base URL: svn://svn.chromium.org/blink/trunk
Patch Set: Deleted instance refs Created 6 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
1 /* 1 /*
2 * Copyright (C) 2013 Google Inc. All rights reserved. 2 * Copyright (C) 2013 Google Inc. All rights reserved.
3 * Copyright (C) 2012 Intel Inc. All rights reserved. 3 * Copyright (C) 2012 Intel Inc. All rights reserved.
4 * 4 *
5 * Redistribution and use in source and binary forms, with or without 5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are 6 * modification, are permitted provided that the following conditions are
7 * met: 7 * met:
8 * 8 *
9 * * Redistributions of source code must retain the above copyright 9 * * Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer. 10 * notice, this list of conditions and the following disclaimer.
(...skipping 16 matching lines...) Expand all
27 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */ 30 */
31 31
32 /** 32 /**
33 * @constructor 33 * @constructor
34 */ 34 */
35 WebInspector.TimelineUIUtils = function() { } 35 WebInspector.TimelineUIUtils = function() { }
36 36
37 WebInspector.TimelineUIUtils.prototype = { 37 /**
38 * @constructor
39 * @param {string} title
40 * @param {!WebInspector.TimelineCategory} category
41 * @param {boolean=} hidden
42 */
43 WebInspector.TimelineRecordStyle = function(title, category, hidden)
44 {
45 this.title = title;
46 this.category = category;
47 this.hidden = !!hidden;
48 }
49
50 /**
51 * @return {!Object.<string, !WebInspector.TimelineRecordStyle>}
52 */
53 WebInspector.TimelineUIUtils._initEventStyles = function()
54 {
55 if (WebInspector.TimelineUIUtils._eventStylesMap)
56 return WebInspector.TimelineUIUtils._eventStylesMap;
57
58 var recordTypes = WebInspector.TracingTimelineModel.RecordType;
59 var categories = WebInspector.TimelineUIUtils.categories();
60
61 var eventStyles = {};
62 eventStyles[recordTypes.Program] = new WebInspector.TimelineRecordStyle(WebI nspector.UIString("Other"), categories["other"]);
63 eventStyles[recordTypes.EventDispatch] = new WebInspector.TimelineRecordStyl e(WebInspector.UIString("Event"), categories["scripting"]);
64 eventStyles[recordTypes.RequestMainThreadFrame] = new WebInspector.TimelineR ecordStyle(WebInspector.UIString("Request Main Thread Frame"), categories["rende ring"], true);
65 eventStyles[recordTypes.BeginFrame] = new WebInspector.TimelineRecordStyle(W ebInspector.UIString("Frame Start"), categories["rendering"], true);
66 eventStyles[recordTypes.BeginMainThreadFrame] = new WebInspector.TimelineRec ordStyle(WebInspector.UIString("Frame Start (main thread)"), categories["renderi ng"], true);
67 eventStyles[recordTypes.DrawFrame] = new WebInspector.TimelineRecordStyle(We bInspector.UIString("Draw Frame"), categories["rendering"], true);
68 eventStyles[recordTypes.ScheduleStyleRecalculation] = new WebInspector.Timel ineRecordStyle(WebInspector.UIString("Schedule Style Recalculation"), categories ["rendering"], true);
69 eventStyles[recordTypes.RecalculateStyles] = new WebInspector.TimelineRecord Style(WebInspector.UIString("Recalculate Style"), categories["rendering"]);
70 eventStyles[recordTypes.InvalidateLayout] = new WebInspector.TimelineRecordS tyle(WebInspector.UIString("Invalidate Layout"), categories["rendering"], true);
71 eventStyles[recordTypes.Layout] = new WebInspector.TimelineRecordStyle(WebIn spector.UIString("Layout"), categories["rendering"]);
72 eventStyles[recordTypes.PaintSetup] = new WebInspector.TimelineRecordStyle(W ebInspector.UIString("Paint Setup"), categories["painting"]);
73 eventStyles[recordTypes.UpdateLayer] = new WebInspector.TimelineRecordStyle( WebInspector.UIString("Update Layer"), categories["painting"], true);
74 eventStyles[recordTypes.UpdateLayerTree] = new WebInspector.TimelineRecordSt yle(WebInspector.UIString("Update Layer Tree"), categories["rendering"]);
75 eventStyles[recordTypes.Paint] = new WebInspector.TimelineRecordStyle(WebIns pector.UIString("Paint"), categories["painting"]);
76 eventStyles[recordTypes.RasterTask] = new WebInspector.TimelineRecordStyle(W ebInspector.UIString("Paint"), categories["painting"]);
77 eventStyles[recordTypes.ScrollLayer] = new WebInspector.TimelineRecordStyle( WebInspector.UIString("Scroll"), categories["rendering"]);
78 eventStyles[recordTypes.CompositeLayers] = new WebInspector.TimelineRecordSt yle(WebInspector.UIString("Composite Layers"), categories["painting"]);
79 eventStyles[recordTypes.ParseHTML] = new WebInspector.TimelineRecordStyle(We bInspector.UIString("Parse HTML"), categories["loading"]);
80 eventStyles[recordTypes.TimerInstall] = new WebInspector.TimelineRecordStyle (WebInspector.UIString("Install Timer"), categories["scripting"]);
81 eventStyles[recordTypes.TimerRemove] = new WebInspector.TimelineRecordStyle( WebInspector.UIString("Remove Timer"), categories["scripting"]);
82 eventStyles[recordTypes.TimerFire] = new WebInspector.TimelineRecordStyle(We bInspector.UIString("Timer Fired"), categories["scripting"]);
83 eventStyles[recordTypes.XHRReadyStateChange] = new WebInspector.TimelineReco rdStyle(WebInspector.UIString("XHR Ready State Change"), categories["scripting"] );
84 eventStyles[recordTypes.XHRLoad] = new WebInspector.TimelineRecordStyle(WebI nspector.UIString("XHR Load"), categories["scripting"]);
85 eventStyles[recordTypes.EvaluateScript] = new WebInspector.TimelineRecordSty le(WebInspector.UIString("Evaluate Script"), categories["scripting"]);
86 eventStyles[recordTypes.MarkLoad] = new WebInspector.TimelineRecordStyle(Web Inspector.UIString("Load event"), categories["scripting"], true);
87 eventStyles[recordTypes.MarkDOMContent] = new WebInspector.TimelineRecordSty le(WebInspector.UIString("DOMContentLoaded event"), categories["scripting"], tru e);
88 eventStyles[recordTypes.MarkFirstPaint] = new WebInspector.TimelineRecordSty le(WebInspector.UIString("First paint"), categories["painting"], true);
89 eventStyles[recordTypes.TimeStamp] = new WebInspector.TimelineRecordStyle(We bInspector.UIString("Timestamp"), categories["scripting"]);
90 eventStyles[recordTypes.ConsoleTime] = new WebInspector.TimelineRecordStyle( WebInspector.UIString("Console Time"), categories["scripting"]);
91 eventStyles[recordTypes.ResourceSendRequest] = new WebInspector.TimelineReco rdStyle(WebInspector.UIString("Send Request"), categories["loading"]);
92 eventStyles[recordTypes.ResourceReceiveResponse] = new WebInspector.Timeline RecordStyle(WebInspector.UIString("Receive Response"), categories["loading"]);
93 eventStyles[recordTypes.ResourceFinish] = new WebInspector.TimelineRecordSty le(WebInspector.UIString("Finish Loading"), categories["loading"]);
94 eventStyles[recordTypes.ResourceReceivedData] = new WebInspector.TimelineRec ordStyle(WebInspector.UIString("Receive Data"), categories["loading"]);
95 eventStyles[recordTypes.FunctionCall] = new WebInspector.TimelineRecordStyle (WebInspector.UIString("Function Call"), categories["scripting"]);
96 eventStyles[recordTypes.GCEvent] = new WebInspector.TimelineRecordStyle(WebI nspector.UIString("GC Event"), categories["scripting"]);
97 eventStyles[recordTypes.JSFrame] = new WebInspector.TimelineRecordStyle(WebI nspector.UIString("JS Frame"), categories["scripting"]);
98 eventStyles[recordTypes.RequestAnimationFrame] = new WebInspector.TimelineRe cordStyle(WebInspector.UIString("Request Animation Frame"), categories["scriptin g"]);
99 eventStyles[recordTypes.CancelAnimationFrame] = new WebInspector.TimelineRec ordStyle(WebInspector.UIString("Cancel Animation Frame"), categories["scripting" ]);
100 eventStyles[recordTypes.FireAnimationFrame] = new WebInspector.TimelineRecor dStyle(WebInspector.UIString("Animation Frame Fired"), categories["scripting"]);
101 eventStyles[recordTypes.WebSocketCreate] = new WebInspector.TimelineRecordSt yle(WebInspector.UIString("Create WebSocket"), categories["scripting"]);
102 eventStyles[recordTypes.WebSocketSendHandshakeRequest] = new WebInspector.Ti melineRecordStyle(WebInspector.UIString("Send WebSocket Handshake"), categories[ "scripting"]);
103 eventStyles[recordTypes.WebSocketReceiveHandshakeResponse] = new WebInspecto r.TimelineRecordStyle(WebInspector.UIString("Receive WebSocket Handshake"), cate gories["scripting"]);
104 eventStyles[recordTypes.WebSocketDestroy] = new WebInspector.TimelineRecordS tyle(WebInspector.UIString("Destroy WebSocket"), categories["scripting"]);
105 eventStyles[recordTypes.EmbedderCallback] = new WebInspector.TimelineRecordS tyle(WebInspector.UIString("Embedder Callback"), categories["scripting"]);
106 eventStyles[recordTypes.DecodeImage] = new WebInspector.TimelineRecordStyle( WebInspector.UIString("Image Decode"), categories["painting"]);
107 eventStyles[recordTypes.ResizeImage] = new WebInspector.TimelineRecordStyle( WebInspector.UIString("Image Resize"), categories["painting"]);
108 WebInspector.TimelineUIUtils._eventStylesMap = eventStyles;
109 return eventStyles;
110 }
111
112 WebInspector.TimelineUIUtils._coalescableRecordTypes = {};
113 WebInspector.TimelineUIUtils._coalescableRecordTypes[WebInspector.TracingTimelin eModel.RecordType.Layout] = 1;
114 WebInspector.TimelineUIUtils._coalescableRecordTypes[WebInspector.TracingTimelin eModel.RecordType.Paint] = 1;
115 WebInspector.TimelineUIUtils._coalescableRecordTypes[WebInspector.TracingTimelin eModel.RecordType.RasterTask] = 1;
116 WebInspector.TimelineUIUtils._coalescableRecordTypes[WebInspector.TracingTimelin eModel.RecordType.DecodeImage] = 1;
117 WebInspector.TimelineUIUtils._coalescableRecordTypes[WebInspector.TracingTimelin eModel.RecordType.ResizeImage] = 1;
118
119 /**
120 * @param {string} recordType
121 * @return {boolean}
122 */
123 WebInspector.TimelineUIUtils.isCoalescable = function(recordType)
124 {
125 return !!WebInspector.TimelineUIUtils._coalescableRecordTypes[recordType];
126 }
127
128 /**
129 * @param {!WebInspector.TimelineModel.Record} record
130 * @return {?Object}
131 */
132 WebInspector.TimelineUIUtils.isCoalescable.countersForRecord = function(record)
133 {
134 return record.type() === WebInspector.TracingTimelineModel.RecordType.Update Counters ? record.data() : null;
135 }
136
137 /**
138 * @param {!WebInspector.TimelineModel.Record} record
139 * @param {!RegExp} regExp
140 * @return {boolean}
141 */
142 WebInspector.TimelineUIUtils.testContentMatching = function(record, regExp)
143 {
144 var traceEvent = record.traceEvent();
145 var title = WebInspector.TimelineUIUtils.eventStyle(traceEvent).title;
146 var tokens = [title];
147 for (var argName in traceEvent.args) {
148 var argValue = traceEvent.args[argName];
149 for (var key in argValue)
150 tokens.push(argValue[key]);
151 }
152 return regExp.test(tokens.join("|"));
153 }
154
155 /**
156 * @param {!WebInspector.TimelineModel.Record} record
157 * @return {!WebInspector.TimelineCategory}
158 */
159 WebInspector.TimelineUIUtils.categoryForRecord = function(record)
160 {
161 return WebInspector.TimelineUIUtils.eventStyle(record.traceEvent()).category ;
162 }
163
164 /**
165 * @param {!WebInspector.TracingModel.Event} event
166 * @return {!{title: string, category: !WebInspector.TimelineCategory}}
167 */
168 WebInspector.TimelineUIUtils.eventStyle = function(event)
169 {
170 var eventStyles = WebInspector.TimelineUIUtils._initEventStyles();
171 if (event.category === WebInspector.TracingModel.ConsoleEventCategory)
172 return { title: event.name, category: WebInspector.TimelineUIUtils.categ ories()["scripting"] };
173
174 var result = eventStyles[event.name];
175 if (!result) {
176 result = new WebInspector.TimelineRecordStyle(WebInspector.UIString("Unk nown: %s", event.name), WebInspector.TimelineUIUtils.categories()["other"]);
177 eventStyles[event.name] = result;
178 }
179 return result;
180 }
181
182 /**
183 * @param {!WebInspector.TracingModel.Event} event
184 * @return {string}
185 */
186 WebInspector.TimelineUIUtils.markerEventColor = function(event)
187 {
188 var red = "rgb(255, 0, 0)";
189 var blue = "rgb(0, 0, 255)";
190 var orange = "rgb(255, 178, 23)";
191 var green = "rgb(0, 130, 0)";
192
193 if (event.category === WebInspector.TracingModel.ConsoleEventCategory)
194 return orange;
195
196 var recordTypes = WebInspector.TracingTimelineModel.RecordType;
197 var eventName = event.name;
198 switch (eventName) {
199 case recordTypes.MarkDOMContent: return blue;
200 case recordTypes.MarkLoad: return red;
201 case recordTypes.MarkFirstPaint: return green;
202 case recordTypes.TimeStamp: return orange;
203 }
204 return green;
205 }
206
207 /**
208 * @param {!WebInspector.TimelineModel.Record} record
209 * @return {string}
210 */
211 WebInspector.TimelineUIUtils.titleForRecord = function(record)
212 {
213 var event = record.traceEvent();
214 return WebInspector.TimelineUIUtils.eventTitle(event, record.timelineModel() );
215 }
216
217 /**
218 * @param {!WebInspector.TracingModel.Event} event
219 * @param {!WebInspector.TimelineModel} model
220 * @return {string}
221 */
222 WebInspector.TimelineUIUtils.eventTitle = function(event, model)
223 {
224 var title = WebInspector.TimelineUIUtils.eventStyle(event).title;
225 if (event.category === WebInspector.TracingModel.ConsoleEventCategory)
226 return title;
227 if (event.name === WebInspector.TracingTimelineModel.RecordType.TimeStamp)
228 return WebInspector.UIString("%s: %s", title, event.args["data"]["messag e"]);
229 if (WebInspector.TimelineUIUtils.isMarkerEvent(event)) {
230 var startTime = Number.millisToString(event.startTime - model.minimumRec ordTime());
231 return WebInspector.UIString("%s at %s", title, startTime);
232 }
233 return title;
234 }
235
236 /**
237 * @param {!WebInspector.TracingModel.Event} event
238 * @return {boolean}
239 */
240 WebInspector.TimelineUIUtils.isMarkerEvent = function(event)
241 {
242 var recordTypes = WebInspector.TracingTimelineModel.RecordType;
243 switch (event.name) {
244 case recordTypes.TimeStamp:
245 case recordTypes.MarkFirstPaint:
246 return true;
247 case recordTypes.MarkDOMContent:
248 case recordTypes.MarkLoad:
249 return event.args["data"]["isMainFrame"];
250 default:
251 return false;
252 }
253 }
254
255 /**
256 * @param {!WebInspector.TracingModel.Event} event
257 * @return {boolean}
258 */
259 WebInspector.TimelineUIUtils.isTallMarkerEvent = function(event)
260 {
261 return event.name !== WebInspector.TracingTimelineModel.RecordType.TimeStamp ;
262 }
263
264 /**
265 * @param {!WebInspector.TracingModel.Event} event
266 * @param {!WebInspector.Linkifier} linkifier
267 * @return {?Node}
268 */
269 WebInspector.TimelineUIUtils.buildDetailsNodeForTraceEvent = function(event, lin kifier)
270 {
271 var recordType = WebInspector.TracingTimelineModel.RecordType;
272 var target = event.thread.target();
273 var details;
274 var detailsText;
275 var eventData = event.args["data"];
276 switch (event.name) {
277 case recordType.GCEvent:
278 var delta = event.args["usedHeapSizeBefore"] - event.args["usedHeapSizeA fter"];
279 detailsText = WebInspector.UIString("%s collected", Number.bytesToString (delta));
280 break;
281 case recordType.TimerFire:
282 detailsText = eventData["timerId"];
283 break;
284 case recordType.FunctionCall:
285 details = linkifyLocation(eventData["scriptId"], eventData["scriptName"] , eventData["scriptLine"], 0);
286 break;
287 case recordType.JSFrame:
288 details = linkifyLocation(eventData["scriptId"], eventData["url"], event Data["lineNumber"], eventData["columnNumber"]);
289 detailsText = WebInspector.CPUProfileDataModel.beautifyFunctionName(even tData["functionName"]);
290 if (details && detailsText)
291 details.textContent = detailsText;
292 break;
293 case recordType.FireAnimationFrame:
294 detailsText = eventData["id"];
295 break;
296 case recordType.EventDispatch:
297 detailsText = eventData ? eventData["type"] : null;
298 break;
299 case recordType.Paint:
300 var width = WebInspector.TimelineUIUtils.quadWidth(eventData.clip);
301 var height = WebInspector.TimelineUIUtils.quadHeight(eventData.clip);
302 if (width && height)
303 detailsText = WebInspector.UIString("%d\u2009\u00d7\u2009%d", width, height);
304 break;
305 case recordType.TimerInstall:
306 case recordType.TimerRemove:
307 details = linkifyTopCallFrame();
308 detailsText = eventData["timerId"];
309 break;
310 case recordType.RequestAnimationFrame:
311 case recordType.CancelAnimationFrame:
312 details = linkifyTopCallFrame();
313 detailsText = eventData["id"];
314 break;
315 case recordType.ParseHTML:
316 case recordType.RecalculateStyles:
317 details = linkifyTopCallFrame();
318 break;
319 case recordType.EvaluateScript:
320 var url = eventData["url"];
321 if (url)
322 details = linkifyLocation("", url, eventData["lineNumber"], 0);
323 break;
324 case recordType.XHRReadyStateChange:
325 case recordType.XHRLoad:
326 case recordType.ResourceSendRequest:
327 var url = eventData["url"];
328 if (url)
329 detailsText = WebInspector.displayNameForURL(url);
330 break;
331 case recordType.ResourceReceivedData:
332 case recordType.ResourceReceiveResponse:
333 case recordType.ResourceFinish:
334 var initiator = event.initiator;
335 if (initiator) {
336 var url = initiator.args["data"]["url"];
337 if (url)
338 detailsText = WebInspector.displayNameForURL(url);
339 }
340 break;
341 case recordType.EmbedderCallback:
342 detailsText = eventData["callbackName"];
343 break;
344
345 case recordType.PaintImage:
346 case recordType.DecodeImage:
347 case recordType.ResizeImage:
348 case recordType.DecodeLazyPixelRef:
349 var url = event.imageURL;
350 if (url)
351 detailsText = WebInspector.displayNameForURL(url);
352 break;
353
354 default:
355 if (event.category === WebInspector.TracingModel.ConsoleEventCategory)
356 detailsText = null;
357 else
358 details = linkifyTopCallFrame();
359 break;
360 }
361
362 if (!details && detailsText)
363 details = createTextNode(detailsText);
364 return details;
365
38 /** 366 /**
39 * @param {!WebInspector.TimelineModel.Record} record 367 * @param {string} scriptId
40 * @return {boolean} 368 * @param {string} url
369 * @param {number} lineNumber
370 * @param {number=} columnNumber
41 */ 371 */
42 isBeginFrame: function(record) 372 function linkifyLocation(scriptId, url, lineNumber, columnNumber)
43 { 373 {
44 throw new Error("Not implemented."); 374 if (!url)
45 }, 375 return null;
376
377 // FIXME(62725): stack trace line/column numbers are one-based.
378 return linkifier.linkifyScriptLocation(target, scriptId, url, lineNumber - 1, (columnNumber ||1) - 1, "timeline-details");
379 }
380
46 /** 381 /**
47 * @param {!WebInspector.TimelineModel.Record} record 382 * @return {?Element}
48 * @return {boolean}
49 */ 383 */
50 isProgram: function(record) 384 function linkifyTopCallFrame()
51 { 385 {
52 throw new Error("Not implemented."); 386 var stackTrace = event.stackTrace;
53 }, 387 if (!stackTrace) {
388 var initiator = event.initiator;
389 if (initiator)
390 stackTrace = initiator.stackTrace;
391 }
392 if (!stackTrace || !stackTrace.length)
393 return null;
394 return linkifier.linkifyConsoleCallFrame(target, stackTrace[0], "timelin e-details");
395 }
396 }
397
398 /**
399 * @param {!WebInspector.TracingModel.Event} event
400 * @param {!WebInspector.TracingTimelineModel} model
401 * @param {!WebInspector.Linkifier} linkifier
402 * @param {function(!DocumentFragment)} callback
403 */
404 WebInspector.TimelineUIUtils.buildTraceEventDetails = function(event, model, lin kifier, callback)
405 {
406 var target = event.thread.target();
407 var relatedNode = null;
408 var barrier = new CallbackBarrier();
409 if (!event.previewElement) {
410 if (event.imageURL && target)
411 WebInspector.DOMPresentationUtils.buildImagePreviewContents(target, event.imageURL, false, barrier.createCallback(saveImage));
412 else if (event.picture)
413 WebInspector.TimelineUIUtils.buildPicturePreviewContent(event, barri er.createCallback(saveImage));
414 }
415 if (event.backendNodeId && target)
416 target.domModel.pushNodesByBackendIdsToFrontend([event.backendNodeId], b arrier.createCallback(setRelatedNode));
417 if (event.invalidationTrackingEvents)
418 WebInspector.TimelineUIUtils._pushInvalidationNodeIdsToFrontend(event, b arrier.createCallback(updateInvalidationNodeIds));
419 barrier.callWhenDone(callbackWrapper);
420
54 /** 421 /**
55 * @param {string} recordType 422 * @param {!Element=} element
56 * @return {boolean}
57 */ 423 */
58 isCoalescable: function(recordType) 424 function saveImage(element)
59 { 425 {
60 throw new Error("Not implemented."); 426 event.previewElement = element || null;
61 }, 427 }
428
62 /** 429 /**
63 * @param {!WebInspector.TimelineModel.Record} record 430 * @param {?Array.<!DOMAgent.NodeId>} nodeIds
64 * @return {boolean}
65 */ 431 */
66 isEventDivider: function(record) 432 function setRelatedNode(nodeIds)
67 { 433 {
68 throw new Error("Not implemented."); 434 if (nodeIds)
69 }, 435 relatedNode = target.domModel.nodeForId(nodeIds[0]);
436 }
437
70 /** 438 /**
71 * @param {!WebInspector.TimelineModel.Record} record 439 * @param {?Array.<!DOMAgent.NodeId>} frontendNodeIds
72 * @return {?Object} 440 * @param {?Array.<!DOMAgent.NodeId>} backendNodeIds
73 */ 441 */
74 countersForRecord: function(record) 442 function updateInvalidationNodeIds(frontendNodeIds, backendNodeIds)
75 { 443 {
76 throw new Error("Not implemented."); 444 if (!frontendNodeIds)
77 }, 445 return;
446 if (frontendNodeIds.length !== backendNodeIds.length) {
447 console.error("Did not resolve the correct number of invalidation no de ids.");
448 return;
449 }
450
451 var backendToFrontendNodeIdMap = {};
452 backendNodeIds.forEach(function(backendNodeId, index) {
453 backendToFrontendNodeIdMap[backendNodeId] = frontendNodeIds[index];
454 });
455
456 if (event.nodeId)
457 event.frontendNodeId = backendToFrontendNodeIdMap[event.nodeId];
458 event.invalidationTrackingEvents.forEach(function(invalidation) {
459 if (invalidation.nodeId)
460 invalidation.frontendNodeId = backendToFrontendNodeIdMap[invalid ation.nodeId];
461 });
462 }
463
464 function callbackWrapper()
465 {
466 callback(WebInspector.TimelineUIUtils._buildTraceEventDetailsSynchronous ly(event, model, linkifier, relatedNode));
467 }
468 }
469
470 /**
471 * @param {!WebInspector.TracingModel.Event} event
472 * @param {!WebInspector.TracingTimelineModel} model
473 * @param {!WebInspector.Linkifier} linkifier
474 * @param {?WebInspector.DOMNode} relatedNode
475 * @return {!DocumentFragment}
476 */
477 WebInspector.TimelineUIUtils._buildTraceEventDetailsSynchronously = function(eve nt, model, linkifier, relatedNode)
478 {
479 var fragment = createDocumentFragment();
480 var stats = {};
481 var hasChildren = WebInspector.TimelineUIUtils._aggregatedStatsForTraceEvent (stats, model, event);
482
483 var selfTime = event.selfTime;
484 var selfCategory = WebInspector.TimelineUIUtils.eventStyle(event).category;
485 // JSFrame events have 0 selfTime so we need to work around this below and a dd the event's time to scripting category.
486 if (event.name === WebInspector.TracingTimelineModel.RecordType.JSFrame && ! event.selfTime && event.duration) {
487 selfTime = event.duration;
488 for (var categoryName in stats)
489 selfTime -= stats[categoryName];
490 stats[selfCategory.name] = selfTime + (stats[selfCategory.name] || 0);
491 }
492
493 var pieChart = hasChildren ?
494 WebInspector.TimelineUIUtils.generatePieChart(stats, selfCategory, selfT ime) :
495 WebInspector.TimelineUIUtils.generatePieChart(stats);
496
497 var recordTypes = WebInspector.TracingTimelineModel.RecordType;
498
499 // This message may vary per event.name;
500 var relatedNodeLabel;
501
502 var contentHelper = new WebInspector.TimelineDetailsContentHelper(event.thre ad.target(), linkifier, true);
503 contentHelper.appendTextRow(WebInspector.UIString("Type"), WebInspector.Time lineUIUtils.eventTitle(event, model));
504 contentHelper.appendTextRow(WebInspector.UIString("Self Time"), Number.milli sToString(event.selfTime, true));
505 contentHelper.appendTextRow(WebInspector.UIString("Start Time"), Number.mill isToString((event.startTime - model.minimumRecordTime())));
506 contentHelper.appendElementRow(WebInspector.UIString("Aggregated Time"), pie Chart);
507 var eventData = event.args["data"];
508 var initiator = event.initiator;
509
510 switch (event.name) {
511 case recordTypes.GCEvent:
512 var delta = event.args["usedHeapSizeBefore"] - event.args["usedHeapSizeA fter"];
513 contentHelper.appendTextRow(WebInspector.UIString("Collected"), Number.b ytesToString(delta));
514 break;
515 case recordTypes.TimerFire:
516 case recordTypes.TimerInstall:
517 case recordTypes.TimerRemove:
518 contentHelper.appendTextRow(WebInspector.UIString("Timer ID"), eventData ["timerId"]);
519 if (event.name === recordTypes.TimerInstall) {
520 contentHelper.appendTextRow(WebInspector.UIString("Timeout"), Number .millisToString(eventData["timeout"]));
521 contentHelper.appendTextRow(WebInspector.UIString("Repeats"), !event Data["singleShot"]);
522 }
523 break;
524 case recordTypes.FireAnimationFrame:
525 contentHelper.appendTextRow(WebInspector.UIString("Callback ID"), eventD ata["id"]);
526 break;
527 case recordTypes.FunctionCall:
528 if (eventData["scriptName"])
529 contentHelper.appendLocationRow(WebInspector.UIString("Location"), e ventData["scriptName"], eventData["scriptLine"]);
530 break;
531 case recordTypes.ResourceSendRequest:
532 case recordTypes.ResourceReceiveResponse:
533 case recordTypes.ResourceReceivedData:
534 case recordTypes.ResourceFinish:
535 var url = (event.name === recordTypes.ResourceSendRequest) ? eventData[" url"] : initiator.args["data"]["url"];
536 if (url)
537 contentHelper.appendElementRow(WebInspector.UIString("Resource"), We bInspector.linkifyResourceAsNode(url));
538 if (eventData["requestMethod"])
539 contentHelper.appendTextRow(WebInspector.UIString("Request Method"), eventData["requestMethod"]);
540 if (typeof eventData["statusCode"] === "number")
541 contentHelper.appendTextRow(WebInspector.UIString("Status Code"), ev entData["statusCode"]);
542 if (eventData["mimeType"])
543 contentHelper.appendTextRow(WebInspector.UIString("MIME Type"), even tData["mimeType"]);
544 if (eventData["encodedDataLength"])
545 contentHelper.appendTextRow(WebInspector.UIString("Encoded Data Leng th"), WebInspector.UIString("%d Bytes", eventData["encodedDataLength"]));
546 break;
547 case recordTypes.EvaluateScript:
548 var url = eventData["url"];
549 if (url)
550 contentHelper.appendLocationRow(WebInspector.UIString("Script"), url , eventData["lineNumber"]);
551 break;
552 case recordTypes.Paint:
553 var clip = eventData["clip"];
554 contentHelper.appendTextRow(WebInspector.UIString("Location"), WebInspec tor.UIString("(%d, %d)", clip[0], clip[1]));
555 var clipWidth = WebInspector.TimelineUIUtils.quadWidth(clip);
556 var clipHeight = WebInspector.TimelineUIUtils.quadHeight(clip);
557 contentHelper.appendTextRow(WebInspector.UIString("Dimensions"), WebInsp ector.UIString("%d × %d", clipWidth, clipHeight));
558 // Fall-through intended.
559
560 case recordTypes.PaintSetup:
561 case recordTypes.Rasterize:
562 case recordTypes.ScrollLayer:
563 relatedNodeLabel = WebInspector.UIString("Layer root");
564 break;
565 case recordTypes.PaintImage:
566 case recordTypes.DecodeLazyPixelRef:
567 case recordTypes.DecodeImage:
568 case recordTypes.ResizeImage:
569 case recordTypes.DrawLazyPixelRef:
570 relatedNodeLabel = WebInspector.UIString("Image element");
571 if (event.imageURL)
572 contentHelper.appendElementRow(WebInspector.UIString("Image URL"), W ebInspector.linkifyResourceAsNode(event.imageURL));
573 break;
574 case recordTypes.RecalculateStyles: // We don't want to see default details.
575 contentHelper.appendTextRow(WebInspector.UIString("Elements affected"), event.args["elementCount"]);
576 break;
577 case recordTypes.Layout:
578 var beginData = event.args["beginData"];
579 contentHelper.appendTextRow(WebInspector.UIString("Nodes that need layou t"), beginData["dirtyObjects"]);
580 contentHelper.appendTextRow(WebInspector.UIString("Layout tree size"), b eginData["totalObjects"]);
581 contentHelper.appendTextRow(WebInspector.UIString("Layout scope"),
582 beginData["partialLayout"] ? WebInspector.UI String("Partial") : WebInspector.UIString("Whole document"));
583 relatedNodeLabel = WebInspector.UIString("Layout root");
584 break;
585 case recordTypes.ConsoleTime:
586 contentHelper.appendTextRow(WebInspector.UIString("Message"), event.name );
587 break;
588 case recordTypes.WebSocketCreate:
589 case recordTypes.WebSocketSendHandshakeRequest:
590 case recordTypes.WebSocketReceiveHandshakeResponse:
591 case recordTypes.WebSocketDestroy:
592 var initiatorData = initiator ? initiator.args["data"] : eventData;
593 if (typeof initiatorData["webSocketURL"] !== "undefined")
594 contentHelper.appendTextRow(WebInspector.UIString("URL"), initiatorD ata["webSocketURL"]);
595 if (typeof initiatorData["webSocketProtocol"] !== "undefined")
596 contentHelper.appendTextRow(WebInspector.UIString("WebSocket Protoco l"), initiatorData["webSocketProtocol"]);
597 if (typeof eventData["message"] !== "undefined")
598 contentHelper.appendTextRow(WebInspector.UIString("Message"), eventD ata["message"]);
599 break;
600 case recordTypes.EmbedderCallback:
601 contentHelper.appendTextRow(WebInspector.UIString("Callback Function"), eventData["callbackName"]);
602 break;
603 default:
604 var detailsNode = WebInspector.TimelineUIUtils.buildDetailsNodeForTraceE vent(event, linkifier);
605 if (detailsNode)
606 contentHelper.appendElementRow(WebInspector.UIString("Details"), det ailsNode);
607 break;
608 }
609
610 if (relatedNode)
611 contentHelper.appendElementRow(relatedNodeLabel || WebInspector.UIString ("Related node"), WebInspector.DOMPresentationUtils.linkifyNodeReference(related Node));
612
613 if (eventData && eventData["scriptName"] && event.name !== recordTypes.Funct ionCall)
614 contentHelper.appendLocationRow(WebInspector.UIString("Function Call"), eventData["scriptName"], eventData["scriptLine"]);
615
616 var warning = event.warning;
617 if (warning) {
618 var div = createElement("div");
619 div.textContent = warning;
620 contentHelper.appendElementRow(WebInspector.UIString("Warning"), div);
621 }
622 if (event.previewElement)
623 contentHelper.appendElementRow(WebInspector.UIString("Preview"), event.p reviewElement);
624
625 if (event.stackTrace || (event.initiator && event.initiator.stackTrace) || e vent.invalidationTrackingEvents)
626 WebInspector.TimelineUIUtils._generateCauses(event, contentHelper);
627
628 fragment.appendChild(contentHelper.element);
629
630 return fragment;
631 }
632
633 /**
634 * @param {!WebInspector.TracingModel.Event} event
635 * @param {!WebInspector.TimelineDetailsContentHelper} contentHelper
636 */
637 WebInspector.TimelineUIUtils._generateCauses = function(event, contentHelper)
638 {
639 var recordTypes = WebInspector.TracingTimelineModel.RecordType;
640
641 var callSiteStackLabel;
642 var stackLabel;
643 var initiator = event.initiator;
644
645 switch (event.name) {
646 case recordTypes.TimerFire:
647 callSiteStackLabel = WebInspector.UIString("Timer installed");
648 break;
649 case recordTypes.FireAnimationFrame:
650 callSiteStackLabel = WebInspector.UIString("Animation frame requested");
651 break;
652 case recordTypes.RecalculateStyles:
653 stackLabel = WebInspector.UIString("Recalculation was forced");
654 break;
655 case recordTypes.Layout:
656 callSiteStackLabel = WebInspector.UIString("First layout invalidation");
657 stackLabel = WebInspector.UIString("Layout forced");
658 break;
659 }
660
661 // Direct cause.
662 if (event.stackTrace)
663 contentHelper.appendStackTrace(stackLabel || WebInspector.UIString("Stac k trace"), event.stackTrace);
664
665 // Indirect causes.
666 if (event.invalidationTrackingEvents) { // Full invalidation tracking (exper imental).
667 WebInspector.TimelineUIUtils._generateInvalidations(event, contentHelper );
668 } else if (initiator && initiator.stackTrace) { // Partial invalidation trac king.
669 contentHelper.appendStackTrace(callSiteStackLabel || WebInspector.UIStri ng("First invalidated"), initiator.stackTrace);
670 }
671 }
672
673 /**
674 * @param {!WebInspector.TracingModel.Event} event
675 * @param {!WebInspector.TimelineDetailsContentHelper} contentHelper
676 */
677 WebInspector.TimelineUIUtils._generateInvalidations = function(event, contentHel per)
678 {
679 if (!event.invalidationTrackingEvents)
680 return;
681
682 var target = event.thread.target();
683 var invalidations = {};
684 event.invalidationTrackingEvents.forEach(function(invalidation) {
685 if (!invalidations[invalidation.type])
686 invalidations[invalidation.type] = [invalidation];
687 else
688 invalidations[invalidation.type].push(invalidation);
689 });
690
691 Object.keys(invalidations).forEach(function(type) {
692 WebInspector.TimelineUIUtils._generateInvalidationsForType(
693 type, target, invalidations[type], contentHelper);
694 });
695 }
696
697 /**
698 * @param {string} type
699 * @param {?WebInspector.Target} target
700 * @param {!Object} invalidationEvents
701 * @param {!WebInspector.TimelineDetailsContentHelper} contentHelper
702 */
703 WebInspector.TimelineUIUtils._generateInvalidationsForType = function(type, targ et, invalidationEvents, contentHelper)
704 {
705 var title;
706 switch (type) {
707 case WebInspector.TracingTimelineModel.RecordType.StyleRecalcInvalidationTra cking:
708 title = WebInspector.UIString("Style invalidations");
709 break;
710 case WebInspector.TracingTimelineModel.RecordType.LayoutInvalidationTracking :
711 title = WebInspector.UIString("Layout invalidations");
712 break;
713 default:
714 title = WebInspector.UIString("Other invalidations");
715 break;
716 }
717
718 var detailsNode = createElementWithClass("div", "timeline-details-view-row") ;
719 var titleElement = detailsNode.createChild("span", "timeline-details-view-ro w-title");
720 titleElement.textContent = WebInspector.UIString("%s: ", title);
721 var eventsList = detailsNode.createChild("ol");
722 invalidationEvents.forEach(appendInvalidations);
723
724 contentHelper.element.appendChild(detailsNode);
725
726
727 function appendInvalidations(invalidation, index)
728 {
729 var row = eventsList.createChild("li");
730 var nodeRow = row.createChild("div");
731 var node = target.domModel.nodeForId(invalidation.frontendNodeId);
732 if (node)
733 nodeRow.appendChild(WebInspector.DOMPresentationUtils.linkifyNodeRef erence(node));
734 else if (invalidation.nodeName)
735 nodeRow.textContent = WebInspector.UIString("[ %s ]", invalidation.n odeName);
736 else
737 nodeRow.textContent = WebInspector.UIString("[ unknown node ]");
738
739 if (invalidation.reason) {
740 var reasonRow = row.createChild("div");
741 var reason = invalidation.reason;
742 reasonRow.textContent = WebInspector.UIString("Reason: %s.", reason) ;
743 }
744
745 if (invalidation.stackTrace)
746 contentHelper.createChildStackTraceElement(row, invalidation.stackTr ace);
747 }
748 }
749
750 /**
751 * @param {!WebInspector.TracingModel.Event} event
752 * @param {function(?Array.<number>, ?Array.<number>)} callback
753 */
754 WebInspector.TimelineUIUtils._pushInvalidationNodeIdsToFrontend = function(event , callback)
755 {
756 var backendNodeIds = [];
757
758 var dedupedNodeIds = {};
759 if (event.nodeId) {
760 backendNodeIds.push(event.nodeId);
761 dedupedNodeIds[event.nodeId] = true;
762 }
763 event.invalidationTrackingEvents.forEach(function(invalidation) {
764 if (invalidation.nodeId && !dedupedNodeIds[invalidation.nodeId]) {
765 backendNodeIds.push(invalidation.nodeId);
766 dedupedNodeIds[invalidation.nodeId] = true;
767 }
768 });
769
770 var target = event.thread.target();
771 target.domModel.pushNodesByBackendIdsToFrontend(backendNodeIds, function(fro ntendNodeIds) {
772 callback(frontendNodeIds, backendNodeIds);
773 });
774 }
775
776 /**
777 * @param {!Object} total
778 * @param {!WebInspector.TimelineModel.Record} record
779 */
780 WebInspector.TimelineUIUtils.aggregateTimeForRecord = function(total, record)
781 {
782 var traceEvent = record.traceEvent();
783 var model = record._model;
784 WebInspector.TimelineUIUtils._aggregatedStatsForTraceEvent(total, model, tra ceEvent);
785 }
786
787 /**
788 * @param {!Object} total
789 * @param {!WebInspector.TracingTimelineModel} model
790 * @param {!WebInspector.TracingModel.Event} event
791 * @return {boolean}
792 */
793 WebInspector.TimelineUIUtils._aggregatedStatsForTraceEvent = function(total, mod el, event)
794 {
795 var events = model.inspectedTargetEvents();
78 /** 796 /**
79 * @param {!WebInspector.TimelineModel.Record} record 797 * @param {number} startTime
80 * @return {?Object} 798 * @param {!WebInspector.TracingModel.Event} e
799 * @return {number}
81 */ 800 */
82 highlightQuadForRecord: function(record) 801 function eventComparator(startTime, e)
83 { 802 {
84 throw new Error("Not implemented."); 803 return startTime - e.startTime;
85 }, 804 }
805 var index = events.binaryIndexOf(event.startTime, eventComparator);
806 var hasChildren = false;
807 var endTime = event.endTime;
808 if (endTime) {
809 for (var i = index; i < events.length; i++) {
810 var nextEvent = events[i];
811 if (nextEvent.startTime >= endTime)
812 break;
813 if (!nextEvent.selfTime)
814 continue;
815 if (nextEvent.thread !== event.thread)
816 continue;
817 if (i > index)
818 hasChildren = true;
819 var categoryName = WebInspector.TimelineUIUtils.eventStyle(nextEvent ).category.name;
820 total[categoryName] = (total[categoryName] || 0) + nextEvent.selfTim e;
821 }
822 }
823 if (WebInspector.TracingModel.isAsyncPhase(event.phase)) {
824 if (event.endTime) {
825 var aggregatedTotal = 0;
826 for (var categoryName in total)
827 aggregatedTotal += total[categoryName];
828 total["idle"] = Math.max(0, event.endTime - event.startTime - aggreg atedTotal);
829 }
830 return false;
831 }
832 return hasChildren;
833 }
834
835 /**
836 * @param {!WebInspector.TracingModel.Event} event
837 * @param {function(!Element=)} callback
838 */
839 WebInspector.TimelineUIUtils.buildPicturePreviewContent = function(event, callba ck)
840 {
841
842 new WebInspector.LayerPaintEvent(event).loadPicture(onSnapshotLoaded);
86 /** 843 /**
87 * @param {!WebInspector.TimelineModel.Record} record 844 * @param {?Array.<number>} rect
88 * @return {string} 845 * @param {?WebInspector.PaintProfilerSnapshot} snapshot
89 */ 846 */
90 titleForRecord: function(record) 847 function onSnapshotLoaded(rect, snapshot)
91 { 848 {
92 throw new Error("Not implemented."); 849 if (!snapshot) {
93 }, 850 callback();
851 return;
852 }
853 snapshot.requestImage(null, null, 1, onGotImage);
854 snapshot.dispose();
855 }
856
94 /** 857 /**
95 * @param {!WebInspector.TimelineModel.Record} record 858 * @param {string=} imageURL
96 * @return {!WebInspector.TimelineCategory}
97 */ 859 */
98 categoryForRecord: function(record) 860 function onGotImage(imageURL)
99 { 861 {
100 throw new Error("Not implemented."); 862 if (!imageURL) {
101 }, 863 callback();
102 /** 864 return;
103 * @param {!WebInspector.TimelineModel.Record} record 865 }
104 * @param {!WebInspector.Linkifier} linkifier 866 var container = createElement("div");
105 * @return {?Node} 867 container.className = "image-preview-container";
106 */ 868 var img = container.createChild("img");
107 buildDetailsNode: function(record, linkifier) 869 img.src = imageURL;
108 { 870 callback(container);
109 throw new Error("Not implemented."); 871 }
110 }, 872 }
111 /** 873
112 * @param {!WebInspector.TimelineModel.Record} record 874 /**
113 * @param {!WebInspector.TimelineModel} model 875 * @param {string} recordType
114 * @param {!WebInspector.Linkifier} linkifier 876 * @param {string=} title
115 * @param {function(!DocumentFragment)} callback 877 * @return {!Element}
116 */ 878 */
117 generateDetailsContent: function(record, model, linkifier, callback) 879 WebInspector.TimelineUIUtils.createEventDivider = function(recordType, title)
118 { 880 {
119 throw new Error("Not implemented."); 881 var eventDivider = createElement("div");
120 }, 882 eventDivider.className = "resources-event-divider";
121 /** 883 var recordTypes = WebInspector.TracingTimelineModel.RecordType;
122 * @return {!Element} 884
123 */ 885 if (recordType === recordTypes.MarkDOMContent)
124 createBeginFrameDivider: function() 886 eventDivider.className += " resources-blue-divider";
125 { 887 else if (recordType === recordTypes.MarkLoad)
126 throw new Error("Not implemented."); 888 eventDivider.className += " resources-red-divider";
127 }, 889 else if (recordType === recordTypes.MarkFirstPaint)
128 /** 890 eventDivider.className += " resources-green-divider";
129 * @param {string} recordType 891 else if (recordType === recordTypes.TimeStamp || recordType === recordTypes. ConsoleTime)
130 * @param {string=} title 892 eventDivider.className += " resources-orange-divider";
131 * @return {!Element} 893 else if (recordType === recordTypes.BeginFrame)
132 */ 894 eventDivider.className += " timeline-frame-divider";
133 createEventDivider: function(recordType, title) 895
134 { 896 if (title)
135 throw new Error("Not implemented."); 897 eventDivider.title = title;
136 }, 898
137 /** 899 return eventDivider;
138 * @param {!WebInspector.TimelineModel.Record} record 900 }
139 * @param {!RegExp} regExp 901
140 * @return {boolean} 902 /**
141 */ 903 * @return {!WebInspector.TimelineModel.Filter}
142 testContentMatching: function(record, regExp) 904 */
143 { 905 WebInspector.TimelineUIUtils.hiddenRecordsFilter = function()
144 throw new Error("Not implemented."); 906 {
145 }, 907 return new WebInspector.TimelineRecordVisibleTypeFilter(WebInspector.Timelin eUIUtils._visibleTypes());
146 /** 908 }
147 * @param {!Object} total 909
148 * @param {!WebInspector.TimelineModel.Record} record 910 /**
149 */ 911 * @return {!Array.<string>}
150 aggregateTimeForRecord: function(total, record) 912 */
151 { 913 WebInspector.TimelineUIUtils._visibleTypes = function()
152 throw new Error("Not implemented."); 914 {
153 }, 915 var eventStyles = WebInspector.TimelineUIUtils._initEventStyles();
154 /** 916 var result = [];
155 * @return {!WebInspector.TimelineModel.Filter} 917 for (var name in eventStyles) {
156 */ 918 if (!eventStyles[name].hidden)
157 hiddenRecordsFilter: function() 919 result.push(name);
158 { 920 }
159 throw new Error("Not implemented."); 921 return result;
160 }, 922 }
161 /** 923
162 * @return {?WebInspector.TimelineModel.Filter} 924 /**
163 */ 925 * @return {!WebInspector.TracingTimelineModel.Filter}
164 hiddenEmptyRecordsFilter: function() 926 */
165 { 927 WebInspector.TimelineUIUtils.hiddenEventsFilter = function()
166 return null; 928 {
167 } 929 return new WebInspector.TracingTimelineModel.InclusiveEventNameFilter(WebIns pector.TimelineUIUtils._visibleTypes());
168 } 930 }
169 931
170 /** 932 /**
171 * @return {!Object.<string, !WebInspector.TimelineCategory>} 933 * @return {!Object.<string, !WebInspector.TimelineCategory>}
172 */ 934 */
173 WebInspector.TimelineUIUtils.categories = function() 935 WebInspector.TimelineUIUtils.categories = function()
174 { 936 {
175 if (WebInspector.TimelineUIUtils._categories) 937 if (WebInspector.TimelineUIUtils._categories)
176 return WebInspector.TimelineUIUtils._categories; 938 return WebInspector.TimelineUIUtils._categories;
177 WebInspector.TimelineUIUtils._categories = { 939 WebInspector.TimelineUIUtils._categories = {
178 loading: new WebInspector.TimelineCategory("loading", WebInspector.UIStr ing("Loading"), 0, "hsl(214, 53%, 58%)", "hsl(214, 67%, 90%)", "hsl(214, 67%, 74 %)", "hsl(214, 67%, 66%)"), 940 loading: new WebInspector.TimelineCategory("loading", WebInspector.UIStr ing("Loading"), 0, "hsl(214, 53%, 58%)", "hsl(214, 67%, 90%)", "hsl(214, 67%, 74 %)", "hsl(214, 67%, 66%)"),
179 scripting: new WebInspector.TimelineCategory("scripting", WebInspector.U IString("Scripting"), 1, "hsl(43, 90%, 45%)", "hsl(43, 83%, 90%)", "hsl(43, 83%, 72%)", "hsl(43, 83%, 64%) "), 941 scripting: new WebInspector.TimelineCategory("scripting", WebInspector.U IString("Scripting"), 1, "hsl(43, 90%, 45%)", "hsl(43, 83%, 90%)", "hsl(43, 83%, 72%)", "hsl(43, 83%, 64%) "),
180 rendering: new WebInspector.TimelineCategory("rendering", WebInspector.U IString("Rendering"), 2, "hsl(256, 50%, 60%)", "hsl(256, 67%, 90%)", "hsl(256, 6 7%, 76%)", "hsl(256, 67%, 70%)"), 942 rendering: new WebInspector.TimelineCategory("rendering", WebInspector.U IString("Rendering"), 2, "hsl(256, 50%, 60%)", "hsl(256, 67%, 90%)", "hsl(256, 6 7%, 76%)", "hsl(256, 67%, 70%)"),
(...skipping 377 matching lines...) Expand 10 before | Expand all | Expand 10 after
558 for (var i = 0; i < stackTrace.length; ++i) { 1320 for (var i = 0; i < stackTrace.length; ++i) {
559 var stackFrame = stackTrace[i]; 1321 var stackFrame = stackTrace[i];
560 var row = stackTraceElement.createChild("div"); 1322 var row = stackTraceElement.createChild("div");
561 row.createTextChild(stackFrame.functionName || WebInspector.UIString ("(anonymous function)")); 1323 row.createTextChild(stackFrame.functionName || WebInspector.UIString ("(anonymous function)"));
562 row.createTextChild(" @ "); 1324 row.createTextChild(" @ ");
563 var urlElement = this._linkifier.linkifyScriptLocation(this._target, stackFrame.scriptId, stackFrame.url, stackFrame.lineNumber - 1, stackFrame.colu mnNumber - 1); 1325 var urlElement = this._linkifier.linkifyScriptLocation(this._target, stackFrame.scriptId, stackFrame.url, stackFrame.lineNumber - 1, stackFrame.colu mnNumber - 1);
564 row.appendChild(urlElement); 1326 row.appendChild(urlElement);
565 } 1327 }
566 } 1328 }
567 } 1329 }
OLDNEW
« no previous file with comments | « Source/devtools/front_end/timeline/TimelinePresentationModel.js ('k') | Source/devtools/front_end/timeline/TimelineView.js » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698