Web Inspector: implement import/export for timeline data.
[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 Date.prototype.toRFC3339 = function()
692 {
693     function leadZero(x)
694     {
695         return x > 9 ? x : '0' + x
696     }
697     var offset = Math.abs(this.getTimezoneOffset());
698     var offsetString = Math.floor(offset / 60) + ':' + leadZero(offset % 60);
699     return this.getFullYear() + '-' +
700            leadZero(this.getMonth() + 1) + '-' +
701            leadZero(this.getDate()) + 'T' +
702            leadZero(this.getHours()) + ':' +
703            leadZero(this.getMinutes()) + ':' +
704            leadZero(this.getSeconds()) +
705            (!offset ? "Z" : (this.getTimezoneOffset() > 0 ? '-' : '+') + offsetString);
706 }
707
708 HTMLTextAreaElement.prototype.moveCursorToEnd = function()
709 {
710     var length = this.value.length;
711     this.setSelectionRange(length, length);
712 }
713
714 Object.defineProperty(Array.prototype, "remove", { value: function(value, onlyFirst)
715 {
716     if (onlyFirst) {
717         var index = this.indexOf(value);
718         if (index !== -1)
719             this.splice(index, 1);
720         return;
721     }
722
723     var length = this.length;
724     for (var i = 0; i < length; ++i) {
725         if (this[i] === value)
726             this.splice(i, 1);
727     }
728 }});
729
730 Object.defineProperty(Array.prototype, "keySet", { value: function()
731 {
732     var keys = {};
733     for (var i = 0; i < this.length; ++i)
734         keys[this[i]] = true;
735     return keys;
736 }});
737
738 Object.defineProperty(Array.prototype, "upperBound", { value: function(value)
739 {
740     var first = 0;
741     var count = this.length;
742     while (count > 0) {
743       var step = count >> 1;
744       var middle = first + step;
745       if (value >= this[middle]) {
746           first = middle + 1;
747           count -= step + 1;
748       } else
749           count = step;
750     }
751     return first;
752 }});
753
754 Array.diff = function(left, right)
755 {
756     var o = left;
757     var n = right;
758
759     var ns = {};
760     var os = {};
761
762     for (var i = 0; i < n.length; i++) {
763         if (ns[n[i]] == null)
764             ns[n[i]] = { rows: [], o: null };
765         ns[n[i]].rows.push(i);
766     }
767
768     for (var i = 0; i < o.length; i++) {
769         if (os[o[i]] == null)
770             os[o[i]] = { rows: [], n: null };
771         os[o[i]].rows.push(i);
772     }
773
774     for (var i in ns) {
775         if (ns[i].rows.length == 1 && typeof(os[i]) != "undefined" && os[i].rows.length == 1) {
776             n[ns[i].rows[0]] = { text: n[ns[i].rows[0]], row: os[i].rows[0] };
777             o[os[i].rows[0]] = { text: o[os[i].rows[0]], row: ns[i].rows[0] };
778         }
779     }
780
781     for (var i = 0; i < n.length - 1; i++) {
782         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]) {
783             n[i + 1] = { text: n[i + 1], row: n[i].row + 1 };
784             o[n[i].row + 1] = { text: o[n[i].row + 1], row: i + 1 };
785         }
786     }
787
788     for (var i = n.length - 1; i > 0; i--) {
789         if (n[i].text != null && n[i - 1].text == null && n[i].row > 0 && o[n[i].row - 1].text == null && 
790             n[i - 1] == o[n[i].row - 1]) {
791             n[i - 1] = { text: n[i - 1], row: n[i].row - 1 };
792             o[n[i].row - 1] = { text: o[n[i].row - 1], row: i - 1 };
793         }
794     }
795
796     return { left: o, right: n };
797 }
798
799 Array.convert = function(list)
800 {
801     // Cast array-like object to an array.
802     return Array.prototype.slice.call(list);
803 }
804
805 String.sprintf = function(format)
806 {
807     return String.vsprintf(format, Array.prototype.slice.call(arguments, 1));
808 }
809
810 String.tokenizeFormatString = function(format)
811 {
812     var tokens = [];
813     var substitutionIndex = 0;
814
815     function addStringToken(str)
816     {
817         tokens.push({ type: "string", value: str });
818     }
819
820     function addSpecifierToken(specifier, precision, substitutionIndex)
821     {
822         tokens.push({ type: "specifier", specifier: specifier, precision: precision, substitutionIndex: substitutionIndex });
823     }
824
825     var index = 0;
826     for (var precentIndex = format.indexOf("%", index); precentIndex !== -1; precentIndex = format.indexOf("%", index)) {
827         addStringToken(format.substring(index, precentIndex));
828         index = precentIndex + 1;
829
830         if (format[index] === "%") {
831             addStringToken("%");
832             ++index;
833             continue;
834         }
835
836         if (!isNaN(format[index])) {
837             // The first character is a number, it might be a substitution index.
838             var number = parseInt(format.substring(index));
839             while (!isNaN(format[index]))
840                 ++index;
841             // If the number is greater than zero and ends with a "$",
842             // then this is a substitution index.
843             if (number > 0 && format[index] === "$") {
844                 substitutionIndex = (number - 1);
845                 ++index;
846             }
847         }
848
849         var precision = -1;
850         if (format[index] === ".") {
851             // This is a precision specifier. If no digit follows the ".",
852             // then the precision should be zero.
853             ++index;
854             precision = parseInt(format.substring(index));
855             if (isNaN(precision))
856                 precision = 0;
857             while (!isNaN(format[index]))
858                 ++index;
859         }
860
861         addSpecifierToken(format[index], precision, substitutionIndex);
862
863         ++substitutionIndex;
864         ++index;
865     }
866
867     addStringToken(format.substring(index));
868
869     return tokens;
870 }
871
872 String.standardFormatters = {
873     d: function(substitution)
874     {
875         if (typeof substitution == "object" && WebInspector.RemoteObject.type(substitution) === "number")
876             substitution = substitution.description;
877         substitution = parseInt(substitution);
878         return !isNaN(substitution) ? substitution : 0;
879     },
880
881     f: function(substitution, token)
882     {
883         if (typeof substitution == "object" && WebInspector.RemoteObject.type(substitution) === "number")
884             substitution = substitution.description;
885         substitution = parseFloat(substitution);
886         if (substitution && token.precision > -1)
887             substitution = substitution.toFixed(token.precision);
888         return !isNaN(substitution) ? substitution : (token.precision > -1 ? Number(0).toFixed(token.precision) : 0);
889     },
890
891     s: function(substitution)
892     {
893         if (typeof substitution == "object" && WebInspector.RemoteObject.type(substitution) !== "null")
894             substitution = substitution.description;
895         return substitution;
896     },
897 };
898
899 String.vsprintf = function(format, substitutions)
900 {
901     return String.format(format, substitutions, String.standardFormatters, "", function(a, b) { return a + b; }).formattedResult;
902 }
903
904 String.format = function(format, substitutions, formatters, initialValue, append)
905 {
906     if (!format || !substitutions || !substitutions.length)
907         return { formattedResult: append(initialValue, format), unusedSubstitutions: substitutions };
908
909     function prettyFunctionName()
910     {
911         return "String.format(\"" + format + "\", \"" + substitutions.join("\", \"") + "\")";
912     }
913
914     function warn(msg)
915     {
916         console.warn(prettyFunctionName() + ": " + msg);
917     }
918
919     function error(msg)
920     {
921         console.error(prettyFunctionName() + ": " + msg);
922     }
923
924     var result = initialValue;
925     var tokens = String.tokenizeFormatString(format);
926     var usedSubstitutionIndexes = {};
927
928     for (var i = 0; i < tokens.length; ++i) {
929         var token = tokens[i];
930
931         if (token.type === "string") {
932             result = append(result, token.value);
933             continue;
934         }
935
936         if (token.type !== "specifier") {
937             error("Unknown token type \"" + token.type + "\" found.");
938             continue;
939         }
940
941         if (token.substitutionIndex >= substitutions.length) {
942             // If there are not enough substitutions for the current substitutionIndex
943             // just output the format specifier literally and move on.
944             error("not enough substitution arguments. Had " + substitutions.length + " but needed " + (token.substitutionIndex + 1) + ", so substitution was skipped.");
945             result = append(result, "%" + (token.precision > -1 ? token.precision : "") + token.specifier);
946             continue;
947         }
948
949         usedSubstitutionIndexes[token.substitutionIndex] = true;
950
951         if (!(token.specifier in formatters)) {
952             // Encountered an unsupported format character, treat as a string.
953             warn("unsupported format character \u201C" + token.specifier + "\u201D. Treating as a string.");
954             result = append(result, substitutions[token.substitutionIndex]);
955             continue;
956         }
957
958         result = append(result, formatters[token.specifier](substitutions[token.substitutionIndex], token));
959     }
960
961     var unusedSubstitutions = [];
962     for (var i = 0; i < substitutions.length; ++i) {
963         if (i in usedSubstitutionIndexes)
964             continue;
965         unusedSubstitutions.push(substitutions[i]);
966     }
967
968     return { formattedResult: result, unusedSubstitutions: unusedSubstitutions };
969 }
970
971 function isEnterKey(event) {
972     // Check if in IME.
973     return event.keyCode !== 229 && event.keyIdentifier === "Enter";
974 }
975
976 function highlightSearchResult(element, offset, length, domChanges)
977 {
978     var result = highlightSearchResults(element, [{offset: offset, length: length }], domChanges);
979     return result.length ? result[0] : null;
980 }
981
982 function highlightSearchResults(element, resultRanges, changes)
983 {
984     changes = changes || [];
985     var highlightNodes = [];
986     var lineText = element.textContent;
987     var textNodeSnapshot = document.evaluate(".//text()", element, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
988
989     var snapshotLength = textNodeSnapshot.snapshotLength;
990     var snapshotNodeOffset = 0;
991     var currentSnapshotItem = 0;
992
993     for (var i = 0; i < resultRanges.length; ++i) {
994         var resultLength = resultRanges[i].length;
995         var startOffset = resultRanges[i].offset;
996         var endOffset = startOffset + resultLength;
997         var length = resultLength;
998         var textNode;
999         var textNodeOffset;
1000         var found;
1001
1002         while (currentSnapshotItem < snapshotLength) {
1003             textNode = textNodeSnapshot.snapshotItem(currentSnapshotItem++);
1004             var textNodeLength = textNode.nodeValue.length;
1005             if (snapshotNodeOffset + textNodeLength > startOffset) {
1006                 textNodeOffset = startOffset - snapshotNodeOffset;
1007                 snapshotNodeOffset += textNodeLength;
1008                 found = true;
1009                 break;
1010             }
1011             snapshotNodeOffset += textNodeLength;
1012         }
1013
1014         if (!found) {
1015             textNode = element;
1016             textNodeOffset = 0;
1017         }
1018
1019         var highlightNode = document.createElement("span");
1020         highlightNode.className = "webkit-search-result";
1021         highlightNode.textContent = lineText.substring(startOffset, endOffset);
1022
1023         var text = textNode.textContent;
1024         if (textNodeOffset + resultLength < text.length) {
1025             // Selection belongs to a single split mode.
1026             textNode.textContent = text.substring(textNodeOffset + resultLength);
1027             changes.push({ node: textNode, type: "changed", oldText: text, newText: textNode.textContent });
1028
1029             textNode.parentElement.insertBefore(highlightNode, textNode);
1030             changes.push({ node: highlightNode, type: "added", nextSibling: textNode, parent: textNode.parentElement });
1031
1032             var prefixNode = document.createTextNode(text.substring(0, textNodeOffset));
1033             textNode.parentElement.insertBefore(prefixNode, highlightNode);
1034             changes.push({ node: prefixNode, type: "added", nextSibling: highlightNode, parent: textNode.parentElement });
1035             highlightNodes.push(highlightNode);
1036             continue;
1037         }
1038
1039         var parentElement = textNode.parentElement;
1040         var anchorElement = textNode.nextSibling;
1041
1042         length -= text.length - textNodeOffset;
1043         textNode.textContent = text.substring(0, textNodeOffset);
1044         changes.push({ node: textNode, type: "changed", oldText: text, newText: textNode.textContent });
1045
1046         while (currentSnapshotItem < snapshotLength) {
1047             textNode = textNodeSnapshot.snapshotItem(currentSnapshotItem++);
1048             snapshotNodeOffset += textNode.nodeValue.length;
1049             var text = textNode.textContent;
1050             if (length < text.length) {
1051                 textNode.textContent = text.substring(length);
1052                 changes.push({ node: textNode, type: "changed", oldText: text, newText: textNode.textContent });
1053                 break;
1054             }
1055
1056             length -= text.length;
1057             textNode.textContent = "";
1058             changes.push({ node: textNode, type: "changed", oldText: text, newText: textNode.textContent });
1059         }
1060
1061         parentElement.insertBefore(highlightNode, anchorElement);
1062         changes.push({ node: highlightNode, type: "added", nextSibling: anchorElement, parent: parentElement });
1063         highlightNodes.push(highlightNode);
1064     }
1065
1066     return highlightNodes;
1067 }
1068
1069 function applyDomChanges(domChanges)
1070 {
1071     for (var i = 0, size = domChanges.length; i < size; ++i) {
1072         var entry = domChanges[i];
1073         switch (entry.type) {
1074         case "added":
1075             entry.parent.insertBefore(entry.node, entry.nextSibling);
1076             break;
1077         case "changed":
1078             entry.node.textContent = entry.newText;
1079             break;
1080         }
1081     }
1082 }
1083
1084 function revertDomChanges(domChanges)
1085 {
1086     for (var i = 0, size = domChanges.length; i < size; ++i) {
1087         var entry = domChanges[i];
1088         switch (entry.type) {
1089         case "added":
1090             if (entry.node.parentElement)
1091                 entry.node.parentElement.removeChild(entry.node);
1092             break;
1093         case "changed":
1094             entry.node.textContent = entry.oldText;
1095             break;
1096         }
1097     }
1098 }
1099
1100 function createSearchRegex(query, extraFlags)
1101 {
1102     // This should be kept the same as the one in InspectorPageAgent.cpp.
1103     regexSpecialCharacters = "[](){}+-*.,?\\^$|";
1104     var regex = "";
1105     for (var i = 0; i < query.length; ++i) {
1106         var char = query.charAt(i);
1107         if (regexSpecialCharacters.indexOf(char) != -1)
1108             regex += "\\";
1109         regex += char;
1110     }
1111     return new RegExp(regex, "i" + (extraFlags || ""));
1112 }
1113
1114 function countRegexMatches(regex, content)
1115 {
1116     var text = content;
1117     var result = 0;
1118     var match;
1119     while (text && (match = regex.exec(text))) {
1120         if (match[0].length > 0)
1121             ++result;
1122         text = text.substring(match.index + 1);
1123     }
1124     return result;
1125 }