OLD | NEW |
1 /* | 1 // Copyright 2017 The Chromium Authors. All rights reserved. |
2 * Copyright (C) 2007, 2008, 2010 Apple Inc. All rights reserved. | 2 // Use of this source code is governed by a BSD-style license that can be |
3 * Copyright (C) 2009 Joseph Pecoraro | 3 // found in the LICENSE file. |
4 * Copyright (C) 2013 Samsung Electronics. All rights reserved. | |
5 * | |
6 * Redistribution and use in source and binary forms, with or without | |
7 * modification, are permitted provided that the following conditions | |
8 * are met: | |
9 * | |
10 * 1. Redistributions of source code must retain the above copyright | |
11 * notice, this list of conditions and the following disclaimer. | |
12 * 2. Redistributions in binary form must reproduce the above copyright | |
13 * notice, this list of conditions and the following disclaimer in the | |
14 * documentation and/or other materials provided with the distribution. | |
15 * 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of | |
16 * its contributors may be used to endorse or promote products derived | |
17 * from this software without specific prior written permission. | |
18 * | |
19 * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY | |
20 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | |
21 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |
22 * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY | |
23 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | |
24 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | |
25 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | |
26 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF | |
28 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
29 */ | |
30 /** | |
31 * @implements {SDK.TargetManager.Observer} | |
32 * @unrestricted | |
33 */ | |
34 Resources.ResourcesPanel = class extends UI.PanelWithSidebar { | |
35 constructor() { | |
36 super('resources'); | |
37 this.registerRequiredCSS('resources/resourcesPanel.css'); | |
38 | 4 |
39 this._resourcesLastSelectedItemSetting = Common.settings.createSetting('reso
urcesLastSelectedItem', {}); | 5 Resources.ResourcesSection = class { |
| 6 /** |
| 7 * @param {!Resources.ResourcesPanel} storagePanel |
| 8 * @param {!UI.TreeElement} treeElement |
| 9 */ |
| 10 constructor(storagePanel, treeElement) { |
| 11 this._panel = storagePanel; |
| 12 this._treeElement = treeElement; |
| 13 /** @type {!Map<string, !Resources.FrameTreeElement>} */ |
| 14 this._treeElementForFrameId = new Map(); |
40 | 15 |
41 this._sidebarTree = new UI.TreeOutlineInShadow(); | 16 function addListener(eventType, handler, target) { |
42 this._sidebarTree.element.classList.add('resources-sidebar'); | 17 SDK.targetManager.addModelListener(SDK.ResourceTreeModel, eventType, event
=> handler.call(target, event.data)); |
43 this._sidebarTree.registerRequiredCSS('resources/resourcesSidebar.css'); | 18 } |
44 this._sidebarTree.element.classList.add('filter-all'); | 19 addListener(SDK.ResourceTreeModel.Events.FrameAdded, this._frameAdded, this)
; |
45 this.panelSidebarElement().appendChild(this._sidebarTree.element); | 20 addListener(SDK.ResourceTreeModel.Events.FrameNavigated, this._frameNavigate
d, this); |
| 21 addListener(SDK.ResourceTreeModel.Events.FrameDetached, this._frameDetached,
this); |
| 22 addListener(SDK.ResourceTreeModel.Events.ResourceAdded, this._resourceAdded,
this); |
46 | 23 |
47 this._applicationTreeElement = this._addSidebarSection(Common.UIString('Appl
ication')); | 24 var mainTarget = SDK.targetManager.mainTarget(); |
48 this._manifestTreeElement = new Resources.AppManifestTreeElement(this); | 25 var resourceTreeModel = mainTarget && mainTarget.hasDOMCapability() && SDK.R
esourceTreeModel.fromTarget(mainTarget); |
49 this._applicationTreeElement.appendChild(this._manifestTreeElement); | 26 var mainFrame = resourceTreeModel && resourceTreeModel.mainFrame; |
50 this.serviceWorkersTreeElement = new Resources.ServiceWorkersTreeElement(thi
s); | 27 if (mainFrame) |
51 this._applicationTreeElement.appendChild(this.serviceWorkersTreeElement); | 28 this._populateFrame(mainFrame); |
52 var clearStorageTreeElement = new Resources.ClearStorageTreeElement(this); | |
53 this._applicationTreeElement.appendChild(clearStorageTreeElement); | |
54 | |
55 var storageTreeElement = this._addSidebarSection(Common.UIString('Storage'))
; | |
56 this.localStorageListTreeElement = | |
57 new Resources.StorageCategoryTreeElement(this, Common.UIString('Local St
orage'), 'LocalStorage'); | |
58 var localStorageIcon = UI.Icon.create('mediumicon-table', 'resource-tree-ite
m'); | |
59 this.localStorageListTreeElement.setLeadingIcons([localStorageIcon]); | |
60 | |
61 storageTreeElement.appendChild(this.localStorageListTreeElement); | |
62 this.sessionStorageListTreeElement = | |
63 new Resources.StorageCategoryTreeElement(this, Common.UIString('Session
Storage'), 'SessionStorage'); | |
64 var sessionStorageIcon = UI.Icon.create('mediumicon-table', 'resource-tree-i
tem'); | |
65 this.sessionStorageListTreeElement.setLeadingIcons([sessionStorageIcon]); | |
66 | |
67 storageTreeElement.appendChild(this.sessionStorageListTreeElement); | |
68 this.indexedDBListTreeElement = new Resources.IndexedDBTreeElement(this); | |
69 storageTreeElement.appendChild(this.indexedDBListTreeElement); | |
70 this.databasesListTreeElement = | |
71 new Resources.StorageCategoryTreeElement(this, Common.UIString('Web SQL'
), 'Databases'); | |
72 var databaseIcon = UI.Icon.create('mediumicon-database', 'resource-tree-item
'); | |
73 this.databasesListTreeElement.setLeadingIcons([databaseIcon]); | |
74 | |
75 storageTreeElement.appendChild(this.databasesListTreeElement); | |
76 this.cookieListTreeElement = new Resources.StorageCategoryTreeElement(this,
Common.UIString('Cookies'), 'Cookies'); | |
77 var cookieIcon = UI.Icon.create('mediumicon-cookie', 'resource-tree-item'); | |
78 this.cookieListTreeElement.setLeadingIcons([cookieIcon]); | |
79 storageTreeElement.appendChild(this.cookieListTreeElement); | |
80 | |
81 var cacheTreeElement = this._addSidebarSection(Common.UIString('Cache')); | |
82 this.cacheStorageListTreeElement = new Resources.ServiceWorkerCacheTreeEleme
nt(this); | |
83 cacheTreeElement.appendChild(this.cacheStorageListTreeElement); | |
84 this.applicationCacheListTreeElement = | |
85 new Resources.StorageCategoryTreeElement(this, Common.UIString('Applicat
ion Cache'), 'ApplicationCache'); | |
86 var applicationCacheIcon = UI.Icon.create('mediumicon-table', 'resource-tree
-item'); | |
87 this.applicationCacheListTreeElement.setLeadingIcons([applicationCacheIcon])
; | |
88 | |
89 cacheTreeElement.appendChild(this.applicationCacheListTreeElement); | |
90 | |
91 this.resourcesListTreeElement = this._addSidebarSection(Common.UIString('Fra
mes')); | |
92 | |
93 var mainContainer = new UI.VBox(); | |
94 this.storageViews = mainContainer.element.createChild('div', 'vbox flex-auto
'); | |
95 this._storageViewToolbar = new UI.Toolbar('resources-toolbar', mainContainer
.element); | |
96 this.splitWidget().setMainWidget(mainContainer); | |
97 | |
98 /** @type {!Map.<!Resources.Database, !Object.<string, !Resources.DatabaseTa
bleView>>} */ | |
99 this._databaseTableViews = new Map(); | |
100 /** @type {!Map.<!Resources.Database, !Resources.DatabaseQueryView>} */ | |
101 this._databaseQueryViews = new Map(); | |
102 /** @type {!Map.<!Resources.Database, !Resources.DatabaseTreeElement>} */ | |
103 this._databaseTreeElements = new Map(); | |
104 /** @type {!Map.<!Resources.DOMStorage, !Resources.DOMStorageTreeElement>} *
/ | |
105 this._domStorageTreeElements = new Map(); | |
106 /** @type {!Object.<string, boolean>} */ | |
107 this._domains = {}; | |
108 | |
109 /** @type {?Resources.DOMStorageItemsView} */ | |
110 this._domStorageView = null; | |
111 /** @type {?Resources.CookieItemsView} */ | |
112 this._cookieView = null; | |
113 | |
114 this.panelSidebarElement().addEventListener('mousemove', this._onmousemove.b
ind(this), false); | |
115 this.panelSidebarElement().addEventListener('mouseleave', this._onmouseleave
.bind(this), false); | |
116 | |
117 SDK.targetManager.observeTargets(this); | |
118 } | 29 } |
119 | 30 |
120 /** | 31 /** |
121 * @return {!Resources.ResourcesPanel} | 32 * @param {!SDK.ResourceTreeFrame} frame |
| 33 * @returns {?SDK.ResourceTreeFrame} |
122 */ | 34 */ |
123 static _instance() { | 35 static _getParentFrame(frame) { |
124 return /** @type {!Resources.ResourcesPanel} */ (self.runtime.sharedInstance
(Resources.ResourcesPanel)); | 36 var parentFrame = frame.parentFrame; |
| 37 if (parentFrame) |
| 38 return parentFrame; |
| 39 var parentTarget = frame.target().parentTarget(); |
| 40 if (!parentTarget) |
| 41 return null; |
| 42 console.assert(parentTarget.hasDOMCapability()); |
| 43 return SDK.ResourceTreeModel.fromTarget(parentTarget).mainFrame; |
125 } | 44 } |
126 | 45 |
127 /** | 46 /** |
128 * @param {string} title | 47 * @param {!SDK.ResourceTreeFrame} frame |
129 * @return {!UI.TreeElement} | |
130 */ | 48 */ |
131 _addSidebarSection(title) { | 49 _frameAdded(frame) { |
132 var treeElement = new UI.TreeElement(title, true); | 50 var parentFrame = Resources.ResourcesSection._getParentFrame(frame); |
133 treeElement.listItemElement.classList.add('storage-group-list-item'); | 51 var parentTreeElement = parentFrame ? this._treeElementForFrameId.get(parent
Frame.id) : this._treeElement; |
134 treeElement.setCollapsible(false); | 52 if (!parentTreeElement) { |
135 treeElement.selectable = false; | 53 console.warn(`No frame to route ${frame.url} to.`); |
136 this._sidebarTree.appendChild(treeElement); | 54 return; |
137 return treeElement; | 55 } |
| 56 |
| 57 var frameTreeElement = new Resources.FrameTreeElement(this._panel, frame); |
| 58 this._treeElementForFrameId.set(frame.id, frameTreeElement); |
| 59 parentTreeElement.appendChild(frameTreeElement); |
138 } | 60 } |
139 | 61 |
140 /** | 62 /** |
141 * @override | 63 * @param {!SDK.ResourceTreeFrame} frame |
142 * @param {!SDK.Target} target | |
143 */ | 64 */ |
144 targetAdded(target) { | 65 _frameDetached(frame) { |
145 if (this._target) | 66 var frameTreeElement = this._treeElementForFrameId.get(frame.id); |
146 return; | |
147 this._target = target; | |
148 this._databaseModel = Resources.DatabaseModel.fromTarget(target); | |
149 | |
150 this._databaseModel.on(Resources.DatabaseModel.DatabaseAddedEvent, this._dat
abaseAdded, this); | |
151 this._databaseModel.on(Resources.DatabaseModel.DatabasesRemovedEvent, this._
resetWebSQL, this); | |
152 | |
153 var resourceTreeModel = SDK.ResourceTreeModel.fromTarget(target); | |
154 if (!resourceTreeModel) | |
155 return; | |
156 | |
157 if (resourceTreeModel.cachedResourcesLoaded()) | |
158 this._initialize(); | |
159 | |
160 resourceTreeModel.addEventListener(SDK.ResourceTreeModel.Events.CachedResour
cesLoaded, this._initialize, this); | |
161 resourceTreeModel.addEventListener( | |
162 SDK.ResourceTreeModel.Events.WillLoadCachedResources, this._resetWithFra
mes, this); | |
163 } | |
164 | |
165 /** | |
166 * @override | |
167 * @param {!SDK.Target} target | |
168 */ | |
169 targetRemoved(target) { | |
170 if (target !== this._target) | |
171 return; | |
172 delete this._target; | |
173 | |
174 var resourceTreeModel = SDK.ResourceTreeModel.fromTarget(target); | |
175 if (resourceTreeModel) { | |
176 resourceTreeModel.removeEventListener(SDK.ResourceTreeModel.Events.CachedR
esourcesLoaded, this._initialize, this); | |
177 resourceTreeModel.removeEventListener( | |
178 SDK.ResourceTreeModel.Events.WillLoadCachedResources, this._resetWithF
rames, this); | |
179 } | |
180 this._databaseModel.off(Resources.DatabaseModel.DatabaseAddedEvent, this._da
tabaseAdded, this); | |
181 this._databaseModel.off(Resources.DatabaseModel.DatabasesRemovedEvent, this.
_resetWebSQL, this); | |
182 | |
183 this._resetWithFrames(); | |
184 } | |
185 | |
186 /** | |
187 * @override | |
188 */ | |
189 focus() { | |
190 this._sidebarTree.focus(); | |
191 } | |
192 | |
193 _initialize() { | |
194 this._databaseModel.enable(); | |
195 | |
196 var indexedDBModel = Resources.IndexedDBModel.fromTarget(this._target); | |
197 if (indexedDBModel) | |
198 indexedDBModel.enable(); | |
199 | |
200 var cacheStorageModel = SDK.ServiceWorkerCacheModel.fromTarget(this._target)
; | |
201 if (cacheStorageModel) | |
202 cacheStorageModel.enable(); | |
203 var resourceTreeModel = SDK.ResourceTreeModel.fromTarget(this._target); | |
204 if (resourceTreeModel) { | |
205 this._populateResourceTree(resourceTreeModel); | |
206 this._populateApplicationCacheTree(resourceTreeModel); | |
207 } | |
208 var domStorageModel = Resources.DOMStorageModel.fromTarget(this._target); | |
209 if (domStorageModel) | |
210 this._populateDOMStorageTree(domStorageModel); | |
211 this.indexedDBListTreeElement._initialize(); | |
212 this.cacheStorageListTreeElement._initialize(); | |
213 this._initDefaultSelection(); | |
214 } | |
215 | |
216 _initDefaultSelection() { | |
217 var itemURL = this._resourcesLastSelectedItemSetting.get(); | |
218 if (itemURL) { | |
219 var rootElement = this._sidebarTree.rootElement(); | |
220 for (var treeElement = rootElement.firstChild(); treeElement; | |
221 treeElement = treeElement.traverseNextTreeElement(false, rootElement,
true)) { | |
222 if (treeElement.itemURL === itemURL) { | |
223 treeElement.revealAndSelect(true); | |
224 return; | |
225 } | |
226 } | |
227 } | |
228 this._manifestTreeElement.select(); | |
229 } | |
230 | |
231 _resetWithFrames() { | |
232 this.resourcesListTreeElement.removeChildren(); | |
233 this._treeElementForFrameId = {}; | |
234 this._reset(); | |
235 } | |
236 | |
237 _resetWebSQL() { | |
238 if (this.visibleView instanceof Resources.DatabaseQueryView || | |
239 this.visibleView instanceof Resources.DatabaseTableView) { | |
240 this.visibleView.detach(); | |
241 delete this.visibleView; | |
242 } | |
243 | |
244 var queryViews = this._databaseQueryViews.valuesArray(); | |
245 for (var i = 0; i < queryViews.length; ++i) { | |
246 queryViews[i].removeEventListener( | |
247 Resources.DatabaseQueryView.Events.SchemaUpdated, this._updateDatabase
Tables, this); | |
248 } | |
249 this._databaseTableViews.clear(); | |
250 this._databaseQueryViews.clear(); | |
251 this._databaseTreeElements.clear(); | |
252 this.databasesListTreeElement.removeChildren(); | |
253 this.databasesListTreeElement.setExpandable(false); | |
254 } | |
255 | |
256 _resetDOMStorage() { | |
257 if (this.visibleView === this._domStorageView) { | |
258 this.visibleView.detach(); | |
259 delete this.visibleView; | |
260 } | |
261 | |
262 this._domStorageTreeElements.clear(); | |
263 this.localStorageListTreeElement.removeChildren(); | |
264 this.sessionStorageListTreeElement.removeChildren(); | |
265 } | |
266 | |
267 _resetCookies() { | |
268 if (this.visibleView instanceof Resources.CookieItemsView) { | |
269 this.visibleView.detach(); | |
270 delete this.visibleView; | |
271 } | |
272 this.cookieListTreeElement.removeChildren(); | |
273 } | |
274 | |
275 _resetCacheStorage() { | |
276 if (this.visibleView instanceof Resources.ServiceWorkerCacheView) { | |
277 this.visibleView.detach(); | |
278 delete this.visibleView; | |
279 } | |
280 this.cacheStorageListTreeElement.removeChildren(); | |
281 this.cacheStorageListTreeElement.setExpandable(false); | |
282 } | |
283 | |
284 _resetAppCache() { | |
285 for (var frameId of Object.keys(this._applicationCacheFrameElements)) | |
286 this._applicationCacheFrameManifestRemoved({data: frameId}); | |
287 this.applicationCacheListTreeElement.setExpandable(false); | |
288 } | |
289 | |
290 _reset() { | |
291 this._domains = {}; | |
292 this._resetWebSQL(); | |
293 this._resetDOMStorage(); | |
294 this._resetCookies(); | |
295 this._resetCacheStorage(); | |
296 // No need to this._resetAppCache. | |
297 | |
298 if ((this.visibleView instanceof SourceFrame.ResourceSourceFrame) || | |
299 (this.visibleView instanceof SourceFrame.ImageView) || (this.visibleView
instanceof SourceFrame.FontView)) { | |
300 this.visibleView.detach(); | |
301 delete this.visibleView; | |
302 } | |
303 | |
304 this._storageViewToolbar.removeToolbarItems(); | |
305 | |
306 if (this._sidebarTree.selectedTreeElement) | |
307 this._sidebarTree.selectedTreeElement.deselect(); | |
308 } | |
309 | |
310 /** | |
311 * @param {!SDK.ResourceTreeModel} resourceTreeModel | |
312 */ | |
313 _populateResourceTree(resourceTreeModel) { | |
314 this._treeElementForFrameId = {}; | |
315 resourceTreeModel.addEventListener(SDK.ResourceTreeModel.Events.FrameAdded,
this._frameAdded, this); | |
316 resourceTreeModel.addEventListener(SDK.ResourceTreeModel.Events.FrameNavigat
ed, this._frameNavigated, this); | |
317 resourceTreeModel.addEventListener(SDK.ResourceTreeModel.Events.FrameDetache
d, this._frameDetached, this); | |
318 resourceTreeModel.addEventListener(SDK.ResourceTreeModel.Events.ResourceAdde
d, this._resourceAdded, this); | |
319 | |
320 /** | |
321 * @param {!SDK.ResourceTreeFrame} frame | |
322 * @this {Resources.ResourcesPanel} | |
323 */ | |
324 function populateFrame(frame) { | |
325 this._frameAdded({data: frame}); | |
326 for (var i = 0; i < frame.childFrames.length; ++i) | |
327 populateFrame.call(this, frame.childFrames[i]); | |
328 | |
329 var resources = frame.resources(); | |
330 for (var i = 0; i < resources.length; ++i) | |
331 this._resourceAdded({data: resources[i]}); | |
332 } | |
333 populateFrame.call(this, resourceTreeModel.mainFrame); | |
334 } | |
335 | |
336 _frameAdded(event) { | |
337 var frame = event.data; | |
338 var parentFrame = frame.parentFrame; | |
339 | |
340 var parentTreeElement = parentFrame ? this._treeElementForFrameId[parentFram
e.id] : this.resourcesListTreeElement; | |
341 if (!parentTreeElement) { | |
342 console.warn('No frame to route ' + frame.url + ' to.'); | |
343 return; | |
344 } | |
345 | |
346 var frameTreeElement = new Resources.FrameTreeElement(this, frame); | |
347 this._treeElementForFrameId[frame.id] = frameTreeElement; | |
348 parentTreeElement.appendChild(frameTreeElement); | |
349 } | |
350 | |
351 _frameDetached(event) { | |
352 var frame = event.data; | |
353 var frameTreeElement = this._treeElementForFrameId[frame.id]; | |
354 if (!frameTreeElement) | 67 if (!frameTreeElement) |
355 return; | 68 return; |
356 | 69 |
357 delete this._treeElementForFrameId[frame.id]; | 70 this._treeElementForFrameId.remove(frame.id); |
358 if (frameTreeElement.parent) | 71 if (frameTreeElement.parent) |
359 frameTreeElement.parent.removeChild(frameTreeElement); | 72 frameTreeElement.parent.removeChild(frameTreeElement); |
360 } | 73 } |
361 | 74 |
362 _resourceAdded(event) { | 75 /** |
363 var resource = event.data; | 76 * @param {!SDK.ResourceTreeFrame} frame |
364 var frameId = resource.frameId; | 77 */ |
| 78 _frameNavigated(frame) { |
| 79 if (!Resources.ResourcesSection._getParentFrame(frame)) |
| 80 return; |
| 81 var frameTreeElement = this._treeElementForFrameId.get(frame.id); |
| 82 if (frameTreeElement) |
| 83 frameTreeElement.frameNavigated(frame); |
| 84 } |
365 | 85 |
366 if (resource.statusCode >= 301 && resource.statusCode <= 303) | 86 /** |
| 87 * @param {!SDK.Resource} resource |
| 88 */ |
| 89 _resourceAdded(resource) { |
| 90 var statusCode = resource['statusCode']; |
| 91 if (statusCode >= 301 && statusCode <= 303) |
367 return; | 92 return; |
368 | 93 |
369 var frameTreeElement = this._treeElementForFrameId[frameId]; | 94 var frameTreeElement = this._treeElementForFrameId.get(resource.frameId); |
370 if (!frameTreeElement) { | 95 if (!frameTreeElement) { |
371 // This is a frame's main resource, it will be retained | 96 // This is a frame's main resource, it will be retained |
372 // and re-added by the resource manager; | 97 // and re-added by the resource manager; |
373 return; | 98 return; |
374 } | 99 } |
375 | 100 |
376 frameTreeElement.appendResource(resource); | 101 frameTreeElement.appendResource(resource); |
377 } | 102 } |
378 | 103 |
379 _frameNavigated(event) { | 104 reset() { |
380 var frame = event.data; | 105 this._treeElement.removeChildren(); |
381 | 106 this._treeElementForFrameId.clear(); |
382 if (!frame.parentFrame) | |
383 this._reset(); | |
384 | |
385 var frameId = frame.id; | |
386 var frameTreeElement = this._treeElementForFrameId[frameId]; | |
387 if (frameTreeElement) | |
388 frameTreeElement.frameNavigated(frame); | |
389 | |
390 var applicationCacheFrameTreeElement = this._applicationCacheFrameElements[f
rameId]; | |
391 if (applicationCacheFrameTreeElement) | |
392 applicationCacheFrameTreeElement.frameNavigated(frame); | |
393 } | |
394 | |
395 /** | |
396 * @param {!Resources.DatabaseModel.DatabaseAddedEvent} event | |
397 */ | |
398 _databaseAdded(event) { | |
399 var databaseTreeElement = new Resources.DatabaseTreeElement(this, event.data
base); | |
400 this._databaseTreeElements.set(event.database, databaseTreeElement); | |
401 this.databasesListTreeElement.appendChild(databaseTreeElement); | |
402 } | 107 } |
403 | 108 |
404 /** | 109 /** |
405 * @param {!SDK.ResourceTreeFrame} frame | 110 * @param {!SDK.ResourceTreeFrame} frame |
406 */ | 111 */ |
407 addCookieDocument(frame) { | 112 _populateFrame(frame) { |
408 var parsedURL = frame.url.asParsedURL(); | 113 this._frameAdded(frame); |
409 if (!parsedURL || (parsedURL.scheme !== 'http' && parsedURL.scheme !== 'http
s' && parsedURL.scheme !== 'file')) | 114 for (var child of frame.childFrames) |
410 return; | 115 this._populateFrame(child); |
| 116 for (var resource of frame.resources()) |
| 117 this._resourceAdded(resource); |
| 118 } |
| 119 }; |
411 | 120 |
412 var domain = parsedURL.securityOrigin(); | 121 Resources.FrameTreeElement = class extends Resources.BaseStorageTreeElement { |
413 if (!this._domains[domain]) { | 122 /** |
414 this._domains[domain] = true; | 123 * @param {!Resources.ResourcesPanel} storagePanel |
415 var cookieDomainTreeElement = new Resources.CookieTreeElement(this, frame,
domain); | 124 * @param {!SDK.ResourceTreeFrame} frame |
416 this.cookieListTreeElement.appendChild(cookieDomainTreeElement); | 125 */ |
417 } | 126 constructor(storagePanel, frame) { |
| 127 super(storagePanel, '', false); |
| 128 this._panel = storagePanel; |
| 129 this._frame = frame; |
| 130 this._frameId = frame.id; |
| 131 this._categoryElements = {}; |
| 132 this._treeElementForResource = {}; |
| 133 this.frameNavigated(frame); |
| 134 |
| 135 var icon = UI.Icon.create('largeicon-navigator-frame', 'navigator-tree-item'
); |
| 136 icon.classList.add('navigator-frame-tree-item'); |
| 137 this.setLeadingIcons([icon]); |
| 138 } |
| 139 |
| 140 frameNavigated(frame) { |
| 141 this.removeChildren(); |
| 142 this._frameId = frame.id; |
| 143 this.title = frame.displayName(); |
| 144 this._categoryElements = {}; |
| 145 this._treeElementForResource = {}; |
| 146 } |
| 147 |
| 148 get itemURL() { |
| 149 return 'frame://' + encodeURI(this.titleAsText()); |
418 } | 150 } |
419 | 151 |
420 /** | 152 /** |
421 * @param {!Common.Event} event | 153 * @override |
| 154 * @return {boolean} |
422 */ | 155 */ |
423 _domStorageAdded(event) { | 156 onselect(selectedByUser) { |
424 var domStorage = /** @type {!Resources.DOMStorage} */ (event.data); | 157 super.onselect(selectedByUser); |
425 this._addDOMStorage(domStorage); | 158 this._panel.showCategoryView(this.titleAsText()); |
| 159 |
| 160 this.listItemElement.classList.remove('hovered'); |
| 161 SDK.DOMModel.hideDOMNodeHighlight(); |
| 162 return false; |
426 } | 163 } |
427 | 164 |
428 /** | 165 set hovered(hovered) { |
429 * @param {!Resources.DOMStorage} domStorage | 166 if (hovered) { |
430 */ | 167 this.listItemElement.classList.add('hovered'); |
431 _addDOMStorage(domStorage) { | 168 var domModel = SDK.DOMModel.fromTarget(this._frame.target()); |
432 console.assert(!this._domStorageTreeElements.get(domStorage)); | 169 if (domModel) |
433 | 170 domModel.highlightFrame(this._frameId); |
434 var domStorageTreeElement = new Resources.DOMStorageTreeElement(this, domSto
rage); | 171 } else { |
435 this._domStorageTreeElements.set(domStorage, domStorageTreeElement); | 172 this.listItemElement.classList.remove('hovered'); |
436 if (domStorage.isLocalStorage) | 173 SDK.DOMModel.hideDOMNodeHighlight(); |
437 this.localStorageListTreeElement.appendChild(domStorageTreeElement); | |
438 else | |
439 this.sessionStorageListTreeElement.appendChild(domStorageTreeElement); | |
440 } | |
441 | |
442 /** | |
443 * @param {!Common.Event} event | |
444 */ | |
445 _domStorageRemoved(event) { | |
446 var domStorage = /** @type {!Resources.DOMStorage} */ (event.data); | |
447 this._removeDOMStorage(domStorage); | |
448 } | |
449 | |
450 /** | |
451 * @param {!Resources.DOMStorage} domStorage | |
452 */ | |
453 _removeDOMStorage(domStorage) { | |
454 var treeElement = this._domStorageTreeElements.get(domStorage); | |
455 if (!treeElement) | |
456 return; | |
457 var wasSelected = treeElement.selected; | |
458 var parentListTreeElement = treeElement.parent; | |
459 parentListTreeElement.removeChild(treeElement); | |
460 if (wasSelected) | |
461 parentListTreeElement.select(); | |
462 this._domStorageTreeElements.remove(domStorage); | |
463 } | |
464 | |
465 /** | |
466 * @param {!Resources.Database} database | |
467 */ | |
468 selectDatabase(database) { | |
469 if (database) { | |
470 this._showDatabase(database); | |
471 this._databaseTreeElements.get(database).select(); | |
472 } | |
473 } | |
474 | |
475 /** | |
476 * @param {!Resources.DOMStorage} domStorage | |
477 */ | |
478 selectDOMStorage(domStorage) { | |
479 if (domStorage) { | |
480 this._showDOMStorage(domStorage); | |
481 this._domStorageTreeElements.get(domStorage).select(); | |
482 } | 174 } |
483 } | 175 } |
484 | 176 |
485 /** | 177 /** |
486 * @param {!SDK.Resource} resource | 178 * @param {!SDK.Resource} resource |
487 * @param {number=} line | |
488 * @param {number=} column | |
489 * @return {boolean} | |
490 */ | 179 */ |
491 showResource(resource, line, column) { | 180 appendResource(resource) { |
492 var resourceTreeElement = this._findTreeElementForResource(resource); | 181 var resourceType = resource.resourceType(); |
493 if (resourceTreeElement) | 182 var categoryName = resourceType.name(); |
494 resourceTreeElement.revealAndSelect(true); | 183 var categoryElement = resourceType === Common.resourceTypes.Document ? this
: this._categoryElements[categoryName]; |
495 | 184 if (!categoryElement) { |
496 if (typeof line === 'number') { | 185 categoryElement = |
497 var resourceSourceFrame = this._resourceSourceFrameViewForResource(resourc
e); | 186 new Resources.StorageCategoryTreeElement(this._panel, resource.resourc
eType().category().title, categoryName); |
498 if (resourceSourceFrame) | 187 this._categoryElements[resourceType.name()] = categoryElement; |
499 resourceSourceFrame.revealPosition(line, column, true); | 188 this._insertInPresentationOrder(this, categoryElement); |
500 } | 189 } |
501 return true; | 190 var resourceTreeElement = new Resources.FrameResourceTreeElement(this._panel
, resource); |
| 191 this._insertInPresentationOrder(categoryElement, resourceTreeElement); |
| 192 this._treeElementForResource[resource.url] = resourceTreeElement; |
502 } | 193 } |
503 | 194 |
504 _showResourceView(resource) { | 195 /** |
505 var view = this._resourceViewForResource(resource); | 196 * @param {string} url |
506 if (!view) { | 197 * @return {?SDK.Resource} |
507 this.visibleView.detach(); | 198 */ |
508 return; | 199 resourceByURL(url) { |
| 200 var treeElement = this._treeElementForResource[url]; |
| 201 return treeElement ? treeElement._resource : null; |
| 202 } |
| 203 |
| 204 /** |
| 205 * @override |
| 206 */ |
| 207 appendChild(treeElement) { |
| 208 this._insertInPresentationOrder(this, treeElement); |
| 209 } |
| 210 |
| 211 _insertInPresentationOrder(parentTreeElement, childTreeElement) { |
| 212 // Insert in the alphabetical order, first frames, then resources. Document
resource goes last. |
| 213 function typeWeight(treeElement) { |
| 214 if (treeElement instanceof Resources.StorageCategoryTreeElement) |
| 215 return 2; |
| 216 if (treeElement instanceof Resources.FrameTreeElement) |
| 217 return 1; |
| 218 return 3; |
509 } | 219 } |
510 this._innerShowView(view); | 220 |
| 221 function compare(treeElement1, treeElement2) { |
| 222 var typeWeight1 = typeWeight(treeElement1); |
| 223 var typeWeight2 = typeWeight(treeElement2); |
| 224 |
| 225 var result; |
| 226 if (typeWeight1 > typeWeight2) |
| 227 result = 1; |
| 228 else if (typeWeight1 < typeWeight2) |
| 229 result = -1; |
| 230 else |
| 231 result = treeElement1.titleAsText().localeCompare(treeElement2.titleAsTe
xt()); |
| 232 return result; |
| 233 } |
| 234 |
| 235 var childCount = parentTreeElement.childCount(); |
| 236 var i; |
| 237 for (i = 0; i < childCount; ++i) { |
| 238 if (compare(childTreeElement, parentTreeElement.childAt(i)) < 0) |
| 239 break; |
| 240 } |
| 241 parentTreeElement.insertChild(childTreeElement, i); |
| 242 } |
| 243 }; |
| 244 |
| 245 Resources.FrameResourceTreeElement = class extends Resources.BaseStorageTreeElem
ent { |
| 246 /** |
| 247 * @param {!Resources.ResourcesPanel} storagePanel |
| 248 * @param {!SDK.Resource} resource |
| 249 */ |
| 250 constructor(storagePanel, resource) { |
| 251 super(storagePanel, resource.displayName, false); |
| 252 this._panel = storagePanel; |
| 253 /** @type {!SDK.Resource} */ |
| 254 this._resource = resource; |
| 255 /** @type {?SourceFrame.ResourceSourceFrame} */ |
| 256 this._sourceFrame = null; |
| 257 this.tooltip = resource.url; |
| 258 this._resource[Resources.FrameResourceTreeElement._symbol] = this; |
| 259 |
| 260 var icon = UI.Icon.create('largeicon-navigator-file', 'navigator-tree-item')
; |
| 261 icon.classList.add('navigator-file-tree-item'); |
| 262 icon.classList.add('navigator-' + resource.resourceType().name() + '-tree-it
em'); |
| 263 this.setLeadingIcons([icon]); |
| 264 } |
| 265 |
| 266 /** |
| 267 * @param {!SDK.Resource} resource |
| 268 */ |
| 269 static forResource(resource) { |
| 270 return resource[Resources.FrameResourceTreeElement._symbol]; |
511 } | 271 } |
512 | 272 |
513 /** | 273 /** |
514 * @param {!SDK.Resource} resource | 274 * @param {!SDK.Resource} resource |
515 * @return {?UI.Widget} | 275 * @return {?UI.Widget} |
516 */ | 276 */ |
517 _resourceViewForResource(resource) { | 277 static resourceViewForResource(resource) { |
518 if (resource.hasTextContent()) { | 278 if (resource.hasTextContent()) { |
519 var treeElement = this._findTreeElementForResource(resource); | 279 var treeElement = Resources.FrameResourceTreeElement.forResource(resource)
; |
520 if (!treeElement) | 280 if (!treeElement) |
521 return null; | 281 return null; |
522 return treeElement.sourceView(); | 282 return treeElement._sourceView(); |
523 } | 283 } |
524 | 284 |
525 switch (resource.resourceType()) { | 285 switch (resource.resourceType()) { |
526 case Common.resourceTypes.Image: | 286 case Common.resourceTypes.Image: |
527 return new SourceFrame.ImageView(resource.mimeType, resource); | 287 return new SourceFrame.ImageView(resource.mimeType, resource); |
528 case Common.resourceTypes.Font: | 288 case Common.resourceTypes.Font: |
529 return new SourceFrame.FontView(resource.mimeType, resource); | 289 return new SourceFrame.FontView(resource.mimeType, resource); |
530 default: | 290 default: |
531 return new UI.EmptyWidget(resource.url); | 291 return new UI.EmptyWidget(resource.url); |
532 } | 292 } |
533 } | 293 } |
534 | 294 |
535 /** | |
536 * @param {!SDK.Resource} resource | |
537 * @return {?SourceFrame.ResourceSourceFrame} | |
538 */ | |
539 _resourceSourceFrameViewForResource(resource) { | |
540 var resourceView = this._resourceViewForResource(resource); | |
541 if (resourceView && resourceView instanceof SourceFrame.ResourceSourceFrame) | |
542 return /** @type {!SourceFrame.ResourceSourceFrame} */ (resourceView); | |
543 return null; | |
544 } | |
545 | |
546 /** | |
547 * @param {!Resources.Database} database | |
548 * @param {string=} tableName | |
549 */ | |
550 _showDatabase(database, tableName) { | |
551 if (!database) | |
552 return; | |
553 | |
554 var view; | |
555 if (tableName) { | |
556 var tableViews = this._databaseTableViews.get(database); | |
557 if (!tableViews) { | |
558 tableViews = /** @type {!Object.<string, !Resources.DatabaseTableView>}
*/ ({}); | |
559 this._databaseTableViews.set(database, tableViews); | |
560 } | |
561 view = tableViews[tableName]; | |
562 if (!view) { | |
563 view = new Resources.DatabaseTableView(database, tableName); | |
564 tableViews[tableName] = view; | |
565 } | |
566 } else { | |
567 view = this._databaseQueryViews.get(database); | |
568 if (!view) { | |
569 view = new Resources.DatabaseQueryView(database); | |
570 this._databaseQueryViews.set(database, view); | |
571 view.addEventListener(Resources.DatabaseQueryView.Events.SchemaUpdated,
this._updateDatabaseTables, this); | |
572 } | |
573 } | |
574 | |
575 this._innerShowView(view); | |
576 } | |
577 | |
578 /** | |
579 * @param {!Resources.DOMStorage} domStorage | |
580 */ | |
581 _showDOMStorage(domStorage) { | |
582 if (!domStorage) | |
583 return; | |
584 | |
585 if (!this._domStorageView) | |
586 this._domStorageView = new Resources.DOMStorageItemsView(domStorage); | |
587 else | |
588 this._domStorageView.setStorage(domStorage); | |
589 this._innerShowView(this._domStorageView); | |
590 } | |
591 | |
592 /** | |
593 * @param {!Resources.CookieTreeElement} treeElement | |
594 * @param {string} cookieDomain | |
595 * @param {!SDK.Target} cookieFrameTarget | |
596 */ | |
597 showCookies(treeElement, cookieDomain, cookieFrameTarget) { | |
598 var model = SDK.CookieModel.fromTarget(cookieFrameTarget); | |
599 if (!this._cookieView) | |
600 this._cookieView = new Resources.CookieItemsView(treeElement, model, cooki
eDomain); | |
601 else | |
602 this._cookieView.setCookiesDomain(model, cookieDomain); | |
603 this._innerShowView(this._cookieView); | |
604 } | |
605 | |
606 /** | |
607 * @param {!SDK.Target} target | |
608 * @param {string} cookieDomain | |
609 */ | |
610 _clearCookies(target, cookieDomain) { | |
611 SDK.CookieModel.fromTarget(target).clear(cookieDomain, () => { | |
612 if (this._cookieView) | |
613 this._cookieView.refreshItems(); | |
614 }); | |
615 } | |
616 | |
617 showApplicationCache(frameId) { | |
618 if (!this._applicationCacheViews[frameId]) { | |
619 this._applicationCacheViews[frameId] = | |
620 new Resources.ApplicationCacheItemsView(this._applicationCacheModel, f
rameId); | |
621 } | |
622 | |
623 this._innerShowView(this._applicationCacheViews[frameId]); | |
624 } | |
625 | |
626 /** | |
627 * @param {!UI.Widget} view | |
628 */ | |
629 showFileSystem(view) { | |
630 this._innerShowView(view); | |
631 } | |
632 | |
633 showCategoryView(categoryName) { | |
634 if (!this._categoryView) | |
635 this._categoryView = new Resources.StorageCategoryView(); | |
636 this._categoryView.setText(categoryName); | |
637 this._innerShowView(this._categoryView); | |
638 } | |
639 | |
640 _innerShowView(view) { | |
641 if (this.visibleView === view) | |
642 return; | |
643 | |
644 if (this.visibleView) | |
645 this.visibleView.detach(); | |
646 | |
647 view.show(this.storageViews); | |
648 this.visibleView = view; | |
649 | |
650 this._storageViewToolbar.removeToolbarItems(); | |
651 var toolbarItems = (view instanceof UI.SimpleView && view.syncToolbarItems()
) || []; | |
652 for (var i = 0; i < toolbarItems.length; ++i) | |
653 this._storageViewToolbar.appendToolbarItem(toolbarItems[i]); | |
654 this._storageViewToolbar.element.classList.toggle('hidden', !toolbarItems.le
ngth); | |
655 } | |
656 | |
657 closeVisibleView() { | |
658 if (!this.visibleView) | |
659 return; | |
660 this.visibleView.detach(); | |
661 delete this.visibleView; | |
662 } | |
663 | |
664 _updateDatabaseTables(event) { | |
665 var database = event.data; | |
666 | |
667 if (!database) | |
668 return; | |
669 | |
670 var databasesTreeElement = this._databaseTreeElements.get(database); | |
671 if (!databasesTreeElement) | |
672 return; | |
673 | |
674 databasesTreeElement.invalidateChildren(); | |
675 var tableViews = this._databaseTableViews.get(database); | |
676 | |
677 if (!tableViews) | |
678 return; | |
679 | |
680 var tableNamesHash = {}; | |
681 var self = this; | |
682 function tableNamesCallback(tableNames) { | |
683 var tableNamesLength = tableNames.length; | |
684 for (var i = 0; i < tableNamesLength; ++i) | |
685 tableNamesHash[tableNames[i]] = true; | |
686 | |
687 for (var tableName in tableViews) { | |
688 if (!(tableName in tableNamesHash)) { | |
689 if (self.visibleView === tableViews[tableName]) | |
690 self.closeVisibleView(); | |
691 delete tableViews[tableName]; | |
692 } | |
693 } | |
694 } | |
695 database.getTableNames(tableNamesCallback); | |
696 } | |
697 | |
698 /** | |
699 * @param {!Resources.DOMStorageModel} domStorageModel | |
700 */ | |
701 _populateDOMStorageTree(domStorageModel) { | |
702 domStorageModel.enable(); | |
703 domStorageModel.storages().forEach(this._addDOMStorage.bind(this)); | |
704 domStorageModel.addEventListener(Resources.DOMStorageModel.Events.DOMStorage
Added, this._domStorageAdded, this); | |
705 domStorageModel.addEventListener(Resources.DOMStorageModel.Events.DOMStorage
Removed, this._domStorageRemoved, this); | |
706 } | |
707 | |
708 /** | |
709 * @param {!SDK.ResourceTreeModel} resourceTreeModel | |
710 */ | |
711 _populateApplicationCacheTree(resourceTreeModel) { | |
712 this._applicationCacheModel = Resources.ApplicationCacheModel.fromTarget(thi
s._target); | |
713 | |
714 this._applicationCacheViews = {}; | |
715 this._applicationCacheFrameElements = {}; | |
716 this._applicationCacheManifestElements = {}; | |
717 | |
718 this._applicationCacheModel.addEventListener( | |
719 Resources.ApplicationCacheModel.Events.FrameManifestAdded, this._applica
tionCacheFrameManifestAdded, this); | |
720 this._applicationCacheModel.addEventListener( | |
721 Resources.ApplicationCacheModel.Events.FrameManifestRemoved, this._appli
cationCacheFrameManifestRemoved, this); | |
722 this._applicationCacheModel.addEventListener( | |
723 Resources.ApplicationCacheModel.Events.FrameManifestsReset, this._resetA
ppCache, this); | |
724 | |
725 this._applicationCacheModel.addEventListener( | |
726 Resources.ApplicationCacheModel.Events.FrameManifestStatusUpdated, | |
727 this._applicationCacheFrameManifestStatusChanged, this); | |
728 this._applicationCacheModel.addEventListener( | |
729 Resources.ApplicationCacheModel.Events.NetworkStateChanged, this._applic
ationCacheNetworkStateChanged, this); | |
730 } | |
731 | |
732 _applicationCacheFrameManifestAdded(event) { | |
733 var frameId = event.data; | |
734 var manifestURL = this._applicationCacheModel.frameManifestURL(frameId); | |
735 | |
736 var manifestTreeElement = this._applicationCacheManifestElements[manifestURL
]; | |
737 if (!manifestTreeElement) { | |
738 manifestTreeElement = new Resources.ApplicationCacheManifestTreeElement(th
is, manifestURL); | |
739 this.applicationCacheListTreeElement.appendChild(manifestTreeElement); | |
740 this._applicationCacheManifestElements[manifestURL] = manifestTreeElement; | |
741 } | |
742 | |
743 var frameTreeElement = new Resources.ApplicationCacheFrameTreeElement(this,
frameId, manifestURL); | |
744 manifestTreeElement.appendChild(frameTreeElement); | |
745 manifestTreeElement.expand(); | |
746 this._applicationCacheFrameElements[frameId] = frameTreeElement; | |
747 } | |
748 | |
749 _applicationCacheFrameManifestRemoved(event) { | |
750 var frameId = event.data; | |
751 var frameTreeElement = this._applicationCacheFrameElements[frameId]; | |
752 if (!frameTreeElement) | |
753 return; | |
754 | |
755 var manifestURL = frameTreeElement.manifestURL; | |
756 delete this._applicationCacheFrameElements[frameId]; | |
757 delete this._applicationCacheViews[frameId]; | |
758 frameTreeElement.parent.removeChild(frameTreeElement); | |
759 | |
760 var manifestTreeElement = this._applicationCacheManifestElements[manifestURL
]; | |
761 if (manifestTreeElement.childCount()) | |
762 return; | |
763 | |
764 delete this._applicationCacheManifestElements[manifestURL]; | |
765 manifestTreeElement.parent.removeChild(manifestTreeElement); | |
766 } | |
767 | |
768 _applicationCacheFrameManifestStatusChanged(event) { | |
769 var frameId = event.data; | |
770 var status = this._applicationCacheModel.frameManifestStatus(frameId); | |
771 | |
772 if (this._applicationCacheViews[frameId]) | |
773 this._applicationCacheViews[frameId].updateStatus(status); | |
774 } | |
775 | |
776 _applicationCacheNetworkStateChanged(event) { | |
777 var isNowOnline = event.data; | |
778 | |
779 for (var manifestURL in this._applicationCacheViews) | |
780 this._applicationCacheViews[manifestURL].updateNetworkState(isNowOnline); | |
781 } | |
782 | |
783 _findTreeElementForResource(resource) { | |
784 return resource[Resources.FrameResourceTreeElement._symbol]; | |
785 } | |
786 | |
787 showView(view) { | |
788 if (view) | |
789 this.showResource(view.resource); | |
790 } | |
791 | |
792 _onmousemove(event) { | |
793 var nodeUnderMouse = event.target; | |
794 if (!nodeUnderMouse) | |
795 return; | |
796 | |
797 var listNode = nodeUnderMouse.enclosingNodeOrSelfWithNodeName('li'); | |
798 if (!listNode) | |
799 return; | |
800 | |
801 var element = listNode.treeElement; | |
802 if (this._previousHoveredElement === element) | |
803 return; | |
804 | |
805 if (this._previousHoveredElement) { | |
806 this._previousHoveredElement.hovered = false; | |
807 delete this._previousHoveredElement; | |
808 } | |
809 | |
810 if (element instanceof Resources.FrameTreeElement) { | |
811 this._previousHoveredElement = element; | |
812 element.hovered = true; | |
813 } | |
814 } | |
815 | |
816 _onmouseleave(event) { | |
817 if (this._previousHoveredElement) { | |
818 this._previousHoveredElement.hovered = false; | |
819 delete this._previousHoveredElement; | |
820 } | |
821 } | |
822 }; | |
823 | |
824 /** | |
825 * @implements {Common.Revealer} | |
826 * @unrestricted | |
827 */ | |
828 Resources.ResourcesPanel.ResourceRevealer = class { | |
829 /** | |
830 * @override | |
831 * @param {!Object} resource | |
832 * @return {!Promise} | |
833 */ | |
834 reveal(resource) { | |
835 if (!(resource instanceof SDK.Resource)) | |
836 return Promise.reject(new Error('Internal error: not a resource')); | |
837 var panel = Resources.ResourcesPanel._instance(); | |
838 return UI.viewManager.showView('resources').then(panel.showResource.bind(pan
el, resource)); | |
839 } | |
840 }; | |
841 | |
842 /** | |
843 * @unrestricted | |
844 */ | |
845 Resources.BaseStorageTreeElement = class extends UI.TreeElement { | |
846 /** | |
847 * @param {!Resources.ResourcesPanel} storagePanel | |
848 * @param {string} title | |
849 * @param {boolean} expandable | |
850 */ | |
851 constructor(storagePanel, title, expandable) { | |
852 super(title, expandable); | |
853 this._storagePanel = storagePanel; | |
854 } | |
855 | |
856 /** | |
857 * @override | |
858 * @return {boolean} | |
859 */ | |
860 onselect(selectedByUser) { | |
861 if (!selectedByUser) | |
862 return false; | |
863 var itemURL = this.itemURL; | |
864 if (itemURL) | |
865 this._storagePanel._resourcesLastSelectedItemSetting.set(itemURL); | |
866 return false; | |
867 } | |
868 }; | |
869 | |
870 /** | |
871 * @unrestricted | |
872 */ | |
873 Resources.StorageCategoryTreeElement = class extends Resources.BaseStorageTreeEl
ement { | |
874 /** | |
875 * @param {!Resources.ResourcesPanel} storagePanel | |
876 * @param {string} categoryName | |
877 * @param {string} settingsKey | |
878 */ | |
879 constructor(storagePanel, categoryName, settingsKey) { | |
880 super(storagePanel, categoryName, false); | |
881 this._expandedSetting = | |
882 Common.settings.createSetting('resources' + settingsKey + 'Expanded', se
ttingsKey === 'Frames'); | |
883 this._categoryName = categoryName; | |
884 } | |
885 | |
886 /** | |
887 * @return {!SDK.Target} | |
888 */ | |
889 target() { | |
890 return this._storagePanel._target; | |
891 } | |
892 | |
893 get itemURL() { | |
894 return 'category://' + this._categoryName; | |
895 } | |
896 | |
897 /** | |
898 * @override | |
899 * @return {boolean} | |
900 */ | |
901 onselect(selectedByUser) { | |
902 super.onselect(selectedByUser); | |
903 this._storagePanel.showCategoryView(this._categoryName); | |
904 return false; | |
905 } | |
906 | |
907 /** | |
908 * @override | |
909 */ | |
910 onattach() { | |
911 super.onattach(); | |
912 if (this._expandedSetting.get()) | |
913 this.expand(); | |
914 } | |
915 | |
916 /** | |
917 * @override | |
918 */ | |
919 onexpand() { | |
920 this._expandedSetting.set(true); | |
921 } | |
922 | |
923 /** | |
924 * @override | |
925 */ | |
926 oncollapse() { | |
927 this._expandedSetting.set(false); | |
928 } | |
929 }; | |
930 | |
931 /** | |
932 * @unrestricted | |
933 */ | |
934 Resources.FrameTreeElement = class extends Resources.BaseStorageTreeElement { | |
935 /** | |
936 * @param {!Resources.ResourcesPanel} storagePanel | |
937 * @param {!SDK.ResourceTreeFrame} frame | |
938 */ | |
939 constructor(storagePanel, frame) { | |
940 super(storagePanel, '', false); | |
941 this._frame = frame; | |
942 this.frameNavigated(frame); | |
943 | |
944 var icon = UI.Icon.create('largeicon-navigator-frame', 'navigator-tree-item'
); | |
945 icon.classList.add('navigator-frame-tree-item'); | |
946 this.setLeadingIcons([icon]); | |
947 } | |
948 | |
949 frameNavigated(frame) { | |
950 this.removeChildren(); | |
951 this._frameId = frame.id; | |
952 this.title = frame.displayName(); | |
953 this._categoryElements = {}; | |
954 this._treeElementForResource = {}; | |
955 | |
956 this._storagePanel.addCookieDocument(frame); | |
957 } | |
958 | |
959 get itemURL() { | |
960 return 'frame://' + encodeURI(this.titleAsText()); | |
961 } | |
962 | |
963 /** | |
964 * @override | |
965 * @return {boolean} | |
966 */ | |
967 onselect(selectedByUser) { | |
968 super.onselect(selectedByUser); | |
969 this._storagePanel.showCategoryView(this.titleAsText()); | |
970 | |
971 this.listItemElement.classList.remove('hovered'); | |
972 SDK.DOMModel.hideDOMNodeHighlight(); | |
973 return false; | |
974 } | |
975 | |
976 set hovered(hovered) { | |
977 if (hovered) { | |
978 this.listItemElement.classList.add('hovered'); | |
979 var domModel = SDK.DOMModel.fromTarget(this._frame.target()); | |
980 if (domModel) | |
981 domModel.highlightFrame(this._frameId); | |
982 } else { | |
983 this.listItemElement.classList.remove('hovered'); | |
984 SDK.DOMModel.hideDOMNodeHighlight(); | |
985 } | |
986 } | |
987 | |
988 /** | |
989 * @param {!SDK.Resource} resource | |
990 */ | |
991 appendResource(resource) { | |
992 var resourceType = resource.resourceType(); | |
993 var categoryName = resourceType.name(); | |
994 var categoryElement = resourceType === Common.resourceTypes.Document ? this
: this._categoryElements[categoryName]; | |
995 if (!categoryElement) { | |
996 categoryElement = new Resources.StorageCategoryTreeElement( | |
997 this._storagePanel, resource.resourceType().category().title, category
Name); | |
998 this._categoryElements[resourceType.name()] = categoryElement; | |
999 this._insertInPresentationOrder(this, categoryElement); | |
1000 } | |
1001 var resourceTreeElement = new Resources.FrameResourceTreeElement(this._stora
gePanel, resource); | |
1002 this._insertInPresentationOrder(categoryElement, resourceTreeElement); | |
1003 this._treeElementForResource[resource.url] = resourceTreeElement; | |
1004 } | |
1005 | |
1006 /** | |
1007 * @param {string} url | |
1008 * @return {?SDK.Resource} | |
1009 */ | |
1010 resourceByURL(url) { | |
1011 var treeElement = this._treeElementForResource[url]; | |
1012 return treeElement ? treeElement._resource : null; | |
1013 } | |
1014 | |
1015 /** | |
1016 * @override | |
1017 */ | |
1018 appendChild(treeElement) { | |
1019 this._insertInPresentationOrder(this, treeElement); | |
1020 } | |
1021 | |
1022 _insertInPresentationOrder(parentTreeElement, childTreeElement) { | |
1023 // Insert in the alphabetical order, first frames, then resources. Document
resource goes last. | |
1024 function typeWeight(treeElement) { | |
1025 if (treeElement instanceof Resources.StorageCategoryTreeElement) | |
1026 return 2; | |
1027 if (treeElement instanceof Resources.FrameTreeElement) | |
1028 return 1; | |
1029 return 3; | |
1030 } | |
1031 | |
1032 function compare(treeElement1, treeElement2) { | |
1033 var typeWeight1 = typeWeight(treeElement1); | |
1034 var typeWeight2 = typeWeight(treeElement2); | |
1035 | |
1036 var result; | |
1037 if (typeWeight1 > typeWeight2) | |
1038 result = 1; | |
1039 else if (typeWeight1 < typeWeight2) | |
1040 result = -1; | |
1041 else | |
1042 result = treeElement1.titleAsText().localeCompare(treeElement2.titleAsTe
xt()); | |
1043 return result; | |
1044 } | |
1045 | |
1046 var childCount = parentTreeElement.childCount(); | |
1047 var i; | |
1048 for (i = 0; i < childCount; ++i) { | |
1049 if (compare(childTreeElement, parentTreeElement.childAt(i)) < 0) | |
1050 break; | |
1051 } | |
1052 parentTreeElement.insertChild(childTreeElement, i); | |
1053 } | |
1054 }; | |
1055 | |
1056 /** | |
1057 * @unrestricted | |
1058 */ | |
1059 Resources.FrameResourceTreeElement = class extends Resources.BaseStorageTreeElem
ent { | |
1060 /** | |
1061 * @param {!Resources.ResourcesPanel} storagePanel | |
1062 * @param {!SDK.Resource} resource | |
1063 */ | |
1064 constructor(storagePanel, resource) { | |
1065 super(storagePanel, resource.displayName, false); | |
1066 /** @type {!SDK.Resource} */ | |
1067 this._resource = resource; | |
1068 this.tooltip = resource.url; | |
1069 this._resource[Resources.FrameResourceTreeElement._symbol] = this; | |
1070 | |
1071 var icon = UI.Icon.create('largeicon-navigator-file', 'navigator-tree-item')
; | |
1072 icon.classList.add('navigator-file-tree-item'); | |
1073 icon.classList.add('navigator-' + resource.resourceType().name() + '-tree-it
em'); | |
1074 this.setLeadingIcons([icon]); | |
1075 } | |
1076 | |
1077 get itemURL() { | 295 get itemURL() { |
1078 return this._resource.url; | 296 return this._resource.url; |
1079 } | 297 } |
1080 | 298 |
1081 /** | 299 /** |
1082 * @override | 300 * @override |
1083 * @return {boolean} | 301 * @return {boolean} |
1084 */ | 302 */ |
1085 onselect(selectedByUser) { | 303 onselect(selectedByUser) { |
1086 super.onselect(selectedByUser); | 304 super.onselect(selectedByUser); |
1087 this._storagePanel._showResourceView(this._resource); | 305 this.showView(Resources.FrameResourceTreeElement.resourceViewForResource(thi
s._resource)); |
1088 return false; | 306 return false; |
1089 } | 307 } |
1090 | 308 |
1091 /** | 309 /** |
1092 * @override | 310 * @override |
1093 * @return {boolean} | 311 * @return {boolean} |
1094 */ | 312 */ |
1095 ondblclick(event) { | 313 ondblclick(event) { |
1096 InspectorFrontendHost.openInNewTab(this._resource.url); | 314 InspectorFrontendHost.openInNewTab(this._resource.url); |
1097 return false; | 315 return false; |
(...skipping 21 matching lines...) Expand all Loading... |
1119 | 337 |
1120 _handleContextMenuEvent(event) { | 338 _handleContextMenuEvent(event) { |
1121 var contextMenu = new UI.ContextMenu(event); | 339 var contextMenu = new UI.ContextMenu(event); |
1122 contextMenu.appendApplicableItems(this._resource); | 340 contextMenu.appendApplicableItems(this._resource); |
1123 contextMenu.show(); | 341 contextMenu.show(); |
1124 } | 342 } |
1125 | 343 |
1126 /** | 344 /** |
1127 * @return {!SourceFrame.ResourceSourceFrame} | 345 * @return {!SourceFrame.ResourceSourceFrame} |
1128 */ | 346 */ |
1129 sourceView() { | 347 _sourceView() { |
1130 if (!this._sourceView) { | 348 if (!this._sourceFrame) { |
1131 var sourceFrame = new SourceFrame.ResourceSourceFrame(this._resource); | 349 this._sourceFrame = new SourceFrame.ResourceSourceFrame(this._resource); |
1132 sourceFrame.setHighlighterType(this._resource.canonicalMimeType()); | 350 this._sourceFrame.setHighlighterType(this._resource.canonicalMimeType()); |
1133 this._sourceView = sourceFrame; | |
1134 } | 351 } |
1135 return this._sourceView; | 352 return this._sourceFrame; |
1136 } | 353 } |
1137 }; | 354 }; |
1138 | 355 |
1139 Resources.FrameResourceTreeElement._symbol = Symbol('treeElement'); | 356 Resources.FrameResourceTreeElement._symbol = Symbol('treeElement'); |
1140 | |
1141 /** | |
1142 * @unrestricted | |
1143 */ | |
1144 Resources.DatabaseTreeElement = class extends Resources.BaseStorageTreeElement { | |
1145 /** | |
1146 * @param {!Resources.ResourcesPanel} storagePanel | |
1147 * @param {!Resources.Database} database | |
1148 */ | |
1149 constructor(storagePanel, database) { | |
1150 super(storagePanel, database.name, true); | |
1151 this._database = database; | |
1152 | |
1153 var icon = UI.Icon.create('mediumicon-database', 'resource-tree-item'); | |
1154 this.setLeadingIcons([icon]); | |
1155 } | |
1156 | |
1157 get itemURL() { | |
1158 return 'database://' + encodeURI(this._database.name); | |
1159 } | |
1160 | |
1161 /** | |
1162 * @override | |
1163 * @return {boolean} | |
1164 */ | |
1165 onselect(selectedByUser) { | |
1166 super.onselect(selectedByUser); | |
1167 this._storagePanel._showDatabase(this._database); | |
1168 return false; | |
1169 } | |
1170 | |
1171 /** | |
1172 * @override | |
1173 */ | |
1174 onexpand() { | |
1175 this._updateChildren(); | |
1176 } | |
1177 | |
1178 _updateChildren() { | |
1179 this.removeChildren(); | |
1180 | |
1181 /** | |
1182 * @param {!Array.<string>} tableNames | |
1183 * @this {Resources.DatabaseTreeElement} | |
1184 */ | |
1185 function tableNamesCallback(tableNames) { | |
1186 var tableNamesLength = tableNames.length; | |
1187 for (var i = 0; i < tableNamesLength; ++i) | |
1188 this.appendChild(new Resources.DatabaseTableTreeElement(this._storagePan
el, this._database, tableNames[i])); | |
1189 } | |
1190 this._database.getTableNames(tableNamesCallback.bind(this)); | |
1191 } | |
1192 }; | |
1193 | |
1194 /** | |
1195 * @unrestricted | |
1196 */ | |
1197 Resources.DatabaseTableTreeElement = class extends Resources.BaseStorageTreeElem
ent { | |
1198 constructor(storagePanel, database, tableName) { | |
1199 super(storagePanel, tableName, false); | |
1200 this._database = database; | |
1201 this._tableName = tableName; | |
1202 var icon = UI.Icon.create('mediumicon-table', 'resource-tree-item'); | |
1203 this.setLeadingIcons([icon]); | |
1204 } | |
1205 | |
1206 get itemURL() { | |
1207 return 'database://' + encodeURI(this._database.name) + '/' + encodeURI(this
._tableName); | |
1208 } | |
1209 | |
1210 /** | |
1211 * @override | |
1212 * @return {boolean} | |
1213 */ | |
1214 onselect(selectedByUser) { | |
1215 super.onselect(selectedByUser); | |
1216 this._storagePanel._showDatabase(this._database, this._tableName); | |
1217 return false; | |
1218 } | |
1219 }; | |
1220 | |
1221 /** | |
1222 * @unrestricted | |
1223 */ | |
1224 Resources.ServiceWorkerCacheTreeElement = class extends Resources.StorageCategor
yTreeElement { | |
1225 /** | |
1226 * @param {!Resources.ResourcesPanel} storagePanel | |
1227 */ | |
1228 constructor(storagePanel) { | |
1229 super(storagePanel, Common.UIString('Cache Storage'), 'CacheStorage'); | |
1230 var icon = UI.Icon.create('mediumicon-database', 'resource-tree-item'); | |
1231 this.setLeadingIcons([icon]); | |
1232 } | |
1233 | |
1234 _initialize() { | |
1235 /** @type {!Array.<!Resources.SWCacheTreeElement>} */ | |
1236 this._swCacheTreeElements = []; | |
1237 var target = this._storagePanel._target; | |
1238 var model = target && SDK.ServiceWorkerCacheModel.fromTarget(target); | |
1239 if (model) { | |
1240 for (var cache of model.caches()) | |
1241 this._addCache(model, cache); | |
1242 } | |
1243 SDK.targetManager.addModelListener( | |
1244 SDK.ServiceWorkerCacheModel, SDK.ServiceWorkerCacheModel.Events.CacheAdd
ed, this._cacheAdded, this); | |
1245 SDK.targetManager.addModelListener( | |
1246 SDK.ServiceWorkerCacheModel, SDK.ServiceWorkerCacheModel.Events.CacheRem
oved, this._cacheRemoved, this); | |
1247 } | |
1248 | |
1249 /** | |
1250 * @override | |
1251 */ | |
1252 onattach() { | |
1253 super.onattach(); | |
1254 this.listItemElement.addEventListener('contextmenu', this._handleContextMenu
Event.bind(this), true); | |
1255 } | |
1256 | |
1257 _handleContextMenuEvent(event) { | |
1258 var contextMenu = new UI.ContextMenu(event); | |
1259 contextMenu.appendItem(Common.UIString('Refresh Caches'), this._refreshCache
s.bind(this)); | |
1260 contextMenu.show(); | |
1261 } | |
1262 | |
1263 _refreshCaches() { | |
1264 var target = this._storagePanel._target; | |
1265 if (target) { | |
1266 var model = SDK.ServiceWorkerCacheModel.fromTarget(target); | |
1267 if (!model) | |
1268 return; | |
1269 model.refreshCacheNames(); | |
1270 } | |
1271 } | |
1272 | |
1273 /** | |
1274 * @param {!Common.Event} event | |
1275 */ | |
1276 _cacheAdded(event) { | |
1277 var cache = /** @type {!SDK.ServiceWorkerCacheModel.Cache} */ (event.data.ca
che); | |
1278 var model = /** @type {!SDK.ServiceWorkerCacheModel} */ (event.data.model); | |
1279 this._addCache(model, cache); | |
1280 } | |
1281 | |
1282 /** | |
1283 * @param {!SDK.ServiceWorkerCacheModel} model | |
1284 * @param {!SDK.ServiceWorkerCacheModel.Cache} cache | |
1285 */ | |
1286 _addCache(model, cache) { | |
1287 var swCacheTreeElement = new Resources.SWCacheTreeElement(this._storagePanel
, model, cache); | |
1288 this._swCacheTreeElements.push(swCacheTreeElement); | |
1289 this.appendChild(swCacheTreeElement); | |
1290 } | |
1291 | |
1292 /** | |
1293 * @param {!Common.Event} event | |
1294 */ | |
1295 _cacheRemoved(event) { | |
1296 var cache = /** @type {!SDK.ServiceWorkerCacheModel.Cache} */ (event.data.ca
che); | |
1297 var model = /** @type {!SDK.ServiceWorkerCacheModel} */ (event.data.model); | |
1298 | |
1299 var swCacheTreeElement = this._cacheTreeElement(model, cache); | |
1300 if (!swCacheTreeElement) | |
1301 return; | |
1302 | |
1303 swCacheTreeElement.clear(); | |
1304 this.removeChild(swCacheTreeElement); | |
1305 this._swCacheTreeElements.remove(swCacheTreeElement); | |
1306 } | |
1307 | |
1308 /** | |
1309 * @param {!SDK.ServiceWorkerCacheModel} model | |
1310 * @param {!SDK.ServiceWorkerCacheModel.Cache} cache | |
1311 * @return {?Resources.SWCacheTreeElement} | |
1312 */ | |
1313 _cacheTreeElement(model, cache) { | |
1314 var index = -1; | |
1315 for (var i = 0; i < this._swCacheTreeElements.length; ++i) { | |
1316 if (this._swCacheTreeElements[i]._cache.equals(cache) && this._swCacheTree
Elements[i]._model === model) { | |
1317 index = i; | |
1318 break; | |
1319 } | |
1320 } | |
1321 if (index !== -1) | |
1322 return this._swCacheTreeElements[i]; | |
1323 return null; | |
1324 } | |
1325 }; | |
1326 | |
1327 /** | |
1328 * @unrestricted | |
1329 */ | |
1330 Resources.SWCacheTreeElement = class extends Resources.BaseStorageTreeElement { | |
1331 /** | |
1332 * @param {!Resources.ResourcesPanel} storagePanel | |
1333 * @param {!SDK.ServiceWorkerCacheModel} model | |
1334 * @param {!SDK.ServiceWorkerCacheModel.Cache} cache | |
1335 */ | |
1336 constructor(storagePanel, model, cache) { | |
1337 super(storagePanel, cache.cacheName + ' - ' + cache.securityOrigin, false); | |
1338 this._model = model; | |
1339 this._cache = cache; | |
1340 var icon = UI.Icon.create('mediumicon-table', 'resource-tree-item'); | |
1341 this.setLeadingIcons([icon]); | |
1342 } | |
1343 | |
1344 get itemURL() { | |
1345 // I don't think this will work at all. | |
1346 return 'cache://' + this._cache.cacheId; | |
1347 } | |
1348 | |
1349 /** | |
1350 * @override | |
1351 */ | |
1352 onattach() { | |
1353 super.onattach(); | |
1354 this.listItemElement.addEventListener('contextmenu', this._handleContextMenu
Event.bind(this), true); | |
1355 } | |
1356 | |
1357 _handleContextMenuEvent(event) { | |
1358 var contextMenu = new UI.ContextMenu(event); | |
1359 contextMenu.appendItem(Common.UIString('Delete'), this._clearCache.bind(this
)); | |
1360 contextMenu.show(); | |
1361 } | |
1362 | |
1363 _clearCache() { | |
1364 this._model.deleteCache(this._cache); | |
1365 } | |
1366 | |
1367 /** | |
1368 * @param {!SDK.ServiceWorkerCacheModel.Cache} cache | |
1369 */ | |
1370 update(cache) { | |
1371 this._cache = cache; | |
1372 if (this._view) | |
1373 this._view.update(cache); | |
1374 } | |
1375 | |
1376 /** | |
1377 * @override | |
1378 * @return {boolean} | |
1379 */ | |
1380 onselect(selectedByUser) { | |
1381 super.onselect(selectedByUser); | |
1382 if (!this._view) | |
1383 this._view = new Resources.ServiceWorkerCacheView(this._model, this._cache
); | |
1384 | |
1385 this._storagePanel._innerShowView(this._view); | |
1386 return false; | |
1387 } | |
1388 | |
1389 clear() { | |
1390 if (this._view) | |
1391 this._view.clear(); | |
1392 } | |
1393 }; | |
1394 | |
1395 /** | |
1396 * @unrestricted | |
1397 */ | |
1398 Resources.ServiceWorkersTreeElement = class extends Resources.BaseStorageTreeEle
ment { | |
1399 /** | |
1400 * @param {!Resources.ResourcesPanel} storagePanel | |
1401 */ | |
1402 constructor(storagePanel) { | |
1403 super(storagePanel, Common.UIString('Service Workers'), false); | |
1404 var icon = UI.Icon.create('mediumicon-service-worker', 'resource-tree-item')
; | |
1405 this.setLeadingIcons([icon]); | |
1406 } | |
1407 | |
1408 /** | |
1409 * @return {string} | |
1410 */ | |
1411 get itemURL() { | |
1412 return 'service-workers://'; | |
1413 } | |
1414 | |
1415 /** | |
1416 * @override | |
1417 * @return {boolean} | |
1418 */ | |
1419 onselect(selectedByUser) { | |
1420 super.onselect(selectedByUser); | |
1421 if (!this._view) | |
1422 this._view = new Resources.ServiceWorkersView(); | |
1423 this._storagePanel._innerShowView(this._view); | |
1424 return false; | |
1425 } | |
1426 }; | |
1427 | |
1428 /** | |
1429 * @unrestricted | |
1430 */ | |
1431 Resources.AppManifestTreeElement = class extends Resources.BaseStorageTreeElemen
t { | |
1432 /** | |
1433 * @param {!Resources.ResourcesPanel} storagePanel | |
1434 */ | |
1435 constructor(storagePanel) { | |
1436 super(storagePanel, Common.UIString('Manifest'), false); | |
1437 var icon = UI.Icon.create('mediumicon-manifest', 'resource-tree-item'); | |
1438 this.setLeadingIcons([icon]); | |
1439 } | |
1440 | |
1441 /** | |
1442 * @return {string} | |
1443 */ | |
1444 get itemURL() { | |
1445 return 'manifest://'; | |
1446 } | |
1447 | |
1448 /** | |
1449 * @override | |
1450 * @return {boolean} | |
1451 */ | |
1452 onselect(selectedByUser) { | |
1453 super.onselect(selectedByUser); | |
1454 if (!this._view) | |
1455 this._view = new Resources.AppManifestView(); | |
1456 this._storagePanel._innerShowView(this._view); | |
1457 return false; | |
1458 } | |
1459 }; | |
1460 | |
1461 /** | |
1462 * @unrestricted | |
1463 */ | |
1464 Resources.ClearStorageTreeElement = class extends Resources.BaseStorageTreeEleme
nt { | |
1465 /** | |
1466 * @param {!Resources.ResourcesPanel} storagePanel | |
1467 */ | |
1468 constructor(storagePanel) { | |
1469 super(storagePanel, Common.UIString('Clear storage'), false); | |
1470 var icon = UI.Icon.create('mediumicon-clear-storage', 'resource-tree-item'); | |
1471 this.setLeadingIcons([icon]); | |
1472 } | |
1473 | |
1474 /** | |
1475 * @return {string} | |
1476 */ | |
1477 get itemURL() { | |
1478 return 'clear-storage://'; | |
1479 } | |
1480 | |
1481 /** | |
1482 * @override | |
1483 * @return {boolean} | |
1484 */ | |
1485 onselect(selectedByUser) { | |
1486 super.onselect(selectedByUser); | |
1487 if (!this._view) | |
1488 this._view = new Resources.ClearStorageView(this._storagePanel); | |
1489 this._storagePanel._innerShowView(this._view); | |
1490 return false; | |
1491 } | |
1492 }; | |
1493 | |
1494 /** | |
1495 * @unrestricted | |
1496 */ | |
1497 Resources.IndexedDBTreeElement = class extends Resources.StorageCategoryTreeElem
ent { | |
1498 /** | |
1499 * @param {!Resources.ResourcesPanel} storagePanel | |
1500 */ | |
1501 constructor(storagePanel) { | |
1502 super(storagePanel, Common.UIString('IndexedDB'), 'IndexedDB'); | |
1503 var icon = UI.Icon.create('mediumicon-database', 'resource-tree-item'); | |
1504 this.setLeadingIcons([icon]); | |
1505 } | |
1506 | |
1507 _initialize() { | |
1508 SDK.targetManager.addModelListener( | |
1509 Resources.IndexedDBModel, Resources.IndexedDBModel.Events.DatabaseAdded,
this._indexedDBAdded, this); | |
1510 SDK.targetManager.addModelListener( | |
1511 Resources.IndexedDBModel, Resources.IndexedDBModel.Events.DatabaseRemove
d, this._indexedDBRemoved, this); | |
1512 SDK.targetManager.addModelListener( | |
1513 Resources.IndexedDBModel, Resources.IndexedDBModel.Events.DatabaseLoaded
, this._indexedDBLoaded, this); | |
1514 /** @type {!Array.<!Resources.IDBDatabaseTreeElement>} */ | |
1515 this._idbDatabaseTreeElements = []; | |
1516 | |
1517 var targets = SDK.targetManager.targets(SDK.Target.Capability.Browser); | |
1518 for (var i = 0; i < targets.length; ++i) { | |
1519 var indexedDBModel = Resources.IndexedDBModel.fromTarget(targets[i]); | |
1520 var databases = indexedDBModel.databases(); | |
1521 for (var j = 0; j < databases.length; ++j) | |
1522 this._addIndexedDB(indexedDBModel, databases[j]); | |
1523 } | |
1524 } | |
1525 | |
1526 /** | |
1527 * @override | |
1528 */ | |
1529 onattach() { | |
1530 super.onattach(); | |
1531 this.listItemElement.addEventListener('contextmenu', this._handleContextMenu
Event.bind(this), true); | |
1532 } | |
1533 | |
1534 _handleContextMenuEvent(event) { | |
1535 var contextMenu = new UI.ContextMenu(event); | |
1536 contextMenu.appendItem(Common.UIString('Refresh IndexedDB'), this.refreshInd
exedDB.bind(this)); | |
1537 contextMenu.show(); | |
1538 } | |
1539 | |
1540 refreshIndexedDB() { | |
1541 var targets = SDK.targetManager.targets(SDK.Target.Capability.Browser); | |
1542 for (var i = 0; i < targets.length; ++i) | |
1543 Resources.IndexedDBModel.fromTarget(targets[i]).refreshDatabaseNames(); | |
1544 } | |
1545 | |
1546 /** | |
1547 * @param {!Common.Event} event | |
1548 */ | |
1549 _indexedDBAdded(event) { | |
1550 var databaseId = /** @type {!Resources.IndexedDBModel.DatabaseId} */ (event.
data.databaseId); | |
1551 var model = /** @type {!Resources.IndexedDBModel} */ (event.data.model); | |
1552 this._addIndexedDB(model, databaseId); | |
1553 } | |
1554 | |
1555 /** | |
1556 * @param {!Resources.IndexedDBModel} model | |
1557 * @param {!Resources.IndexedDBModel.DatabaseId} databaseId | |
1558 */ | |
1559 _addIndexedDB(model, databaseId) { | |
1560 var idbDatabaseTreeElement = new Resources.IDBDatabaseTreeElement(this._stor
agePanel, model, databaseId); | |
1561 this._idbDatabaseTreeElements.push(idbDatabaseTreeElement); | |
1562 this.appendChild(idbDatabaseTreeElement); | |
1563 model.refreshDatabase(databaseId); | |
1564 } | |
1565 | |
1566 /** | |
1567 * @param {!Common.Event} event | |
1568 */ | |
1569 _indexedDBRemoved(event) { | |
1570 var databaseId = /** @type {!Resources.IndexedDBModel.DatabaseId} */ (event.
data.databaseId); | |
1571 var model = /** @type {!Resources.IndexedDBModel} */ (event.data.model); | |
1572 | |
1573 var idbDatabaseTreeElement = this._idbDatabaseTreeElement(model, databaseId)
; | |
1574 if (!idbDatabaseTreeElement) | |
1575 return; | |
1576 | |
1577 idbDatabaseTreeElement.clear(); | |
1578 this.removeChild(idbDatabaseTreeElement); | |
1579 this._idbDatabaseTreeElements.remove(idbDatabaseTreeElement); | |
1580 } | |
1581 | |
1582 /** | |
1583 * @param {!Common.Event} event | |
1584 */ | |
1585 _indexedDBLoaded(event) { | |
1586 var database = /** @type {!Resources.IndexedDBModel.Database} */ (event.data
.database); | |
1587 var model = /** @type {!Resources.IndexedDBModel} */ (event.data.model); | |
1588 | |
1589 var idbDatabaseTreeElement = this._idbDatabaseTreeElement(model, database.da
tabaseId); | |
1590 if (!idbDatabaseTreeElement) | |
1591 return; | |
1592 | |
1593 idbDatabaseTreeElement.update(database); | |
1594 } | |
1595 | |
1596 /** | |
1597 * @param {!Resources.IndexedDBModel.DatabaseId} databaseId | |
1598 * @param {!Resources.IndexedDBModel} model | |
1599 * @return {?Resources.IDBDatabaseTreeElement} | |
1600 */ | |
1601 _idbDatabaseTreeElement(model, databaseId) { | |
1602 var index = -1; | |
1603 for (var i = 0; i < this._idbDatabaseTreeElements.length; ++i) { | |
1604 if (this._idbDatabaseTreeElements[i]._databaseId.equals(databaseId) && | |
1605 this._idbDatabaseTreeElements[i]._model === model) { | |
1606 index = i; | |
1607 break; | |
1608 } | |
1609 } | |
1610 if (index !== -1) | |
1611 return this._idbDatabaseTreeElements[i]; | |
1612 return null; | |
1613 } | |
1614 }; | |
1615 | |
1616 /** | |
1617 * @unrestricted | |
1618 */ | |
1619 Resources.IDBDatabaseTreeElement = class extends Resources.BaseStorageTreeElemen
t { | |
1620 /** | |
1621 * @param {!Resources.ResourcesPanel} storagePanel | |
1622 * @param {!Resources.IndexedDBModel} model | |
1623 * @param {!Resources.IndexedDBModel.DatabaseId} databaseId | |
1624 */ | |
1625 constructor(storagePanel, model, databaseId) { | |
1626 super(storagePanel, databaseId.name + ' - ' + databaseId.securityOrigin, fal
se); | |
1627 this._model = model; | |
1628 this._databaseId = databaseId; | |
1629 this._idbObjectStoreTreeElements = {}; | |
1630 var icon = UI.Icon.create('mediumicon-database', 'resource-tree-item'); | |
1631 this.setLeadingIcons([icon]); | |
1632 } | |
1633 | |
1634 get itemURL() { | |
1635 return 'indexedDB://' + this._databaseId.securityOrigin + '/' + this._databa
seId.name; | |
1636 } | |
1637 | |
1638 /** | |
1639 * @override | |
1640 */ | |
1641 onattach() { | |
1642 super.onattach(); | |
1643 this.listItemElement.addEventListener('contextmenu', this._handleContextMenu
Event.bind(this), true); | |
1644 } | |
1645 | |
1646 _handleContextMenuEvent(event) { | |
1647 var contextMenu = new UI.ContextMenu(event); | |
1648 contextMenu.appendItem(Common.UIString('Refresh IndexedDB'), this._refreshIn
dexedDB.bind(this)); | |
1649 contextMenu.show(); | |
1650 } | |
1651 | |
1652 _refreshIndexedDB() { | |
1653 this._model.refreshDatabaseNames(); | |
1654 } | |
1655 | |
1656 /** | |
1657 * @param {!Resources.IndexedDBModel.Database} database | |
1658 */ | |
1659 update(database) { | |
1660 this._database = database; | |
1661 var objectStoreNames = {}; | |
1662 for (var objectStoreName in this._database.objectStores) { | |
1663 var objectStore = this._database.objectStores[objectStoreName]; | |
1664 objectStoreNames[objectStore.name] = true; | |
1665 if (!this._idbObjectStoreTreeElements[objectStore.name]) { | |
1666 var idbObjectStoreTreeElement = | |
1667 new Resources.IDBObjectStoreTreeElement(this._storagePanel, this._mo
del, this._databaseId, objectStore); | |
1668 this._idbObjectStoreTreeElements[objectStore.name] = idbObjectStoreTreeE
lement; | |
1669 this.appendChild(idbObjectStoreTreeElement); | |
1670 } | |
1671 this._idbObjectStoreTreeElements[objectStore.name].update(objectStore); | |
1672 } | |
1673 for (var objectStoreName in this._idbObjectStoreTreeElements) { | |
1674 if (!objectStoreNames[objectStoreName]) | |
1675 this._objectStoreRemoved(objectStoreName); | |
1676 } | |
1677 | |
1678 if (this._view) | |
1679 this._view.update(database); | |
1680 | |
1681 this._updateTooltip(); | |
1682 } | |
1683 | |
1684 _updateTooltip() { | |
1685 this.tooltip = Common.UIString('Version') + ': ' + this._database.version; | |
1686 } | |
1687 | |
1688 /** | |
1689 * @override | |
1690 * @return {boolean} | |
1691 */ | |
1692 onselect(selectedByUser) { | |
1693 super.onselect(selectedByUser); | |
1694 if (!this._view) | |
1695 this._view = new Resources.IDBDatabaseView(this._model, this._database); | |
1696 | |
1697 this._storagePanel._innerShowView(this._view); | |
1698 return false; | |
1699 } | |
1700 | |
1701 /** | |
1702 * @param {string} objectStoreName | |
1703 */ | |
1704 _objectStoreRemoved(objectStoreName) { | |
1705 var objectStoreTreeElement = this._idbObjectStoreTreeElements[objectStoreNam
e]; | |
1706 objectStoreTreeElement.clear(); | |
1707 this.removeChild(objectStoreTreeElement); | |
1708 delete this._idbObjectStoreTreeElements[objectStoreName]; | |
1709 } | |
1710 | |
1711 clear() { | |
1712 for (var objectStoreName in this._idbObjectStoreTreeElements) | |
1713 this._objectStoreRemoved(objectStoreName); | |
1714 } | |
1715 }; | |
1716 | |
1717 /** | |
1718 * @unrestricted | |
1719 */ | |
1720 Resources.IDBObjectStoreTreeElement = class extends Resources.BaseStorageTreeEle
ment { | |
1721 /** | |
1722 * @param {!Resources.ResourcesPanel} storagePanel | |
1723 * @param {!Resources.IndexedDBModel} model | |
1724 * @param {!Resources.IndexedDBModel.DatabaseId} databaseId | |
1725 * @param {!Resources.IndexedDBModel.ObjectStore} objectStore | |
1726 */ | |
1727 constructor(storagePanel, model, databaseId, objectStore) { | |
1728 super(storagePanel, objectStore.name, false); | |
1729 this._model = model; | |
1730 this._databaseId = databaseId; | |
1731 this._idbIndexTreeElements = {}; | |
1732 var icon = UI.Icon.create('mediumicon-table', 'resource-tree-item'); | |
1733 this.setLeadingIcons([icon]); | |
1734 } | |
1735 | |
1736 get itemURL() { | |
1737 return 'indexedDB://' + this._databaseId.securityOrigin + '/' + this._databa
seId.name + '/' + | |
1738 this._objectStore.name; | |
1739 } | |
1740 | |
1741 /** | |
1742 * @override | |
1743 */ | |
1744 onattach() { | |
1745 super.onattach(); | |
1746 this.listItemElement.addEventListener('contextmenu', this._handleContextMenu
Event.bind(this), true); | |
1747 } | |
1748 | |
1749 _handleContextMenuEvent(event) { | |
1750 var contextMenu = new UI.ContextMenu(event); | |
1751 contextMenu.appendItem(Common.UIString('Clear'), this._clearObjectStore.bind
(this)); | |
1752 contextMenu.show(); | |
1753 } | |
1754 | |
1755 _clearObjectStore() { | |
1756 /** | |
1757 * @this {Resources.IDBObjectStoreTreeElement} | |
1758 */ | |
1759 function callback() { | |
1760 this.update(this._objectStore); | |
1761 } | |
1762 this._model.clearObjectStore(this._databaseId, this._objectStore.name, callb
ack.bind(this)); | |
1763 } | |
1764 | |
1765 /** | |
1766 * @param {!Resources.IndexedDBModel.ObjectStore} objectStore | |
1767 */ | |
1768 update(objectStore) { | |
1769 this._objectStore = objectStore; | |
1770 | |
1771 var indexNames = {}; | |
1772 for (var indexName in this._objectStore.indexes) { | |
1773 var index = this._objectStore.indexes[indexName]; | |
1774 indexNames[index.name] = true; | |
1775 if (!this._idbIndexTreeElements[index.name]) { | |
1776 var idbIndexTreeElement = new Resources.IDBIndexTreeElement( | |
1777 this._storagePanel, this._model, this._databaseId, this._objectStore
, index); | |
1778 this._idbIndexTreeElements[index.name] = idbIndexTreeElement; | |
1779 this.appendChild(idbIndexTreeElement); | |
1780 } | |
1781 this._idbIndexTreeElements[index.name].update(index); | |
1782 } | |
1783 for (var indexName in this._idbIndexTreeElements) { | |
1784 if (!indexNames[indexName]) | |
1785 this._indexRemoved(indexName); | |
1786 } | |
1787 for (var indexName in this._idbIndexTreeElements) { | |
1788 if (!indexNames[indexName]) { | |
1789 this.removeChild(this._idbIndexTreeElements[indexName]); | |
1790 delete this._idbIndexTreeElements[indexName]; | |
1791 } | |
1792 } | |
1793 | |
1794 if (this.childCount()) | |
1795 this.expand(); | |
1796 | |
1797 if (this._view) | |
1798 this._view.update(this._objectStore); | |
1799 | |
1800 this._updateTooltip(); | |
1801 } | |
1802 | |
1803 _updateTooltip() { | |
1804 var keyPathString = this._objectStore.keyPathString; | |
1805 var tooltipString = keyPathString !== null ? (Common.UIString('Key path: ')
+ keyPathString) : ''; | |
1806 if (this._objectStore.autoIncrement) | |
1807 tooltipString += '\n' + Common.UIString('autoIncrement'); | |
1808 this.tooltip = tooltipString; | |
1809 } | |
1810 | |
1811 /** | |
1812 * @override | |
1813 * @return {boolean} | |
1814 */ | |
1815 onselect(selectedByUser) { | |
1816 super.onselect(selectedByUser); | |
1817 if (!this._view) | |
1818 this._view = new Resources.IDBDataView(this._model, this._databaseId, this
._objectStore, null); | |
1819 | |
1820 this._storagePanel._innerShowView(this._view); | |
1821 return false; | |
1822 } | |
1823 | |
1824 /** | |
1825 * @param {string} indexName | |
1826 */ | |
1827 _indexRemoved(indexName) { | |
1828 var indexTreeElement = this._idbIndexTreeElements[indexName]; | |
1829 indexTreeElement.clear(); | |
1830 this.removeChild(indexTreeElement); | |
1831 delete this._idbIndexTreeElements[indexName]; | |
1832 } | |
1833 | |
1834 clear() { | |
1835 for (var indexName in this._idbIndexTreeElements) | |
1836 this._indexRemoved(indexName); | |
1837 if (this._view) | |
1838 this._view.clear(); | |
1839 } | |
1840 }; | |
1841 | |
1842 /** | |
1843 * @unrestricted | |
1844 */ | |
1845 Resources.IDBIndexTreeElement = class extends Resources.BaseStorageTreeElement { | |
1846 /** | |
1847 * @param {!Resources.ResourcesPanel} storagePanel | |
1848 * @param {!Resources.IndexedDBModel} model | |
1849 * @param {!Resources.IndexedDBModel.DatabaseId} databaseId | |
1850 * @param {!Resources.IndexedDBModel.ObjectStore} objectStore | |
1851 * @param {!Resources.IndexedDBModel.Index} index | |
1852 */ | |
1853 constructor(storagePanel, model, databaseId, objectStore, index) { | |
1854 super(storagePanel, index.name, false); | |
1855 this._model = model; | |
1856 this._databaseId = databaseId; | |
1857 this._objectStore = objectStore; | |
1858 this._index = index; | |
1859 } | |
1860 | |
1861 get itemURL() { | |
1862 return 'indexedDB://' + this._databaseId.securityOrigin + '/' + this._databa
seId.name + '/' + | |
1863 this._objectStore.name + '/' + this._index.name; | |
1864 } | |
1865 | |
1866 /** | |
1867 * @param {!Resources.IndexedDBModel.Index} index | |
1868 */ | |
1869 update(index) { | |
1870 this._index = index; | |
1871 | |
1872 if (this._view) | |
1873 this._view.update(this._index); | |
1874 | |
1875 this._updateTooltip(); | |
1876 } | |
1877 | |
1878 _updateTooltip() { | |
1879 var tooltipLines = []; | |
1880 var keyPathString = this._index.keyPathString; | |
1881 tooltipLines.push(Common.UIString('Key path: ') + keyPathString); | |
1882 if (this._index.unique) | |
1883 tooltipLines.push(Common.UIString('unique')); | |
1884 if (this._index.multiEntry) | |
1885 tooltipLines.push(Common.UIString('multiEntry')); | |
1886 this.tooltip = tooltipLines.join('\n'); | |
1887 } | |
1888 | |
1889 /** | |
1890 * @override | |
1891 * @return {boolean} | |
1892 */ | |
1893 onselect(selectedByUser) { | |
1894 super.onselect(selectedByUser); | |
1895 if (!this._view) | |
1896 this._view = new Resources.IDBDataView(this._model, this._databaseId, this
._objectStore, this._index); | |
1897 | |
1898 this._storagePanel._innerShowView(this._view); | |
1899 return false; | |
1900 } | |
1901 | |
1902 clear() { | |
1903 if (this._view) | |
1904 this._view.clear(); | |
1905 } | |
1906 }; | |
1907 | |
1908 /** | |
1909 * @unrestricted | |
1910 */ | |
1911 Resources.DOMStorageTreeElement = class extends Resources.BaseStorageTreeElement
{ | |
1912 constructor(storagePanel, domStorage) { | |
1913 super(storagePanel, domStorage.securityOrigin ? domStorage.securityOrigin :
Common.UIString('Local Files'), false); | |
1914 this._domStorage = domStorage; | |
1915 var icon = UI.Icon.create('mediumicon-table', 'resource-tree-item'); | |
1916 this.setLeadingIcons([icon]); | |
1917 } | |
1918 | |
1919 get itemURL() { | |
1920 return 'storage://' + this._domStorage.securityOrigin + '/' + | |
1921 (this._domStorage.isLocalStorage ? 'local' : 'session'); | |
1922 } | |
1923 | |
1924 /** | |
1925 * @override | |
1926 * @return {boolean} | |
1927 */ | |
1928 onselect(selectedByUser) { | |
1929 super.onselect(selectedByUser); | |
1930 this._storagePanel._showDOMStorage(this._domStorage); | |
1931 return false; | |
1932 } | |
1933 | |
1934 /** | |
1935 * @override | |
1936 */ | |
1937 onattach() { | |
1938 super.onattach(); | |
1939 this.listItemElement.addEventListener('contextmenu', this._handleContextMenu
Event.bind(this), true); | |
1940 } | |
1941 | |
1942 _handleContextMenuEvent(event) { | |
1943 var contextMenu = new UI.ContextMenu(event); | |
1944 contextMenu.appendItem(Common.UIString('Clear'), () => this._domStorage.clea
r()); | |
1945 contextMenu.show(); | |
1946 } | |
1947 }; | |
1948 | |
1949 Resources.CookieTreeElement = class extends Resources.BaseStorageTreeElement { | |
1950 /** | |
1951 * @param {!Resources.ResourcesPanel} storagePanel | |
1952 * @param {!SDK.ResourceTreeFrame} frame | |
1953 * @param {string} cookieDomain | |
1954 */ | |
1955 constructor(storagePanel, frame, cookieDomain) { | |
1956 super(storagePanel, cookieDomain ? cookieDomain : Common.UIString('Local Fil
es'), false); | |
1957 this._target = frame.target(); | |
1958 this._cookieDomain = cookieDomain; | |
1959 var icon = UI.Icon.create('mediumicon-cookie', 'resource-tree-item'); | |
1960 this.setLeadingIcons([icon]); | |
1961 } | |
1962 | |
1963 get itemURL() { | |
1964 return 'cookies://' + this._cookieDomain; | |
1965 } | |
1966 | |
1967 /** | |
1968 * @override | |
1969 */ | |
1970 onattach() { | |
1971 super.onattach(); | |
1972 this.listItemElement.addEventListener('contextmenu', this._handleContextMenu
Event.bind(this), true); | |
1973 } | |
1974 | |
1975 /** | |
1976 * @param {!Event} event | |
1977 */ | |
1978 _handleContextMenuEvent(event) { | |
1979 var contextMenu = new UI.ContextMenu(event); | |
1980 contextMenu.appendItem( | |
1981 Common.UIString('Clear'), () => this._storagePanel._clearCookies(this._t
arget, this._cookieDomain)); | |
1982 contextMenu.show(); | |
1983 } | |
1984 | |
1985 /** | |
1986 * @override | |
1987 * @return {boolean} | |
1988 */ | |
1989 onselect(selectedByUser) { | |
1990 super.onselect(selectedByUser); | |
1991 this._storagePanel.showCookies(this, this._cookieDomain, this._target); | |
1992 return false; | |
1993 } | |
1994 }; | |
1995 | |
1996 /** | |
1997 * @unrestricted | |
1998 */ | |
1999 Resources.ApplicationCacheManifestTreeElement = class extends Resources.BaseStor
ageTreeElement { | |
2000 constructor(storagePanel, manifestURL) { | |
2001 var title = new Common.ParsedURL(manifestURL).displayName; | |
2002 super(storagePanel, title, false); | |
2003 this.tooltip = manifestURL; | |
2004 this._manifestURL = manifestURL; | |
2005 } | |
2006 | |
2007 get itemURL() { | |
2008 return 'appcache://' + this._manifestURL; | |
2009 } | |
2010 | |
2011 get manifestURL() { | |
2012 return this._manifestURL; | |
2013 } | |
2014 | |
2015 /** | |
2016 * @override | |
2017 * @return {boolean} | |
2018 */ | |
2019 onselect(selectedByUser) { | |
2020 super.onselect(selectedByUser); | |
2021 this._storagePanel.showCategoryView(this._manifestURL); | |
2022 return false; | |
2023 } | |
2024 }; | |
2025 | |
2026 /** | |
2027 * @unrestricted | |
2028 */ | |
2029 Resources.ApplicationCacheFrameTreeElement = class extends Resources.BaseStorage
TreeElement { | |
2030 /** | |
2031 * @param {!Resources.ResourcesPanel} storagePanel | |
2032 * @param {!Protocol.Page.FrameId} frameId | |
2033 * @param {string} manifestURL | |
2034 */ | |
2035 constructor(storagePanel, frameId, manifestURL) { | |
2036 super(storagePanel, '', false); | |
2037 this._frameId = frameId; | |
2038 this._manifestURL = manifestURL; | |
2039 this._refreshTitles(); | |
2040 | |
2041 var icon = UI.Icon.create('largeicon-navigator-folder', 'navigator-tree-item
'); | |
2042 icon.classList.add('navigator-folder-tree-item'); | |
2043 this.setLeadingIcons([icon]); | |
2044 } | |
2045 | |
2046 get itemURL() { | |
2047 return 'appcache://' + this._manifestURL + '/' + encodeURI(this.titleAsText(
)); | |
2048 } | |
2049 | |
2050 get frameId() { | |
2051 return this._frameId; | |
2052 } | |
2053 | |
2054 get manifestURL() { | |
2055 return this._manifestURL; | |
2056 } | |
2057 | |
2058 _refreshTitles() { | |
2059 var resourceTreeModel = SDK.ResourceTreeModel.fromTarget(this._storagePanel.
_target); | |
2060 var frame = resourceTreeModel.frameForId(this._frameId); | |
2061 this.title = frame.displayName(); | |
2062 } | |
2063 | |
2064 frameNavigated() { | |
2065 this._refreshTitles(); | |
2066 } | |
2067 | |
2068 /** | |
2069 * @override | |
2070 * @return {boolean} | |
2071 */ | |
2072 onselect(selectedByUser) { | |
2073 super.onselect(selectedByUser); | |
2074 this._storagePanel.showApplicationCache(this._frameId); | |
2075 return false; | |
2076 } | |
2077 }; | |
2078 | |
2079 /** | |
2080 * @unrestricted | |
2081 */ | |
2082 Resources.StorageCategoryView = class extends UI.VBox { | |
2083 constructor() { | |
2084 super(); | |
2085 | |
2086 this.element.classList.add('storage-view'); | |
2087 this._emptyWidget = new UI.EmptyWidget(''); | |
2088 this._emptyWidget.show(this.element); | |
2089 } | |
2090 | |
2091 setText(text) { | |
2092 this._emptyWidget.text = text; | |
2093 } | |
2094 }; | |
OLD | NEW |