1/*
2 * Copyright (C) 2012 Google Inc. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
6 * met:
7 *
8 *     * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 *     * Redistributions in binary form must reproduce the above
11 * copyright notice, this list of conditions and the following disclaimer
12 * in the documentation and/or other materials provided with the
13 * distribution.
14 *     * Neither the name of Google Inc. nor the names of its
15 * contributors may be used to endorse or promote products derived from
16 * this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31/**
32 * @constructor
33 * @extends {WebInspector.PanelWithSidebarTree}
34 */
35WebInspector.AuditsPanel = function()
36{
37    WebInspector.PanelWithSidebarTree.call(this, "audits");
38    this.registerRequiredCSS("panelEnablerView.css");
39    this.registerRequiredCSS("auditsPanel.css");
40
41    this.auditsTreeElement = new WebInspector.SidebarSectionTreeElement("", {}, true);
42    this.sidebarTree.appendChild(this.auditsTreeElement);
43    this.auditsTreeElement.listItemElement.classList.add("hidden");
44
45    this.auditsItemTreeElement = new WebInspector.AuditsSidebarTreeElement(this);
46    this.auditsTreeElement.appendChild(this.auditsItemTreeElement);
47
48    this.auditResultsTreeElement = new WebInspector.SidebarSectionTreeElement(WebInspector.UIString("RESULTS"), {}, true);
49    this.sidebarTree.appendChild(this.auditResultsTreeElement);
50    this.auditResultsTreeElement.expand();
51
52    this._constructCategories();
53
54    this._auditController = new WebInspector.AuditController(this);
55    this._launcherView = new WebInspector.AuditLauncherView(this._auditController);
56    for (var id in this.categoriesById)
57        this._launcherView.addCategory(this.categoriesById[id]);
58}
59
60WebInspector.AuditsPanel.prototype = {
61    /**
62     * @return {boolean}
63     */
64    canSearch: function()
65    {
66        return false;
67    },
68
69    /**
70     * @return {!Object.<string, !WebInspector.AuditCategory>}
71     */
72    get categoriesById()
73    {
74        return this._auditCategoriesById;
75    },
76
77    /**
78     * @param {!WebInspector.AuditCategory} category
79     */
80    addCategory: function(category)
81    {
82        this.categoriesById[category.id] = category;
83        this._launcherView.addCategory(category);
84    },
85
86    /**
87     * @param {string} id
88     * @return {!WebInspector.AuditCategory}
89     */
90    getCategory: function(id)
91    {
92        return this.categoriesById[id];
93    },
94
95    _constructCategories: function()
96    {
97        this._auditCategoriesById = {};
98        for (var categoryCtorID in WebInspector.AuditCategories) {
99            var auditCategory = new WebInspector.AuditCategories[categoryCtorID]();
100            auditCategory._id = categoryCtorID;
101            this.categoriesById[categoryCtorID] = auditCategory;
102        }
103    },
104
105    /**
106     * @param {string} mainResourceURL
107     * @param {!Array.<!WebInspector.AuditCategoryResult>} results
108     */
109    auditFinishedCallback: function(mainResourceURL, results)
110    {
111        var children = this.auditResultsTreeElement.children;
112        var ordinal = 1;
113        for (var i = 0; i < children.length; ++i) {
114            if (children[i].mainResourceURL === mainResourceURL)
115                ordinal++;
116        }
117
118        var resultTreeElement = new WebInspector.AuditResultSidebarTreeElement(this, results, mainResourceURL, ordinal);
119        this.auditResultsTreeElement.appendChild(resultTreeElement);
120        resultTreeElement.revealAndSelect();
121    },
122
123    /**
124     * @param {!Array.<!WebInspector.AuditCategoryResult>} categoryResults
125     */
126    showResults: function(categoryResults)
127    {
128        if (!categoryResults._resultView)
129            categoryResults._resultView = new WebInspector.AuditResultView(categoryResults);
130
131        this.visibleView = categoryResults._resultView;
132    },
133
134    showLauncherView: function()
135    {
136        this.visibleView = this._launcherView;
137    },
138
139    get visibleView()
140    {
141        return this._visibleView;
142    },
143
144    set visibleView(x)
145    {
146        if (this._visibleView === x)
147            return;
148
149        if (this._visibleView)
150            this._visibleView.detach();
151
152        this._visibleView = x;
153
154        if (x)
155            x.show(this.mainElement());
156    },
157
158    wasShown: function()
159    {
160        WebInspector.Panel.prototype.wasShown.call(this);
161        if (!this._visibleView)
162            this.auditsItemTreeElement.select();
163    },
164
165    clearResults: function()
166    {
167        this.auditsItemTreeElement.revealAndSelect();
168        this.auditResultsTreeElement.removeChildren();
169    },
170
171    __proto__: WebInspector.PanelWithSidebarTree.prototype
172}
173
174/**
175 * @constructor
176 * @implements {WebInspector.AuditCategory}
177 * @param {string} displayName
178 */
179WebInspector.AuditCategoryImpl = function(displayName)
180{
181    this._displayName = displayName;
182    this._rules = [];
183}
184
185WebInspector.AuditCategoryImpl.prototype = {
186    /**
187     * @override
188     * @return {string}
189     */
190    get id()
191    {
192        // this._id value is injected at construction time.
193        return this._id;
194    },
195
196    /**
197     * @override
198     * @return {string}
199     */
200    get displayName()
201    {
202        return this._displayName;
203    },
204
205    /**
206     * @param {!WebInspector.AuditRule} rule
207     * @param {!WebInspector.AuditRule.Severity} severity
208     */
209    addRule: function(rule, severity)
210    {
211        rule.severity = severity;
212        this._rules.push(rule);
213    },
214
215    /**
216     * @override
217     * @param {!WebInspector.Target} target
218     * @param {!Array.<!WebInspector.NetworkRequest>} requests
219     * @param {function(!WebInspector.AuditRuleResult)} ruleResultCallback
220     * @param {function()} categoryDoneCallback
221     * @param {!WebInspector.Progress} progress
222     */
223    run: function(target, requests, ruleResultCallback, categoryDoneCallback, progress)
224    {
225        this._ensureInitialized();
226        var remainingRulesCount = this._rules.length;
227        progress.setTotalWork(remainingRulesCount);
228        function callbackWrapper(result)
229        {
230            ruleResultCallback(result);
231            progress.worked();
232            if (!--remainingRulesCount)
233                categoryDoneCallback();
234        }
235        for (var i = 0; i < this._rules.length; ++i)
236            this._rules[i].run(target, requests, callbackWrapper, progress);
237    },
238
239    _ensureInitialized: function()
240    {
241        if (!this._initialized) {
242            if ("initialize" in this)
243                this.initialize();
244            this._initialized = true;
245        }
246    }
247}
248
249/**
250 * @constructor
251 * @param {string} id
252 * @param {string} displayName
253 */
254WebInspector.AuditRule = function(id, displayName)
255{
256    this._id = id;
257    this._displayName = displayName;
258}
259
260/**
261 * @enum {string}
262 */
263WebInspector.AuditRule.Severity = {
264    Info: "info",
265    Warning: "warning",
266    Severe: "severe"
267}
268
269WebInspector.AuditRule.SeverityOrder = {
270    "info": 3,
271    "warning": 2,
272    "severe": 1
273}
274
275WebInspector.AuditRule.prototype = {
276    get id()
277    {
278        return this._id;
279    },
280
281    get displayName()
282    {
283        return this._displayName;
284    },
285
286    /**
287     * @param {!WebInspector.AuditRule.Severity} severity
288     */
289    set severity(severity)
290    {
291        this._severity = severity;
292    },
293
294    /**
295     * @param {!WebInspector.Target} target
296     * @param {!Array.<!WebInspector.NetworkRequest>} requests
297     * @param {function(!WebInspector.AuditRuleResult)} callback
298     * @param {!WebInspector.Progress} progress
299     */
300    run: function(target, requests, callback, progress)
301    {
302        if (progress.isCanceled())
303            return;
304
305        var result = new WebInspector.AuditRuleResult(this.displayName);
306        result.severity = this._severity;
307        this.doRun(target, requests, result, callback, progress);
308    },
309
310    /**
311     * @param {!WebInspector.Target} target
312     * @param {!Array.<!WebInspector.NetworkRequest>} requests
313     * @param {!WebInspector.AuditRuleResult} result
314     * @param {function(!WebInspector.AuditRuleResult)} callback
315     * @param {!WebInspector.Progress} progress
316     */
317    doRun: function(target, requests, result, callback, progress)
318    {
319        throw new Error("doRun() not implemented");
320    }
321}
322
323/**
324 * @constructor
325 * @param {!WebInspector.AuditCategory} category
326 */
327WebInspector.AuditCategoryResult = function(category)
328{
329    this.title = category.displayName;
330    this.ruleResults = [];
331}
332
333WebInspector.AuditCategoryResult.prototype = {
334    /**
335     * @param {!WebInspector.AuditRuleResult} ruleResult
336     */
337    addRuleResult: function(ruleResult)
338    {
339        this.ruleResults.push(ruleResult);
340    }
341}
342
343/**
344 * @constructor
345 * @param {(string|boolean|number|!Object)} value
346 * @param {boolean=} expanded
347 * @param {string=} className
348 */
349WebInspector.AuditRuleResult = function(value, expanded, className)
350{
351    this.value = value;
352    this.className = className;
353    this.expanded = expanded;
354    this.violationCount = 0;
355    this._formatters = {
356        r: WebInspector.AuditRuleResult.linkifyDisplayName
357    };
358    var standardFormatters = Object.keys(String.standardFormatters);
359    for (var i = 0; i < standardFormatters.length; ++i)
360        this._formatters[standardFormatters[i]] = String.standardFormatters[standardFormatters[i]];
361}
362
363/**
364 * @param {string} url
365 * @return {!Element}
366 */
367WebInspector.AuditRuleResult.linkifyDisplayName = function(url)
368{
369    return WebInspector.linkifyURLAsNode(url, WebInspector.displayNameForURL(url));
370}
371
372/**
373 * @param {string} domain
374 * @return {string}
375 */
376WebInspector.AuditRuleResult.resourceDomain = function(domain)
377{
378    return domain || WebInspector.UIString("[empty domain]");
379}
380
381WebInspector.AuditRuleResult.prototype = {
382    /**
383     * @param {(string|boolean|number|!Object)} value
384     * @param {boolean=} expanded
385     * @param {string=} className
386     * @return {!WebInspector.AuditRuleResult}
387     */
388    addChild: function(value, expanded, className)
389    {
390        if (!this.children)
391            this.children = [];
392        var entry = new WebInspector.AuditRuleResult(value, expanded, className);
393        this.children.push(entry);
394        return entry;
395    },
396
397    /**
398     * @param {string} url
399     */
400    addURL: function(url)
401    {
402        this.addChild(WebInspector.AuditRuleResult.linkifyDisplayName(url));
403    },
404
405    /**
406     * @param {!Array.<string>} urls
407     */
408    addURLs: function(urls)
409    {
410        for (var i = 0; i < urls.length; ++i)
411            this.addURL(urls[i]);
412    },
413
414    /**
415     * @param {string} snippet
416     */
417    addSnippet: function(snippet)
418    {
419        this.addChild(snippet, false, "source-code");
420    },
421
422    /**
423     * @param {string} format
424     * @param {...*} vararg
425     * @return {!WebInspector.AuditRuleResult}
426     */
427    addFormatted: function(format, vararg)
428    {
429        var substitutions = Array.prototype.slice.call(arguments, 1);
430        var fragment = document.createDocumentFragment();
431
432        function append(a, b)
433        {
434            if (!(b instanceof Node))
435                b = document.createTextNode(b);
436            a.appendChild(b);
437            return a;
438        }
439
440        var formattedResult = String.format(format, substitutions, this._formatters, fragment, append).formattedResult;
441        if (formattedResult instanceof Node)
442            formattedResult.normalize();
443        return this.addChild(formattedResult);
444    }
445}
446
447/**
448 * @constructor
449 * @extends {WebInspector.SidebarTreeElement}
450 * @param {!WebInspector.AuditsPanel} panel
451 */
452WebInspector.AuditsSidebarTreeElement = function(panel)
453{
454    this._panel = panel;
455    this.small = false;
456    WebInspector.SidebarTreeElement.call(this, "audits-sidebar-tree-item", WebInspector.UIString("Audits"), "", null, false);
457}
458
459WebInspector.AuditsSidebarTreeElement.prototype = {
460    onattach: function()
461    {
462        WebInspector.SidebarTreeElement.prototype.onattach.call(this);
463    },
464
465    /**
466     * @return {boolean}
467     */
468    onselect: function()
469    {
470        this._panel.showLauncherView();
471        return true;
472    },
473
474    get selectable()
475    {
476        return true;
477    },
478
479    refresh: function()
480    {
481        this.refreshTitles();
482    },
483
484    __proto__: WebInspector.SidebarTreeElement.prototype
485}
486
487/**
488 * @constructor
489 * @extends {WebInspector.SidebarTreeElement}
490 * @param {!WebInspector.AuditsPanel} panel
491 * @param {!Array.<!WebInspector.AuditCategoryResult>} results
492 * @param {string} mainResourceURL
493 * @param {number} ordinal
494 */
495WebInspector.AuditResultSidebarTreeElement = function(panel, results, mainResourceURL, ordinal)
496{
497    this._panel = panel;
498    this.results = results;
499    this.mainResourceURL = mainResourceURL;
500    WebInspector.SidebarTreeElement.call(this, "audit-result-sidebar-tree-item", String.sprintf("%s (%d)", mainResourceURL, ordinal), "", {}, false);
501}
502
503WebInspector.AuditResultSidebarTreeElement.prototype = {
504    /**
505     * @return {boolean}
506     */
507    onselect: function()
508    {
509        this._panel.showResults(this.results);
510        return true;
511    },
512
513    get selectable()
514    {
515        return true;
516    },
517
518    __proto__: WebInspector.SidebarTreeElement.prototype
519}
520
521// Contributed audit rules should go into this namespace.
522WebInspector.AuditRules = {};
523
524/**
525 * Contributed audit categories should go into this namespace.
526 * @type {!Object.<string, function(new:WebInspector.AuditCategory)>}
527 */
528WebInspector.AuditCategories = {};
529