OLD | NEW |
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 Loading... |
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 Loading... |
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 } |
OLD | NEW |