OLD | NEW |
| (Empty) |
1 // Copyright (c) 2009 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 /** | |
6 * @fileoverview Heap profiler panel implementation. | |
7 */ | |
8 | |
9 WebInspector.ProfilesPanel.prototype.addSnapshot = function(snapshot) { | |
10 snapshot.title = WebInspector.UIString("Snapshot %d", snapshot.number); | |
11 | |
12 var snapshots = WebInspector.HeapSnapshotProfileType.snapshots; | |
13 snapshots.push(snapshot); | |
14 | |
15 snapshot.listIndex = snapshots.length - 1; | |
16 | |
17 this.addProfileHeader(WebInspector.HeapSnapshotProfileType.TypeId, snapshot)
; | |
18 | |
19 this.dispatchEventToListeners("snapshot added"); | |
20 } | |
21 | |
22 | |
23 WebInspector.HeapSnapshotView = function(parent, profile) | |
24 { | |
25 WebInspector.View.call(this); | |
26 | |
27 this.element.addStyleClass("heap-snapshot-view"); | |
28 | |
29 this.parent = parent; | |
30 this.parent.addEventListener("snapshot added", this._updateBaseOptions, this
); | |
31 | |
32 this.showCountAsPercent = true; | |
33 this.showSizeAsPercent = true; | |
34 this.showCountDeltaAsPercent = true; | |
35 this.showSizeDeltaAsPercent = true; | |
36 | |
37 this.summaryBar = new WebInspector.SummaryBar(this.categories); | |
38 this.summaryBar.element.id = "heap-snapshot-summary"; | |
39 this.summaryBar.calculator = new WebInspector.HeapSummaryCalculator(profile.
used); | |
40 this.element.appendChild(this.summaryBar.element); | |
41 | |
42 var columns = { "cons": { title: WebInspector.UIString("Constructor"), discl
osure: true, sortable: true }, | |
43 "count": { title: WebInspector.UIString("Count"), width: "54
px", sortable: true }, | |
44 "size": { title: WebInspector.UIString("Size"), width: "72px
", sort: "descending", sortable: true }, | |
45 "countDelta": { title: WebInspector.UIString("\xb1 Count"),
width: "72px", sortable: true }, | |
46 "sizeDelta": { title: WebInspector.UIString("\xb1 Size"), wi
dth: "72px", sortable: true } }; | |
47 | |
48 this.dataGrid = new WebInspector.DataGrid(columns); | |
49 this.dataGrid.addEventListener("sorting changed", this._sortData, this); | |
50 this.dataGrid.element.addEventListener("mousedown", this._mouseDownInDataGri
d.bind(this), true); | |
51 this.element.appendChild(this.dataGrid.element); | |
52 | |
53 this.profile = profile; | |
54 | |
55 this.baseSelectElement = document.createElement("select"); | |
56 this.baseSelectElement.className = "status-bar-item"; | |
57 this.baseSelectElement.addEventListener("change", this._changeBase.bind(this
), false); | |
58 this._updateBaseOptions(); | |
59 if (this.profile.listIndex > 0) | |
60 this.baseSelectElement.selectedIndex = this.profile.listIndex - 1; | |
61 else | |
62 this.baseSelectElement.selectedIndex = this.profile.listIndex; | |
63 this._resetDataGridList(); | |
64 | |
65 this.percentButton = new WebInspector.StatusBarButton("", "percent-time-stat
us-bar-item status-bar-item"); | |
66 this.percentButton.addEventListener("click", this._percentClicked.bind(this)
, false); | |
67 | |
68 this.refresh(); | |
69 | |
70 this._updatePercentButton(); | |
71 }; | |
72 | |
73 WebInspector.HeapSnapshotView.prototype = { | |
74 | |
75 get categories() | |
76 { | |
77 return {code: {title: WebInspector.UIString("Code"), color: {r: 255, g:
121, b: 0}}, data: {title: WebInspector.UIString("Objects and Data"), color: {r:
47, g: 102, b: 236}}, other: {title: WebInspector.UIString("Other"), color: {r:
186, g: 186, b: 186}}}; | |
78 }, | |
79 | |
80 get statusBarItems() | |
81 { | |
82 return [this.baseSelectElement, this.percentButton.element]; | |
83 }, | |
84 | |
85 get profile() | |
86 { | |
87 return this._profile; | |
88 }, | |
89 | |
90 set profile(profile) | |
91 { | |
92 this._profile = profile; | |
93 }, | |
94 | |
95 show: function(parentElement) | |
96 { | |
97 WebInspector.View.prototype.show.call(this, parentElement); | |
98 this.dataGrid.updateWidths(); | |
99 }, | |
100 | |
101 resize: function() | |
102 { | |
103 if (this.dataGrid) | |
104 this.dataGrid.updateWidths(); | |
105 }, | |
106 | |
107 refresh: function() | |
108 { | |
109 this.dataGrid.removeChildren(); | |
110 | |
111 var children = this.snapshotDataGridList.children; | |
112 var count = children.length; | |
113 for (var index = 0; index < count; ++index) | |
114 this.dataGrid.appendChild(children[index]); | |
115 | |
116 this._updateSummaryGraph(); | |
117 }, | |
118 | |
119 refreshShowAsPercents: function() | |
120 { | |
121 this._updatePercentButton(); | |
122 this.refreshVisibleData(); | |
123 }, | |
124 | |
125 refreshVisibleData: function() | |
126 { | |
127 var child = this.dataGrid.children[0]; | |
128 while (child) { | |
129 child.refresh(); | |
130 child = child.traverseNextNode(false, null, true); | |
131 } | |
132 this._updateSummaryGraph(); | |
133 }, | |
134 | |
135 _changeBase: function() { | |
136 if (this.baseSnapshot === WebInspector.HeapSnapshotProfileType.snapshots
[this.baseSelectElement.selectedIndex]) | |
137 return; | |
138 | |
139 this._resetDataGridList(); | |
140 this.refresh(); | |
141 }, | |
142 | |
143 _createSnapshotDataGridList: function() | |
144 { | |
145 if (this._snapshotDataGridList) | |
146 delete this._snapshotDataGridList; | |
147 | |
148 this._snapshotDataGridList = new WebInspector.HeapSnapshotDataGridList(t
his, this.baseSnapshot.entries, this.profile.entries); | |
149 return this._snapshotDataGridList; | |
150 }, | |
151 | |
152 _mouseDownInDataGrid: function(event) | |
153 { | |
154 if (event.detail < 2) | |
155 return; | |
156 | |
157 var cell = event.target.enclosingNodeOrSelfWithNodeName("td"); | |
158 if (!cell || (!cell.hasStyleClass("count-column") && !cell.hasStyleClass
("size-column") && !cell.hasStyleClass("countDelta-column") && !cell.hasStyleCla
ss("sizeDelta-column"))) | |
159 return; | |
160 | |
161 if (cell.hasStyleClass("count-column")) | |
162 this.showCountAsPercent = !this.showCountAsPercent; | |
163 else if (cell.hasStyleClass("size-column")) | |
164 this.showSizeAsPercent = !this.showSizeAsPercent; | |
165 else if (cell.hasStyleClass("countDelta-column")) | |
166 this.showCountDeltaAsPercent = !this.showCountDeltaAsPercent; | |
167 else if (cell.hasStyleClass("sizeDelta-column")) | |
168 this.showSizeDeltaAsPercent = !this.showSizeDeltaAsPercent; | |
169 | |
170 this.refreshShowAsPercents(); | |
171 | |
172 event.preventDefault(); | |
173 event.stopPropagation(); | |
174 }, | |
175 | |
176 get _isShowingAsPercent() | |
177 { | |
178 return this.showCountAsPercent && this.showSizeAsPercent && this.showCou
ntDeltaAsPercent && this.showSizeDeltaAsPercent; | |
179 }, | |
180 | |
181 _percentClicked: function(event) | |
182 { | |
183 var currentState = this._isShowingAsPercent; | |
184 this.showCountAsPercent = !currentState; | |
185 this.showSizeAsPercent = !currentState; | |
186 this.showCountDeltaAsPercent = !currentState; | |
187 this.showSizeDeltaAsPercent = !currentState; | |
188 this.refreshShowAsPercents(); | |
189 }, | |
190 | |
191 _resetDataGridList: function() | |
192 { | |
193 this.baseSnapshot = WebInspector.HeapSnapshotProfileType.snapshots[this.
baseSelectElement.selectedIndex]; | |
194 var lastComparator = WebInspector.HeapSnapshotDataGridList.propertyCompa
rator("size", false); | |
195 if (this.snapshotDataGridList) { | |
196 lastComparator = this.snapshotDataGridList.lastComparator; | |
197 } | |
198 this.snapshotDataGridList = this._createSnapshotDataGridList(); | |
199 this.snapshotDataGridList.sort(lastComparator, true); | |
200 }, | |
201 | |
202 _sortData: function() | |
203 { | |
204 var sortAscending = this.dataGrid.sortOrder === "ascending"; | |
205 var sortColumnIdentifier = this.dataGrid.sortColumnIdentifier; | |
206 var sortProperty = { | |
207 "cons": "constructorName", | |
208 "count": "count", | |
209 "size": "size", | |
210 "countDelta": this.showCountDeltaAsPercent ? "countDeltaPercent"
: "countDelta", | |
211 "sizeDelta": this.showSizeDeltaAsPercent ? "sizeDeltaPercent" :
"sizeDelta" | |
212 }[sortColumnIdentifier]; | |
213 | |
214 this.snapshotDataGridList.sort(WebInspector.HeapSnapshotDataGridList.pro
pertyComparator(sortProperty, sortAscending)); | |
215 | |
216 this.refresh(); | |
217 }, | |
218 | |
219 _updateBaseOptions: function() | |
220 { | |
221 var list = WebInspector.HeapSnapshotProfileType.snapshots; | |
222 // We're assuming that snapshots can only be added. | |
223 if (this.baseSelectElement.length == list.length) | |
224 return; | |
225 | |
226 for (var i = this.baseSelectElement.length, n = list.length; i < n; ++i)
{ | |
227 var baseOption = document.createElement("option"); | |
228 baseOption.label = WebInspector.UIString("Compared to %s", list[i].t
itle); | |
229 this.baseSelectElement.appendChild(baseOption); | |
230 } | |
231 }, | |
232 | |
233 _updatePercentButton: function() | |
234 { | |
235 if (this._isShowingAsPercent) { | |
236 this.percentButton.title = WebInspector.UIString("Show absolute coun
ts and sizes."); | |
237 this.percentButton.toggled = true; | |
238 } else { | |
239 this.percentButton.title = WebInspector.UIString("Show counts and si
zes as percentages."); | |
240 this.percentButton.toggled = false; | |
241 } | |
242 }, | |
243 | |
244 _updateSummaryGraph: function() | |
245 { | |
246 this.summaryBar.calculator.showAsPercent = this._isShowingAsPercent; | |
247 this.summaryBar.update(this.profile.lowlevels); | |
248 } | |
249 }; | |
250 | |
251 WebInspector.HeapSnapshotView.prototype.__proto__ = WebInspector.View.prototype; | |
252 | |
253 WebInspector.HeapSummaryCalculator = function(total) | |
254 { | |
255 this.total = total; | |
256 } | |
257 | |
258 WebInspector.HeapSummaryCalculator.prototype = { | |
259 computeSummaryValues: function(lowLevels) | |
260 { | |
261 function highFromLow(type) { | |
262 if (type == "CODE_TYPE" || type == "SHARED_FUNCTION_INFO_TYPE" || ty
pe == "SCRIPT_TYPE") return "code"; | |
263 if (type == "STRING_TYPE" || type == "HEAP_NUMBER_TYPE" || type.matc
h(/^JS_/) || type.match(/_ARRAY_TYPE$/)) return "data"; | |
264 return "other"; | |
265 } | |
266 var highLevels = {data: 0, code: 0, other: 0}; | |
267 for (var item in lowLevels) { | |
268 var highItem = highFromLow(item); | |
269 highLevels[highItem] += lowLevels[item].size; | |
270 } | |
271 return {categoryValues: highLevels}; | |
272 }, | |
273 | |
274 formatValue: function(value) | |
275 { | |
276 if (this.showAsPercent) | |
277 return WebInspector.UIString("%.2f%%", value / this.total * 100.0); | |
278 else | |
279 return Number.bytesToString(value); | |
280 }, | |
281 | |
282 get showAsPercent() | |
283 { | |
284 return this._showAsPercent; | |
285 }, | |
286 | |
287 set showAsPercent(x) | |
288 { | |
289 this._showAsPercent = x; | |
290 } | |
291 } | |
292 | |
293 WebInspector.HeapSnapshotSidebarTreeElement = function(snapshot) | |
294 { | |
295 this.profile = snapshot; | |
296 | |
297 WebInspector.SidebarTreeElement.call(this, "heap-snapshot-sidebar-tree-item"
, "", "", snapshot, false); | |
298 | |
299 this.refreshTitles(); | |
300 }; | |
301 | |
302 WebInspector.HeapSnapshotSidebarTreeElement.prototype = { | |
303 get mainTitle() | |
304 { | |
305 if (this._mainTitle) | |
306 return this._mainTitle; | |
307 return this.profile.title; | |
308 }, | |
309 | |
310 set mainTitle(x) | |
311 { | |
312 this._mainTitle = x; | |
313 this.refreshTitles(); | |
314 }, | |
315 | |
316 get subtitle() | |
317 { | |
318 if (this._subTitle) | |
319 return this._subTitle; | |
320 return WebInspector.UIString("Used %s of %s (%.0f%%)", Number.bytesToStr
ing(this.profile.used, null, false), Number.bytesToString(this.profile.capacity,
null, false), this.profile.used / this.profile.capacity * 100.0); | |
321 }, | |
322 | |
323 set subtitle(x) | |
324 { | |
325 this._subTitle = x; | |
326 this.refreshTitles(); | |
327 } | |
328 }; | |
329 | |
330 WebInspector.HeapSnapshotSidebarTreeElement.prototype.__proto__ = WebInspector.P
rofileSidebarTreeElement.prototype; | |
331 | |
332 WebInspector.HeapSnapshotDataGridNodeWithRetainers = function(owningTree) | |
333 { | |
334 this.tree = owningTree; | |
335 | |
336 WebInspector.DataGridNode.call(this, null, this._hasRetainers); | |
337 | |
338 this.addEventListener("populate", this._populate, this); | |
339 }; | |
340 | |
341 WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype = { | |
342 isEmptySet: function(set) | |
343 { | |
344 for (var x in set) | |
345 return false; | |
346 return true; | |
347 }, | |
348 | |
349 get _hasRetainers() | |
350 { | |
351 return !this.isEmptySet(this.retainers); | |
352 }, | |
353 | |
354 get _parent() | |
355 { | |
356 // For top-level nodes, return owning tree as a parent, not data grid. | |
357 return this.parent !== this.dataGrid ? this.parent : this.tree; | |
358 }, | |
359 | |
360 _populate: function(event) | |
361 { | |
362 var self = this; | |
363 this.produceDiff(this.baseRetainers, this.retainers, function(baseItem,
snapshotItem) { | |
364 self.appendChild(new WebInspector.HeapSnapshotDataGridRetainerNode(s
elf.snapshotView, baseItem, snapshotItem, self.tree)); | |
365 }); | |
366 | |
367 if (this._parent) { | |
368 var currentComparator = this._parent.lastComparator; | |
369 if (currentComparator) | |
370 this.sort(currentComparator, true); | |
371 } | |
372 | |
373 this.removeEventListener("populate", this._populate, this); | |
374 }, | |
375 | |
376 produceDiff: function(baseEntries, currentEntries, callback) | |
377 { | |
378 for (var item in currentEntries) | |
379 callback(baseEntries[item], currentEntries[item]); | |
380 | |
381 for (item in baseEntries) { | |
382 if (!(item in currentEntries)) | |
383 callback(baseEntries[item], null); | |
384 } | |
385 }, | |
386 | |
387 sort: function(comparator, force) { | |
388 if (!force && this.lastComparator === comparator) | |
389 return; | |
390 | |
391 this.children.sort(comparator); | |
392 var childCount = this.children.length; | |
393 for (var childIndex = 0; childIndex < childCount; ++childIndex) | |
394 this.children[childIndex]._recalculateSiblings(childIndex); | |
395 for (var i = 0; i < this.children.length; ++i) { | |
396 var child = this.children[i]; | |
397 if (!force && (!child.expanded || child.lastComparator === comparato
r)) | |
398 continue; | |
399 child.sort(comparator, force); | |
400 } | |
401 this.lastComparator = comparator; | |
402 }, | |
403 | |
404 signForDelta: function(delta) { | |
405 if (delta == 0) | |
406 return ""; | |
407 if (delta > 0) | |
408 return "+"; | |
409 else | |
410 // Math minus sign, same width as plus. | |
411 return "\u2212"; | |
412 }, | |
413 | |
414 showDeltaAsPercent: function(value) { | |
415 if (value === Number.POSITIVE_INFINITY) | |
416 return WebInspector.UIString("new"); | |
417 else if (value === Number.NEGATIVE_INFINITY) | |
418 return WebInspector.UIString("deleted"); | |
419 if (value > 1000.0) | |
420 return WebInspector.UIString("%s >1000%%", this.signForDelta(value))
; | |
421 return WebInspector.UIString("%s%.2f%%", this.signForDelta(value), Math.
abs(value)); | |
422 }, | |
423 | |
424 getTotalCount: function() { | |
425 if (!this._count) { | |
426 this._count = 0; | |
427 for (var i = 0, n = this.children.length; i < n; ++i) { | |
428 this._count += this.children[i].count; | |
429 } | |
430 } | |
431 return this._count; | |
432 }, | |
433 | |
434 getTotalSize: function() { | |
435 if (!this._size) { | |
436 this._size = 0; | |
437 for (var i = 0, n = this.children.length; i < n; ++i) { | |
438 this._size += this.children[i].size; | |
439 } | |
440 } | |
441 return this._size; | |
442 }, | |
443 | |
444 get countPercent() | |
445 { | |
446 return this.count / this._parent.getTotalCount() * 100.0; | |
447 }, | |
448 | |
449 get sizePercent() | |
450 { | |
451 return this.size / this._parent.getTotalSize() * 100.0; | |
452 }, | |
453 | |
454 get countDeltaPercent() | |
455 { | |
456 if (this.baseCount > 0) { | |
457 if (this.count > 0) | |
458 return this.countDelta / this.baseCount * 100.0; | |
459 else | |
460 return Number.NEGATIVE_INFINITY; | |
461 } else | |
462 return Number.POSITIVE_INFINITY; | |
463 }, | |
464 | |
465 get sizeDeltaPercent() | |
466 { | |
467 if (this.baseSize > 0) { | |
468 if (this.size > 0) | |
469 return this.sizeDelta / this.baseSize * 100.0; | |
470 else | |
471 return Number.NEGATIVE_INFINITY; | |
472 } else | |
473 return Number.POSITIVE_INFINITY; | |
474 }, | |
475 | |
476 getData: function(showSize) | |
477 { | |
478 var data = {}; | |
479 | |
480 data["cons"] = this.constructorName; | |
481 | |
482 if (this.snapshotView.showCountAsPercent) | |
483 data["count"] = WebInspector.UIString("%.2f%%", this.countPercent); | |
484 else | |
485 data["count"] = this.count; | |
486 | |
487 if (showSize) { | |
488 if (this.snapshotView.showSizeAsPercent) | |
489 data["size"] = WebInspector.UIString("%.2f%%", this.sizePercent)
; | |
490 else | |
491 data["size"] = Number.bytesToString(this.size); | |
492 } else { | |
493 data["size"] = ""; | |
494 } | |
495 | |
496 if (this.snapshotView.showCountDeltaAsPercent) | |
497 data["countDelta"] = this.showDeltaAsPercent(this.countDeltaPercent)
; | |
498 else | |
499 data["countDelta"] = WebInspector.UIString("%s%d", this.signForDelta
(this.countDelta), Math.abs(this.countDelta)); | |
500 | |
501 if (showSize) { | |
502 if (this.snapshotView.showSizeDeltaAsPercent) | |
503 data["sizeDelta"] = this.showDeltaAsPercent(this.sizeDeltaPercen
t); | |
504 else | |
505 data["sizeDelta"] = WebInspector.UIString("%s%s", this.signForDe
lta(this.sizeDelta), Number.bytesToString(Math.abs(this.sizeDelta))); | |
506 } else { | |
507 data["sizeDelta"] = ""; | |
508 } | |
509 | |
510 return data; | |
511 } | |
512 }; | |
513 | |
514 WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.__proto__ = WebInsp
ector.DataGridNode.prototype; | |
515 | |
516 WebInspector.HeapSnapshotDataGridNode = function(snapshotView, baseEntry, snapsh
otEntry, owningTree) | |
517 { | |
518 this.snapshotView = snapshotView; | |
519 | |
520 if (!snapshotEntry) | |
521 snapshotEntry = { cons: baseEntry.cons, count: 0, size: 0, retainers: {}
}; | |
522 this.constructorName = snapshotEntry.cons; | |
523 this.count = snapshotEntry.count; | |
524 this.size = snapshotEntry.size; | |
525 this.retainers = snapshotEntry.retainers; | |
526 | |
527 if (!baseEntry) | |
528 baseEntry = { count: 0, size: 0, retainers: {} }; | |
529 this.baseCount = baseEntry.count; | |
530 this.countDelta = this.count - this.baseCount; | |
531 this.baseSize = baseEntry.size; | |
532 this.sizeDelta = this.size - this.baseSize; | |
533 this.baseRetainers = baseEntry.retainers; | |
534 | |
535 WebInspector.HeapSnapshotDataGridNodeWithRetainers.call(this, owningTree); | |
536 }; | |
537 | |
538 WebInspector.HeapSnapshotDataGridNode.prototype = { | |
539 get data() | |
540 { | |
541 return this.getData(true); | |
542 } | |
543 }; | |
544 | |
545 WebInspector.HeapSnapshotDataGridNode.prototype.__proto__ = WebInspector.HeapSna
pshotDataGridNodeWithRetainers.prototype; | |
546 | |
547 WebInspector.HeapSnapshotDataGridList = function(snapshotView, baseEntries, snap
shotEntries) | |
548 { | |
549 this.tree = this; | |
550 this.snapshotView = snapshotView; | |
551 this.children = []; | |
552 this.lastComparator = null; | |
553 this.populateChildren(baseEntries, snapshotEntries); | |
554 }; | |
555 | |
556 WebInspector.HeapSnapshotDataGridList.prototype = { | |
557 appendChild: function(child) | |
558 { | |
559 this.insertChild(child, this.children.length); | |
560 }, | |
561 | |
562 insertChild: function(child, index) | |
563 { | |
564 this.children.splice(index, 0, child); | |
565 }, | |
566 | |
567 removeChildren: function() | |
568 { | |
569 this.children = []; | |
570 }, | |
571 | |
572 populateChildren: function(baseEntries, snapshotEntries) | |
573 { | |
574 var self = this; | |
575 this.produceDiff(baseEntries, snapshotEntries, function(baseItem, snapsh
otItem) { | |
576 self.appendChild(new WebInspector.HeapSnapshotDataGridNode(self.snap
shotView, baseItem, snapshotItem, self)); | |
577 }); | |
578 }, | |
579 | |
580 produceDiff: WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.pr
oduceDiff, | |
581 sort: WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.sort, | |
582 getTotalCount: WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.
getTotalCount, | |
583 getTotalSize: WebInspector.HeapSnapshotDataGridNodeWithRetainers.prototype.g
etTotalSize | |
584 }; | |
585 | |
586 WebInspector.HeapSnapshotDataGridList.propertyComparators = [{}, {}]; | |
587 | |
588 WebInspector.HeapSnapshotDataGridList.propertyComparator = function(property, is
Ascending) | |
589 { | |
590 var comparator = this.propertyComparators[(isAscending ? 1 : 0)][property]; | |
591 if (!comparator) { | |
592 comparator = function(lhs, rhs) { | |
593 var l = lhs[property], r = rhs[property]; | |
594 var result = l < r ? -1 : (l > r ? 1 : 0); | |
595 return isAscending ? result : -result; | |
596 }; | |
597 this.propertyComparators[(isAscending ? 1 : 0)][property] = comparator; | |
598 } | |
599 return comparator; | |
600 }; | |
601 | |
602 WebInspector.HeapSnapshotDataGridRetainerNode = function(snapshotView, baseEntry
, snapshotEntry, owningTree) | |
603 { | |
604 this.snapshotView = snapshotView; | |
605 | |
606 if (!snapshotEntry) | |
607 snapshotEntry = { cons: baseEntry.cons, count: 0, clusters: {} }; | |
608 this.constructorName = snapshotEntry.cons; | |
609 this.count = snapshotEntry.count; | |
610 this.retainers = this._calculateRetainers(this.snapshotView.profile, snapsho
tEntry.clusters); | |
611 | |
612 if (!baseEntry) | |
613 baseEntry = { count: 0, clusters: {} }; | |
614 this.baseCount = baseEntry.count; | |
615 this.countDelta = this.count - this.baseCount; | |
616 this.baseRetainers = this._calculateRetainers(this.snapshotView.baseSnapshot
, baseEntry.clusters); | |
617 | |
618 this.size = this.count; // This way, when sorting by sizes entries will be
sorted by references count. | |
619 | |
620 WebInspector.HeapSnapshotDataGridNodeWithRetainers.call(this, owningTree); | |
621 } | |
622 | |
623 WebInspector.HeapSnapshotDataGridRetainerNode.prototype = { | |
624 get data() | |
625 { | |
626 return this.getData(false); | |
627 }, | |
628 | |
629 _calculateRetainers: function(snapshot, clusters) { | |
630 var retainers = {}; | |
631 if (this.isEmptySet(clusters)) { | |
632 if (this.constructorName in snapshot.entries) | |
633 return snapshot.entries[this.constructorName].retainers; | |
634 } else { | |
635 // In case when an entry is retained by clusters, we need to gather
up the list | |
636 // of retainers by merging retainers of every cluster. | |
637 // E.g. having such a tree: | |
638 // A | |
639 // Object:1 10 | |
640 // X 3 | |
641 // Y 4 | |
642 // Object:2 5 | |
643 // X 6 | |
644 // | |
645 // will result in a following retainers list: X 9, Y 4. | |
646 for (var clusterName in clusters) { | |
647 if (clusterName in snapshot.clusters) { | |
648 var clusterRetainers = snapshot.clusters[clusterName].retain
ers; | |
649 for (var clusterRetainer in clusterRetainers) { | |
650 var clusterRetainerEntry = clusterRetainers[clusterRetai
ner]; | |
651 if (!(clusterRetainer in retainers)) | |
652 retainers[clusterRetainer] = { cons: clusterRetainer
Entry.cons, count: 0, clusters: {} }; | |
653 retainers[clusterRetainer].count += clusterRetainerEntry
.count; | |
654 for (var clusterRetainerCluster in clusterRetainerEntry.
clusters) | |
655 retainers[clusterRetainer].clusters[clusterRetainerC
luster] = true; | |
656 } | |
657 } | |
658 } | |
659 } | |
660 return retainers; | |
661 } | |
662 }; | |
663 | |
664 WebInspector.HeapSnapshotDataGridRetainerNode.prototype.__proto__ = WebInspector
.HeapSnapshotDataGridNodeWithRetainers.prototype; | |
665 | |
666 | |
667 WebInspector.HeapSnapshotProfileType = function() | |
668 { | |
669 WebInspector.ProfileType.call(this, WebInspector.HeapSnapshotProfileType.Typ
eId, WebInspector.UIString("HEAP SNAPSHOTS")); | |
670 } | |
671 | |
672 WebInspector.HeapSnapshotProfileType.TypeId = "HEAP"; | |
673 | |
674 WebInspector.HeapSnapshotProfileType.snapshots = []; | |
675 | |
676 WebInspector.HeapSnapshotProfileType.prototype = { | |
677 get buttonTooltip() | |
678 { | |
679 return WebInspector.UIString("Take heap snapshot."); | |
680 }, | |
681 | |
682 get buttonStyle() | |
683 { | |
684 return "heap-snapshot-status-bar-item status-bar-item"; | |
685 }, | |
686 | |
687 buttonClicked: function() | |
688 { | |
689 InspectorController.takeHeapSnapshot(); | |
690 }, | |
691 | |
692 createSidebarTreeElementForProfile: function(profile) | |
693 { | |
694 var element = new WebInspector.HeapSnapshotSidebarTreeElement(profile); | |
695 element.small = false; | |
696 return element; | |
697 }, | |
698 | |
699 createView: function(profile) | |
700 { | |
701 return new WebInspector.HeapSnapshotView(WebInspector.panels.profiles, p
rofile); | |
702 } | |
703 } | |
704 | |
705 WebInspector.HeapSnapshotProfileType.prototype.__proto__ = WebInspector.ProfileT
ype.prototype; | |
706 | |
707 | |
708 (function() { | |
709 var originalCreatePanels = WebInspector._createPanels; | |
710 WebInspector._createPanels = function() { | |
711 originalCreatePanels.apply(this, arguments); | |
712 if (WebInspector.panels.profiles) | |
713 WebInspector.panels.profiles.registerProfileType(new WebInspector.He
apSnapshotProfileType()); | |
714 } | |
715 })(); | |
OLD | NEW |