eff55e96fe18d8ca14d268ef13878f8ab3b3ec92
[WebKit-https.git] / Source / WebCore / inspector / front-end / utilities.js
1 /*
2  * Copyright (C) 2007 Apple 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
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer. 
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution. 
13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
14  *     its contributors may be used to endorse or promote products derived
15  *     from this software without specific prior written permission. 
16  *
17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  *
28  * Contains diff method based on Javascript Diff Algorithm By John Resig
29  * http://ejohn.org/files/jsdiff.js (released under the MIT license).
30  */
31
32 Function.prototype.bind = function(thisObject)
33 {
34     var func = this;
35     var args = Array.prototype.slice.call(arguments, 1);
36     function bound()
37     {
38         return func.apply(thisObject, args.concat(Array.prototype.slice.call(arguments, 0)));
39     }
40     bound.toString = function() {
41         return "bound: " + func;
42     };
43     return bound;
44 }
45
46 Node.prototype.rangeOfWord = function(offset, stopCharacters, stayWithinNode, direction)
47 {
48     var startNode;
49     var startOffset = 0;
50     var endNode;
51     var endOffset = 0;
52
53     if (!stayWithinNode)
54         stayWithinNode = this;
55
56     if (!direction || direction === "backward" || direction === "both") {
57         var node = this;
58         while (node) {
59             if (node === stayWithinNode) {
60                 if (!startNode)
61                     startNode = stayWithinNode;
62                 break;
63             }
64
65             if (node.nodeType === Node.TEXT_NODE) {
66                 var start = (node === this ? (offset - 1) : (node.nodeValue.length - 1));
67                 for (var i = start; i >= 0; --i) {
68                     if (stopCharacters.indexOf(node.nodeValue[i]) !== -1) {
69                         startNode = node;
70                         startOffset = i + 1;
71                         break;
72                     }
73                 }
74             }
75
76             if (startNode)
77                 break;
78
79             node = node.traversePreviousNode(stayWithinNode);
80         }
81
82         if (!startNode) {
83             startNode = stayWithinNode;
84             startOffset = 0;
85         }
86     } else {
87         startNode = this;
88         startOffset = offset;
89     }
90
91     if (!direction || direction === "forward" || direction === "both") {
92         node = this;
93         while (node) {
94             if (node === stayWithinNode) {
95                 if (!endNode)
96                     endNode = stayWithinNode;
97                 break;
98             }
99
100             if (node.nodeType === Node.TEXT_NODE) {
101                 var start = (node === this ? offset : 0);
102                 for (var i = start; i < node.nodeValue.length; ++i) {
103                     if (stopCharacters.indexOf(node.nodeValue[i]) !== -1) {
104                         endNode = node;
105                         endOffset = i;
106                         break;
107                     }
108                 }
109             }
110
111             if (endNode)
112                 break;
113
114             node = node.traverseNextNode(stayWithinNode);
115         }
116
117         if (!endNode) {
118             endNode = stayWithinNode;
119             endOffset = stayWithinNode.nodeType === Node.TEXT_NODE ? stayWithinNode.nodeValue.length : stayWithinNode.childNodes.length;
120         }
121     } else {
122         endNode = this;
123         endOffset = offset;
124     }
125
126     var result = this.ownerDocument.createRange();
127     result.setStart(startNode, startOffset);
128     result.setEnd(endNode, endOffset);
129
130     return result;
131 }
132
133 Node.prototype.traverseNextTextNode = function(stayWithin)
134 {
135     var node = this.traverseNextNode(stayWithin);
136     if (!node)
137         return;
138
139     while (node && node.nodeType !== Node.TEXT_NODE)
140         node = node.traverseNextNode(stayWithin);
141
142     return node;
143 }
144
145 Node.prototype.rangeBoundaryForOffset = function(offset)
146 {
147     var node = this.traverseNextTextNode(this);
148     while (node && offset > node.nodeValue.length) {
149         offset -= node.nodeValue.length;
150         node = node.traverseNextTextNode(this);
151     }
152     if (!node)
153         return { container: this, offset: 0 };
154     return { container: node, offset: offset };
155 }
156
157 Element.prototype.removeStyleClass = function(className) 
158 {
159     this.classList.remove(className);
160 }
161
162 Element.prototype.removeMatchingStyleClasses = function(classNameRegex)
163 {
164     var regex = new RegExp("(^|\\s+)" + classNameRegex + "($|\\s+)");
165     if (regex.test(this.className))
166         this.className = this.className.replace(regex, " ");
167 }
168
169 Element.prototype.addStyleClass = function(className) 
170 {
171     this.classList.add(className);
172 }
173
174 Element.prototype.hasStyleClass = function(className) 
175 {
176     return this.classList.contains(className);
177 }
178
179 Element.prototype.positionAt = function(x, y)
180 {
181     this.style.left = x + "px";
182     this.style.top = y + "px";
183 }
184
185 Element.prototype.pruneEmptyTextNodes = function()
186 {
187     var sibling = this.firstChild;
188     while (sibling) {
189         var nextSibling = sibling.nextSibling;
190         if (sibling.nodeType === this.TEXT_NODE && sibling.nodeValue === "")
191             this.removeChild(sibling);
192         sibling = nextSibling;
193     }
194 }
195
196 Element.prototype.isScrolledToBottom = function()
197 {
198     // This code works only for 0-width border
199     return this.scrollTop + this.clientHeight === this.scrollHeight;
200 }
201
202 Node.prototype.enclosingNodeOrSelfWithNodeNameInArray = function(nameArray)
203 {
204     for (var node = this; node && node !== this.ownerDocument; node = node.parentNode)
205         for (var i = 0; i < nameArray.length; ++i)
206             if (node.nodeName.toLowerCase() === nameArray[i].toLowerCase())
207                 return node;
208     return null;
209 }
210
211 Node.prototype.enclosingNodeOrSelfWithNodeName = function(nodeName)
212 {
213     return this.enclosingNodeOrSelfWithNodeNameInArray([nodeName]);
214 }
215
216 Node.prototype.enclosingNodeOrSelfWithClass = function(className)
217 {
218     for (var node = this; node && node !== this.ownerDocument; node = node.parentNode)
219         if (node.nodeType === Node.ELEMENT_NODE && node.hasStyleClass(className))
220             return node;
221     return null;
222 }
223
224 Node.prototype.enclosingNodeWithClass = function(className)
225 {
226     if (!this.parentNode)
227         return null;
228     return this.parentNode.enclosingNodeOrSelfWithClass(className);
229 }
230
231 Element.prototype.query = function(query) 
232 {
233     return this.ownerDocument.evaluate(query, this, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
234 }
235
236 Element.prototype.removeChildren = function()
237 {
238     if (this.firstChild)
239         this.textContent = "";
240 }
241
242 Element.prototype.isInsertionCaretInside = function()
243 {
244     var selection = window.getSelection();
245     if (!selection.rangeCount || !selection.isCollapsed)
246         return false;
247     var selectionRange = selection.getRangeAt(0);
248     return selectionRange.startContainer === this || selectionRange.startContainer.isDescendant(this);
249 }
250
251 Element.prototype.createChild = function(elementName, className)
252 {
253     var element = document.createElement(elementName);
254     if (className)
255         element.className = className;
256     this.appendChild(element);
257     return element;
258 }
259
260 DocumentFragment.prototype.createChild = Element.prototype.createChild;
261
262 Element.prototype.__defineGetter__("totalOffsetLeft", function()
263 {
264     var total = 0;
265     for (var element = this; element; element = element.offsetParent)
266         total += element.offsetLeft + (this !== element ? element.clientLeft : 0);
267     return total;
268 });
269
270 Element.prototype.__defineGetter__("totalOffsetTop", function()
271 {
272     var total = 0;
273     for (var element = this; element; element = element.offsetParent)
274         total += element.offsetTop + (this !== element ? element.clientTop : 0);
275     return total;
276 });
277
278 Element.prototype.offsetRelativeToWindow = function(targetWindow)
279 {
280     var elementOffset = {x: 0, y: 0};
281     var curElement = this;
282     var curWindow = this.ownerDocument.defaultView;
283     while (curWindow && curElement) {
284         elementOffset.x += curElement.totalOffsetLeft;
285         elementOffset.y += curElement.totalOffsetTop;
286         if (curWindow === targetWindow)
287             break;
288
289         curElement = curWindow.frameElement;
290         curWindow = curWindow.parent;
291     }
292
293     return elementOffset;
294 }
295
296 Element.prototype.setTextAndTitle = function(text)
297 {
298     this.textContent = text;
299     this.title = text;
300 }
301
302 KeyboardEvent.prototype.__defineGetter__("data", function()
303 {
304     // Emulate "data" attribute from DOM 3 TextInput event.
305     // See http://www.w3.org/TR/DOM-Level-3-Events/#events-Events-TextEvent-data
306     switch (this.type) {
307         case "keypress":
308             if (!this.ctrlKey && !this.metaKey)
309                 return String.fromCharCode(this.charCode);
310             else
311                 return "";
312         case "keydown":
313         case "keyup":
314             if (!this.ctrlKey && !this.metaKey && !this.altKey)
315                 return String.fromCharCode(this.which);
316             else
317                 return "";
318     }
319 });
320
321 Text.prototype.select = function(start, end)
322 {
323     start = start || 0;
324     end = end || this.textContent.length;
325
326     if (start < 0)
327         start = end + start;
328
329     var selection = window.getSelection();
330     selection.removeAllRanges();
331     var range = document.createRange();
332     range.setStart(this, start);
333     range.setEnd(this, end);
334     selection.addRange(range);
335     return this;
336 }
337
338 Element.prototype.__defineGetter__("selectionLeftOffset", function() {
339     // Calculate selection offset relative to the current element.
340
341     var selection = window.getSelection();
342     if (!selection.containsNode(this, true))
343         return null;
344
345     var leftOffset = selection.anchorOffset;
346     var node = selection.anchorNode;
347
348     while (node !== this) {
349         while (node.previousSibling) {
350             node = node.previousSibling;
351             leftOffset += node.textContent.length;
352         }
353         node = node.parentNode;
354     }
355
356     return leftOffset;
357 });
358
359 Node.prototype.isWhitespace = isNodeWhitespace;
360 Node.prototype.displayName = nodeDisplayName;
361 Node.prototype.isAncestor = function(node)
362 {
363     return isAncestorNode(this, node);
364 };
365 Node.prototype.isDescendant = isDescendantNode;
366 Node.prototype.traverseNextNode = traverseNextNode;
367 Node.prototype.traversePreviousNode = traversePreviousNode;
368
369 String.prototype.hasSubstring = function(string, caseInsensitive)
370 {
371     if (!caseInsensitive)
372         return this.indexOf(string) !== -1;
373     return this.match(new RegExp(string.escapeForRegExp(), "i"));
374 }
375
376 String.prototype.findAll = function(string)
377 {
378     var matches = [];
379     var i = this.indexOf(string);
380     while (i !== -1) {
381         matches.push(i);
382         i = this.indexOf(string, i + string.length);
383     }
384     return matches;
385 }
386
387 String.prototype.lineEndings = function()
388 {
389     if (!this._lineEndings) {
390         this._lineEndings = this.findAll("\n");
391         this._lineEndings.push(this.length);
392     }
393     return this._lineEndings;
394 }
395
396 String.prototype.asParsedURL = function()
397 {
398     // RegExp groups:
399     // 1 - scheme
400     // 2 - hostname
401     // 3 - ?port
402     // 4 - ?path
403     // 5 - ?fragment
404     var match = this.match(/^([^:]+):\/\/([^\/:]*)(?::([\d]+))?(?:(\/[^#]*)(?:#(.*))?)?$/i);
405     if (!match)
406         return null;
407     var result = {};
408     result.scheme = match[1].toLowerCase();
409     result.host = match[2];
410     result.port = match[3];
411     result.path = match[4] || "/";
412     result.fragment = match[5];
413     return result;
414 }
415
416 String.prototype.escapeCharacters = function(chars)
417 {
418     var foundChar = false;
419     for (var i = 0; i < chars.length; ++i) {
420         if (this.indexOf(chars.charAt(i)) !== -1) {
421             foundChar = true;
422             break;
423         }
424     }
425
426     if (!foundChar)
427         return this;
428
429     var result = "";
430     for (var i = 0; i < this.length; ++i) {
431         if (chars.indexOf(this.charAt(i)) !== -1)
432             result += "\\";
433         result += this.charAt(i);
434     }
435
436     return result;
437 }
438
439 String.prototype.escapeForRegExp = function()
440 {
441     return this.escapeCharacters("^[]{}()\\.$*+?|");
442 }
443
444 String.prototype.escapeHTML = function()
445 {
446     return this.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;"); //" doublequotes just for editor
447 }
448
449 String.prototype.collapseWhitespace = function()
450 {
451     return this.replace(/[\s\xA0]+/g, " ");
452 }
453
454 String.prototype.trimMiddle = function(maxLength)
455 {
456     if (this.length <= maxLength)
457         return this;
458     var leftHalf = maxLength >> 1;
459     var rightHalf = maxLength - leftHalf - 1;
460     return this.substr(0, leftHalf) + "\u2026" + this.substr(this.length - rightHalf, rightHalf);
461 }
462
463 String.prototype.trimURL = function(baseURLDomain)
464 {
465     var result = this.replace(/^(https|http|file):\/\//i, "");
466     if (baseURLDomain)
467         result = result.replace(new RegExp("^" + baseURLDomain.escapeForRegExp(), "i"), "");
468     return result;
469 }
470
471 String.prototype.removeURLFragment = function()
472 {
473     var fragmentIndex = this.indexOf("#");
474     if (fragmentIndex == -1)
475         fragmentIndex = this.length;
476     return this.substring(0, fragmentIndex);
477 }
478
479 function isNodeWhitespace()
480 {
481     if (!this || this.nodeType !== Node.TEXT_NODE)
482         return false;
483     if (!this.nodeValue.length)
484         return true;
485     return this.nodeValue.match(/^[\s\xA0]+$/);
486 }
487
488 function nodeDisplayName()
489 {
490     if (!this)
491         return "";
492
493     switch (this.nodeType) {
494         case Node.DOCUMENT_NODE:
495             return "Document";
496
497         case Node.ELEMENT_NODE:
498             var name = "<" + this.nodeName.toLowerCase();
499
500             if (this.hasAttributes()) {
501                 var value = this.getAttribute("id");
502                 if (value)
503                     name += " id=\"" + value + "\"";
504                 value = this.getAttribute("class");
505                 if (value)
506                     name += " class=\"" + value + "\"";
507                 if (this.nodeName.toLowerCase() === "a") {
508                     value = this.getAttribute("name");
509                     if (value)
510                         name += " name=\"" + value + "\"";
511                     value = this.getAttribute("href");
512                     if (value)
513                         name += " href=\"" + value + "\"";
514                 } else if (this.nodeName.toLowerCase() === "img") {
515                     value = this.getAttribute("src");
516                     if (value)
517                         name += " src=\"" + value + "\"";
518                 } else if (this.nodeName.toLowerCase() === "iframe") {
519                     value = this.getAttribute("src");
520                     if (value)
521                         name += " src=\"" + value + "\"";
522                 } else if (this.nodeName.toLowerCase() === "input") {
523                     value = this.getAttribute("name");
524                     if (value)
525                         name += " name=\"" + value + "\"";
526                     value = this.getAttribute("type");
527                     if (value)
528                         name += " type=\"" + value + "\"";
529                 } else if (this.nodeName.toLowerCase() === "form") {
530                     value = this.getAttribute("action");
531                     if (value)
532                         name += " action=\"" + value + "\"";
533                 }
534             }
535
536             return name + ">";
537
538         case Node.TEXT_NODE:
539             if (isNodeWhitespace.call(this))
540                 return "(whitespace)";
541             return "\"" + this.nodeValue + "\"";
542
543         case Node.COMMENT_NODE:
544             return "<!--" + this.nodeValue + "-->";
545             
546         case Node.DOCUMENT_TYPE_NODE:
547             var docType = "<!DOCTYPE " + this.nodeName;
548             if (this.publicId) {
549                 docType += " PUBLIC \"" + this.publicId + "\"";
550                 if (this.systemId)
551                     docType += " \"" + this.systemId + "\"";
552             } else if (this.systemId)
553                 docType += " SYSTEM \"" + this.systemId + "\"";
554             if (this.internalSubset)
555                 docType += " [" + this.internalSubset + "]";
556             return docType + ">";
557     }
558
559     return this.nodeName.toLowerCase().collapseWhitespace();
560 }
561
562 function isAncestorNode(ancestor, node)
563 {
564     if (!node || !ancestor)
565         return false;
566
567     var currentNode = node.parentNode;
568     while (currentNode) {
569         if (ancestor === currentNode)
570             return true;
571         currentNode = currentNode.parentNode;
572     }
573     return false;
574 }
575
576 function isDescendantNode(descendant)
577 {
578     return isAncestorNode(descendant, this);
579 }
580
581 function traverseNextNode(stayWithin)
582 {
583     if (!this)
584         return;
585
586     var node = this.firstChild;
587     if (node)
588         return node;
589
590     if (stayWithin && this === stayWithin)
591         return null;
592
593     node = this.nextSibling;
594     if (node)
595         return node;
596
597     node = this;
598     while (node && !node.nextSibling && (!stayWithin || !node.parentNode || node.parentNode !== stayWithin))
599         node = node.parentNode;
600     if (!node)
601         return null;
602
603     return node.nextSibling;
604 }
605
606 function traversePreviousNode(stayWithin)
607 {
608     if (!this)
609         return;
610     if (stayWithin && this === stayWithin)
611         return null;
612     var node = this.previousSibling;
613     while (node && node.lastChild)
614         node = node.lastChild;
615     if (node)
616         return node;
617     return this.parentNode;
618 }
619
620 function getDocumentForNode(node)
621 {
622     return node.nodeType == Node.DOCUMENT_NODE ? node : node.ownerDocument;
623 }
624
625 function parentNode(node)
626 {
627     return node.parentNode;
628 }
629
630 Number.millisToString = function(ms, higherResolution)
631 {
632     return Number.secondsToString(ms / 1000, higherResolution);
633 }
634
635 Number.secondsToString = function(seconds, higherResolution)
636 {
637     if (seconds === 0)
638         return "0";
639
640     var ms = seconds * 1000;
641     if (higherResolution && ms < 1000)
642         return WebInspector.UIString("%.3fms", ms);
643     else if (ms < 1000)
644         return WebInspector.UIString("%.0fms", ms);
645
646     if (seconds < 60)
647         return WebInspector.UIString("%.2fs", seconds);
648
649     var minutes = seconds / 60;
650     if (minutes < 60)
651         return WebInspector.UIString("%.1fmin", minutes);
652
653     var hours = minutes / 60;
654     if (hours < 24)
655         return WebInspector.UIString("%.1fhrs", hours);
656
657     var days = hours / 24;
658     return WebInspector.UIString("%.1f days", days);
659 }
660
661 Number.bytesToString = function(bytes, higherResolution)
662 {
663     if (typeof higherResolution === "undefined")
664         higherResolution = true;
665
666     if (bytes < 1024)
667         return WebInspector.UIString("%.0fB", bytes);
668
669     var kilobytes = bytes / 1024;
670     if (higherResolution && kilobytes < 1024)
671         return WebInspector.UIString("%.2fKB", kilobytes);
672     else if (kilobytes < 1024)
673         return WebInspector.UIString("%.0fKB", kilobytes);
674
675     var megabytes = kilobytes / 1024;
676     if (higherResolution)
677         return WebInspector.UIString("%.2fMB", megabytes);
678     else
679         return WebInspector.UIString("%.0fMB", megabytes);
680 }
681
682 Number.constrain = function(num, min, max)
683 {
684     if (num < min)
685         num = min;
686     else if (num > max)
687         num = max;
688     return num;
689 }
690
691 HTMLTextAreaElement.prototype.moveCursorToEnd = function()
692 {
693     var length = this.value.length;
694     this.setSelectionRange(length, length);
695 }
696
697 Object.defineProperty(Array.prototype, "remove", { value: function(value, onlyFirst)
698 {
699     if (onlyFirst) {
700         var index = this.indexOf(value);
701         if (index !== -1)
702             this.splice(index, 1);
703         return;
704     }
705
706     var length = this.length;
707     for (var i = 0; i < length; ++i) {
708         if (this[i] === value)
709             this.splice(i, 1);
710     }
711 }});
712
713 Object.defineProperty(Array.prototype, "keySet", { value: function()
714 {
715     var keys = {};
716     for (var i = 0; i < this.length; ++i)
717         keys[this[i]] = true;
718     return keys;
719 }});
720
721 Object.defineProperty(Array.prototype, "upperBound", { value: function(value)
722 {
723     var first = 0;
724     var count = this.length;
725     while (count > 0) {
726       var step = count >> 1;
727       var middle = first + step;
728       if (value >= this[middle]) {
729           first = middle + 1;
730           count -= step + 1;
731       } else
732           count = step;
733     }
734     return first;
735 }});
736
737 Array.diff = function(left, right)
738 {
739     var o = left;
740     var n = right;
741
742     var ns = {};
743     var os = {};
744
745     for (var i = 0; i < n.length; i++) {
746         if (ns[n[i]] == null)
747             ns[n[i]] = { rows: [], o: null };
748         ns[n[i]].rows.push(i);
749     }
750
751     for (var i = 0; i < o.length; i++) {
752         if (os[o[i]] == null)
753             os[o[i]] = { rows: [], n: null };
754         os[o[i]].rows.push(i);
755     }
756
757     for (var i in ns) {
758         if (ns[i].rows.length == 1 && typeof(os[i]) != "undefined" && os[i].rows.length == 1) {
759             n[ns[i].rows[0]] = { text: n[ns[i].rows[0]], row: os[i].rows[0] };
760             o[os[i].rows[0]] = { text: o[os[i].rows[0]], row: ns[i].rows[0] };
761         }
762     }
763
764     for (var i = 0; i < n.length - 1; i++) {
765         if (n[i].text != null && n[i + 1].text == null && n[i].row + 1 < o.length && o[n[i].row + 1].text == null && n[i + 1] == o[n[i].row + 1]) {
766             n[i + 1] = { text: n[i + 1], row: n[i].row + 1 };
767             o[n[i].row + 1] = { text: o[n[i].row + 1], row: i + 1 };
768         }
769     }
770
771     for (var i = n.length - 1; i > 0; i--) {
772         if (n[i].text != null && n[i - 1].text == null && n[i].row > 0 && o[n[i].row - 1].text == null && 
773             n[i - 1] == o[n[i].row - 1]) {
774             n[i - 1] = { text: n[i - 1], row: n[i].row - 1 };
775             o[n[i].row - 1] = { text: o[n[i].row - 1], row: i - 1 };
776         }
777     }
778
779     return { left: o, right: n };
780 }
781
782 Array.convert = function(list)
783 {
784     // Cast array-like object to an array.
785     return Array.prototype.slice.call(list);
786 }
787
788 String.sprintf = function(format)
789 {
790     return String.vsprintf(format, Array.prototype.slice.call(arguments, 1));
791 }
792
793 String.tokenizeFormatString = function(format)
794 {
795     var tokens = [];
796     var substitutionIndex = 0;
797
798     function addStringToken(str)
799     {
800         tokens.push({ type: "string", value: str });
801     }
802
803     function addSpecifierToken(specifier, precision, substitutionIndex)
804     {
805         tokens.push({ type: "specifier", specifier: specifier, precision: precision, substitutionIndex: substitutionIndex });
806     }
807
808     var index = 0;
809     for (var precentIndex = format.indexOf("%", index); precentIndex !== -1; precentIndex = format.indexOf("%", index)) {
810         addStringToken(format.substring(index, precentIndex));
811         index = precentIndex + 1;
812
813         if (format[index] === "%") {
814             addStringToken("%");
815             ++index;
816             continue;
817         }
818
819         if (!isNaN(format[index])) {
820             // The first character is a number, it might be a substitution index.
821             var number = parseInt(format.substring(index));
822             while (!isNaN(format[index]))
823                 ++index;
824             // If the number is greater than zero and ends with a "$",
825             // then this is a substitution index.
826             if (number > 0 && format[index] === "$") {
827                 substitutionIndex = (number - 1);
828                 ++index;
829             }
830         }
831
832         var precision = -1;
833         if (format[index] === ".") {
834             // This is a precision specifier. If no digit follows the ".",
835             // then the precision should be zero.
836             ++index;
837             precision = parseInt(format.substring(index));
838             if (isNaN(precision))
839                 precision = 0;
840             while (!isNaN(format[index]))
841                 ++index;
842         }
843
844         addSpecifierToken(format[index], precision, substitutionIndex);
845
846         ++substitutionIndex;
847         ++index;
848     }
849
850     addStringToken(format.substring(index));
851
852     return tokens;
853 }
854
855 String.standardFormatters = {
856     d: function(substitution)
857     {
858         if (typeof substitution == "object" && WebInspector.RemoteObject.type(substitution) === "number")
859             substitution = substitution.description;
860         substitution = parseInt(substitution);
861         return !isNaN(substitution) ? substitution : 0;
862     },
863
864     f: function(substitution, token)
865     {
866         if (typeof substitution == "object" && WebInspector.RemoteObject.type(substitution) === "number")
867             substitution = substitution.description;
868         substitution = parseFloat(substitution);
869         if (substitution && token.precision > -1)
870             substitution = substitution.toFixed(token.precision);
871         return !isNaN(substitution) ? substitution : (token.precision > -1 ? Number(0).toFixed(token.precision) : 0);
872     },
873
874     s: function(substitution)
875     {
876         if (typeof substitution == "object" && WebInspector.RemoteObject.type(substitution) !== "null")
877             substitution = substitution.description;
878         return substitution;
879     },
880 };
881
882 String.vsprintf = function(format, substitutions)
883 {
884     return String.format(format, substitutions, String.standardFormatters, "", function(a, b) { return a + b; }).formattedResult;
885 }
886
887 String.format = function(format, substitutions, formatters, initialValue, append)
888 {
889     if (!format || !substitutions || !substitutions.length)
890         return { formattedResult: append(initialValue, format), unusedSubstitutions: substitutions };
891
892     function prettyFunctionName()
893     {
894         return "String.format(\"" + format + "\", \"" + substitutions.join("\", \"") + "\")";
895     }
896
897     function warn(msg)
898     {
899         console.warn(prettyFunctionName() + ": " + msg);
900     }
901
902     function error(msg)
903     {
904         console.error(prettyFunctionName() + ": " + msg);
905     }
906
907     var result = initialValue;
908     var tokens = String.tokenizeFormatString(format);
909     var usedSubstitutionIndexes = {};
910
911     for (var i = 0; i < tokens.length; ++i) {
912         var token = tokens[i];
913
914         if (token.type === "string") {
915             result = append(result, token.value);
916             continue;
917         }
918
919         if (token.type !== "specifier") {
920             error("Unknown token type \"" + token.type + "\" found.");
921             continue;
922         }
923
924         if (token.substitutionIndex >= substitutions.length) {
925             // If there are not enough substitutions for the current substitutionIndex
926             // just output the format specifier literally and move on.
927             error("not enough substitution arguments. Had " + substitutions.length + " but needed " + (token.substitutionIndex + 1) + ", so substitution was skipped.");
928             result = append(result, "%" + (token.precision > -1 ? token.precision : "") + token.specifier);
929             continue;
930         }
931
932         usedSubstitutionIndexes[token.substitutionIndex] = true;
933
934         if (!(token.specifier in formatters)) {
935             // Encountered an unsupported format character, treat as a string.
936             warn("unsupported format character \u201C" + token.specifier + "\u201D. Treating as a string.");
937             result = append(result, substitutions[token.substitutionIndex]);
938             continue;
939         }
940
941         result = append(result, formatters[token.specifier](substitutions[token.substitutionIndex], token));
942     }
943
944     var unusedSubstitutions = [];
945     for (var i = 0; i < substitutions.length; ++i) {
946         if (i in usedSubstitutionIndexes)
947             continue;
948         unusedSubstitutions.push(substitutions[i]);
949     }
950
951     return { formattedResult: result, unusedSubstitutions: unusedSubstitutions };
952 }
953
954 function isEnterKey(event) {
955     // Check if in IME.
956     return event.keyCode !== 229 && event.keyIdentifier === "Enter";
957 }
958
959 function highlightSearchResult(element, offset, length, domChanges)
960 {
961     var result = highlightSearchResults(element, [{offset: offset, length: length }], domChanges);
962     return result.length ? result[0] : null;
963 }
964
965 function highlightSearchResults(element, resultRanges, changes)
966 {
967     changes = changes || [];
968     var highlightNodes = [];
969     var lineText = element.textContent;
970     var textNodeSnapshot = document.evaluate(".//text()", element, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
971
972     var snapshotLength = textNodeSnapshot.snapshotLength;
973     var snapshotNodeOffset = 0;
974     var currentSnapshotItem = 0;
975
976     for (var i = 0; i < resultRanges.length; ++i) {
977         var resultLength = resultRanges[i].length;
978         var startOffset = resultRanges[i].offset;
979         var endOffset = startOffset + resultLength;
980         var length = resultLength;
981         var textNode;
982         var textNodeOffset;
983         var found;
984
985         while (currentSnapshotItem < snapshotLength) {
986             textNode = textNodeSnapshot.snapshotItem(currentSnapshotItem++);
987             var textNodeLength = textNode.nodeValue.length;
988             if (snapshotNodeOffset + textNodeLength > startOffset) {
989                 textNodeOffset = startOffset - snapshotNodeOffset;
990                 snapshotNodeOffset += textNodeLength;
991                 found = true;
992                 break;
993             }
994             snapshotNodeOffset += textNodeLength;
995         }
996
997         if (!found) {
998             textNode = element;
999             textNodeOffset = 0;
1000         }
1001
1002         var highlightNode = document.createElement("span");
1003         highlightNode.className = "webkit-search-result";
1004         highlightNode.textContent = lineText.substring(startOffset, endOffset);
1005
1006         var text = textNode.textContent;
1007         if (textNodeOffset + resultLength < text.length) {
1008             // Selection belongs to a single split mode.
1009             textNode.textContent = text.substring(textNodeOffset + resultLength);
1010             changes.push({ node: textNode, type: "changed", oldText: text, newText: textNode.textContent });
1011
1012             textNode.parentElement.insertBefore(highlightNode, textNode);
1013             changes.push({ node: highlightNode, type: "added", nextSibling: textNode, parent: textNode.parentElement });
1014
1015             var prefixNode = document.createTextNode(text.substring(0, textNodeOffset));
1016             textNode.parentElement.insertBefore(prefixNode, highlightNode);
1017             changes.push({ node: prefixNode, type: "added", nextSibling: highlightNode, parent: textNode.parentElement });
1018             highlightNodes.push(highlightNode);
1019             continue;
1020         }
1021
1022         var parentElement = textNode.parentElement;
1023         var anchorElement = textNode.nextSibling;
1024
1025         length -= text.length - textNodeOffset;
1026         textNode.textContent = text.substring(0, textNodeOffset);
1027         changes.push({ node: textNode, type: "changed", oldText: text, newText: textNode.textContent });
1028
1029         while (currentSnapshotItem < snapshotLength) {
1030             textNode = textNodeSnapshot.snapshotItem(currentSnapshotItem++);
1031             snapshotNodeOffset += textNode.nodeValue.length;
1032             var text = textNode.textContent;
1033             if (length < text.length) {
1034                 textNode.textContent = text.substring(length);
1035                 changes.push({ node: textNode, type: "changed", oldText: text, newText: textNode.textContent });
1036                 break;
1037             }
1038
1039             length -= text.length;
1040             textNode.textContent = "";
1041             changes.push({ node: textNode, type: "changed", oldText: text, newText: textNode.textContent });
1042         }
1043
1044         parentElement.insertBefore(highlightNode, anchorElement);
1045         changes.push({ node: highlightNode, type: "added", nextSibling: anchorElement, parent: parentElement });
1046         highlightNodes.push(highlightNode);
1047     }
1048
1049     return highlightNodes;
1050 }
1051
1052 function applyDomChanges(domChanges)
1053 {
1054     for (var i = 0, size = domChanges.length; i < size; ++i) {
1055         var entry = domChanges[i];
1056         switch (entry.type) {
1057         case "added":
1058             entry.parent.insertBefore(entry.node, entry.nextSibling);
1059             break;
1060         case "changed":
1061             entry.node.textContent = entry.newText;
1062             break;
1063         }
1064     }
1065 }
1066
1067 function revertDomChanges(domChanges)
1068 {
1069     for (var i = 0, size = domChanges.length; i < size; ++i) {
1070         var entry = domChanges[i];
1071         switch (entry.type) {
1072         case "added":
1073             if (entry.node.parentElement)
1074                 entry.node.parentElement.removeChild(entry.node);
1075             break;
1076         case "changed":
1077             entry.node.textContent = entry.oldText;
1078             break;
1079         }
1080     }
1081 }
1082
1083 function createSearchRegex(query, extraFlags)
1084 {
1085     // This should be kept the same as the one in InspectorPageAgent.cpp.
1086     regexSpecialCharacters = "[](){}+-*.,?\\^$|";
1087     var regex = "";
1088     for (var i = 0; i < query.length; ++i) {
1089         var char = query.charAt(i);
1090         if (regexSpecialCharacters.indexOf(char) != -1)
1091             regex += "\\";
1092         regex += char;
1093     }
1094     return new RegExp(regex, "i" + (extraFlags || ""));
1095 }
1096
1097 function countRegexMatches(regex, content)
1098 {
1099     var text = content;
1100     var result = 0;
1101     var match;
1102     while (text && (match = regex.exec(text))) {
1103         if (match[0].length > 0)
1104             ++result;
1105         text = text.substring(match.index + 1);
1106     }
1107     return result;
1108 }