2010-03-22 Pavel Feldman <pfeldman@chromium.org>
[WebKit-https.git] / WebCore / inspector / front-end / DOMAgent.js
1 /*
2  * Copyright (C) 2009 Google Inc. All rights reserved.
3  * Copyright (C) 2009 Joseph Pecoraro
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are
7  * met:
8  *
9  *     * Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *     * Redistributions in binary form must reproduce the above
12  * copyright notice, this list of conditions and the following disclaimer
13  * in the documentation and/or other materials provided with the
14  * distribution.
15  *     * Neither the name of Google Inc. nor the names of its
16  * contributors may be used to endorse or promote products derived from
17  * this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 WebInspector.DOMNode = function(doc, payload) {
33     this.ownerDocument = doc;
34
35     this.id = payload.id;
36     // injectedScriptId is a node is for DOM nodes which should be converted
37     // to corresponding InjectedScript by the inspector backend. We indicate
38     // this by making injectedScriptId negative.
39     this.injectedScriptId = -payload.id;
40     this.nodeType = payload.nodeType;
41     this.nodeName = payload.nodeName;
42     this.localName = payload.localName;
43     this._nodeValue = payload.nodeValue;
44     this.textContent = this.nodeValue;
45
46     this.attributes = [];
47     this._attributesMap = {};
48     if (payload.attributes)
49         this._setAttributesPayload(payload.attributes);
50
51     this._childNodeCount = payload.childNodeCount;
52     this.children = null;
53
54     this.nextSibling = null;
55     this.prevSibling = null;
56     this.firstChild = null;
57     this.lastChild = null;
58     this.parentNode = null;
59
60     if (payload.children)
61         this._setChildrenPayload(payload.children);
62
63     this._computedStyle = null;
64     this.style = null;
65     this._matchedCSSRules = [];
66
67     if (this.nodeType === Node.ELEMENT_NODE) {
68         // HTML and BODY from internal iframes should not overwrite top-level ones.
69         if (!this.ownerDocument.documentElement && this.nodeName === "HTML")
70             this.ownerDocument.documentElement = this;
71         if (!this.ownerDocument.body && this.nodeName === "BODY")
72             this.ownerDocument.body = this;
73         if (payload.documentURL)
74             this.documentURL = payload.documentURL;
75     } else if (this.nodeType === Node.DOCUMENT_TYPE_NODE) {
76         this.publicId = payload.publicId;
77         this.systemId = payload.systemId;
78         this.internalSubset = payload.internalSubset;
79     } else if (this.nodeType === Node.DOCUMENT_NODE)
80         this.documentURL = payload.documentURL;
81 }
82
83 WebInspector.DOMNode.prototype = {
84     hasAttributes: function()
85     {
86         return this.attributes.length > 0;
87     },
88
89     hasChildNodes: function()  {
90         return this._childNodeCount > 0;
91     },
92
93     get nodeValue() {
94         return this._nodeValue;
95     },
96
97     set nodeValue(value) {
98         if (this.nodeType != Node.TEXT_NODE)
99             return;
100         var self = this;
101         var callback = function()
102         {
103             self._nodeValue = value;
104             self.textContent = value;
105         };
106         this.ownerDocument._domAgent.setTextNodeValueAsync(this, value, callback);
107     },
108
109     getAttribute: function(name)
110     {
111         var attr = this._attributesMap[name];
112         return attr ? attr.value : undefined;
113     },
114
115     setAttribute: function(name, value)
116     {
117         var self = this;
118         var callback = function()
119         {
120             var attr = self._attributesMap[name];
121             if (attr)
122                 attr.value = value;
123             else
124                 attr = self._addAttribute(name, value);
125         };
126         this.ownerDocument._domAgent.setAttributeAsync(this, name, value, callback);
127     },
128
129     removeAttribute: function(name)
130     {
131         var self = this;
132         var callback = function()
133         {
134             delete self._attributesMap[name];
135             for (var i = 0;  i < self.attributes.length; ++i) {
136                 if (self.attributes[i].name == name) {
137                     self.attributes.splice(i, 1);
138                     break;
139                 }
140             }
141         };
142         this.ownerDocument._domAgent.removeAttributeAsync(this, name, callback);
143     },
144
145     _setAttributesPayload: function(attrs)
146     {
147         this.attributes = [];
148         this._attributesMap = {};
149         for (var i = 0; i < attrs.length; i += 2)
150             this._addAttribute(attrs[i], attrs[i + 1]);
151     },
152
153     _insertChild: function(prev, payload)
154     {
155         var node = new WebInspector.DOMNode(this.ownerDocument, payload);
156         if (!prev) {
157             if (!this.children) {
158                 // First node
159                 this.children = [ node ];
160             } else
161                 this.children.unshift(node);
162         } else
163             this.children.splice(this.children.indexOf(prev) + 1, 0, node);
164         this._renumber();
165         return node;
166     },
167
168     removeChild_: function(node)
169     {
170         this.children.splice(this.children.indexOf(node), 1);
171         node.parentNode = null;
172         this._renumber();
173     },
174
175     _setChildrenPayload: function(payloads)
176     {
177         this.children = [];
178         for (var i = 0; i < payloads.length; ++i) {
179             var payload = payloads[i];
180             var node = new WebInspector.DOMNode(this.ownerDocument, payload);
181             this.children.push(node);
182         }
183         this._renumber();
184     },
185
186     _renumber: function()
187     {
188         this._childNodeCount = this.children.length;
189         if (this._childNodeCount == 0) {
190             this.firstChild = null;
191             this.lastChild = null;
192             return;
193         }
194         this.firstChild = this.children[0];
195         this.lastChild = this.children[this._childNodeCount - 1];
196         for (var i = 0; i < this._childNodeCount; ++i) {
197             var child = this.children[i];
198             child.index = i;
199             child.nextSibling = i + 1 < this._childNodeCount ? this.children[i + 1] : null;
200             child.prevSibling = i - 1 >= 0 ? this.children[i - 1] : null;
201             child.parentNode = this;
202         }
203     },
204
205     _addAttribute: function(name, value)
206     {
207         var attr = {
208             "name": name,
209             "value": value,
210             "_node": this
211         };
212         this._attributesMap[name] = attr;
213         this.attributes.push(attr);
214     }
215 }
216
217 WebInspector.DOMDocument = function(domAgent, defaultView, payload)
218 {
219     WebInspector.DOMNode.call(this, this, payload);
220     this._listeners = {};
221     this._domAgent = domAgent;
222     this.defaultView = defaultView;
223 }
224
225 WebInspector.DOMDocument.prototype = {
226
227     addEventListener: function(name, callback)
228     {
229         var listeners = this._listeners[name];
230         if (!listeners) {
231             listeners = [];
232             this._listeners[name] = listeners;
233         }
234         listeners.push(callback);
235     },
236
237     removeEventListener: function(name, callback)
238     {
239         var listeners = this._listeners[name];
240         if (!listeners)
241             return;
242
243         var index = listeners.indexOf(callback);
244         if (index != -1)
245             listeners.splice(index, 1);
246     },
247
248     _fireDomEvent: function(name, event)
249     {
250         var listeners = this._listeners[name];
251         if (!listeners)
252             return;
253
254         for (var i = 0; i < listeners.length; ++i) {
255             var listener = listeners[i];
256             listener.call(this, event);
257         }
258     }
259 }
260
261 WebInspector.DOMDocument.prototype.__proto__ = WebInspector.DOMNode.prototype;
262
263
264 WebInspector.DOMWindow = function(domAgent)
265 {
266     this._domAgent = domAgent;
267 }
268
269 WebInspector.DOMWindow.prototype = {
270     get document()
271     {
272         return this._domAgent.document;
273     },
274
275     get Node()
276     {
277         return WebInspector.DOMNode;
278     },
279
280     get Element()
281     {
282         return WebInspector.DOMNode;
283     },
284
285     Object: function()
286     {
287     }
288 }
289
290 WebInspector.DOMAgent = function() {
291     this._window = new WebInspector.DOMWindow(this);
292     this._idToDOMNode = null;
293     this.document = null;
294 }
295
296 WebInspector.DOMAgent.prototype = {
297     get domWindow()
298     {
299         return this._window;
300     },
301
302     getChildNodesAsync: function(parent, callback)
303     {
304         var children = parent.children;
305         if (children) {
306             callback(children);
307             return;
308         }
309         function mycallback() {
310             callback(parent.children);
311         }
312         var callId = WebInspector.Callback.wrap(mycallback);
313         InspectorBackend.getChildNodes(callId, parent.id);
314     },
315
316     setAttributeAsync: function(node, name, value, callback)
317     {
318         var mycallback = this._didApplyDomChange.bind(this, node, callback);
319         InspectorBackend.setAttribute(WebInspector.Callback.wrap(mycallback), node.id, name, value);
320     },
321
322     removeAttributeAsync: function(node, name, callback)
323     {
324         var mycallback = this._didApplyDomChange.bind(this, node, callback);
325         InspectorBackend.removeAttribute(WebInspector.Callback.wrap(mycallback), node.id, name);
326     },
327
328     setTextNodeValueAsync: function(node, text, callback)
329     {
330         var mycallback = this._didApplyDomChange.bind(this, node, callback);
331         InspectorBackend.setTextNodeValue(WebInspector.Callback.wrap(mycallback), node.id, text);
332     },
333
334     _didApplyDomChange: function(node, callback, success)
335     {
336         if (!success)
337             return;
338         callback();
339         // TODO(pfeldman): Fix this hack.
340         var elem = WebInspector.panels.elements.treeOutline.findTreeElement(node);
341         if (elem)
342             elem.updateTitle();
343     },
344
345     _attributesUpdated: function(nodeId, attrsArray)
346     {
347         var node = this._idToDOMNode[nodeId];
348         node._setAttributesPayload(attrsArray);
349         var event = {target: node};
350         this.document._fireDomEvent("DOMAttrModified", event);
351     },
352
353     nodeForId: function(nodeId) {
354         return this._idToDOMNode[nodeId];
355     },
356
357     _setDocument: function(payload)
358     {
359         this._idToDOMNode = {};
360         if (payload && "id" in payload) {
361             this.document = new WebInspector.DOMDocument(this, this._window, payload);
362             this._idToDOMNode[payload.id] = this.document;
363             this._bindNodes(this.document.children);
364         } else
365             this.document = null;
366         WebInspector.panels.elements.setDocument(this.document);
367     },
368
369     _setDetachedRoot: function(payload)
370     {
371         var root = new WebInspector.DOMNode(this.document, payload);
372         this._idToDOMNode[payload.id] = root;
373     },
374
375     _setChildNodes: function(parentId, payloads)
376     {
377         var parent = this._idToDOMNode[parentId];
378         parent._setChildrenPayload(payloads);
379         this._bindNodes(parent.children);
380     },
381
382     _bindNodes: function(children)
383     {
384         for (var i = 0; i < children.length; ++i) {
385             var child = children[i];
386             this._idToDOMNode[child.id] = child;
387             if (child.children)
388                 this._bindNodes(child.children);
389         }
390     },
391
392     _childNodeCountUpdated: function(nodeId, newValue)
393     {
394         var node = this._idToDOMNode[nodeId];
395         node._childNodeCount = newValue;
396         var outline = WebInspector.panels.elements.treeOutline;
397         var treeElement = outline.findTreeElement(node);
398         if (treeElement)
399             treeElement.hasChildren = newValue;
400     },
401
402     _childNodeInserted: function(parentId, prevId, payload)
403     {
404         var parent = this._idToDOMNode[parentId];
405         var prev = this._idToDOMNode[prevId];
406         var node = parent._insertChild(prev, payload);
407         this._idToDOMNode[node.id] = node;
408         var event = { target : node, relatedNode : parent };
409         this.document._fireDomEvent("DOMNodeInserted", event);
410     },
411
412     _childNodeRemoved: function(parentId, nodeId)
413     {
414         var parent = this._idToDOMNode[parentId];
415         var node = this._idToDOMNode[nodeId];
416         parent.removeChild_(node);
417         var event = { target : node, relatedNode : parent };
418         this.document._fireDomEvent("DOMNodeRemoved", event);
419         delete this._idToDOMNode[nodeId];
420     }
421 }
422
423 WebInspector.Cookies = {}
424
425 WebInspector.Cookies.getCookiesAsync = function(callback)
426 {
427     function mycallback(cookies, cookiesString) {
428         if (cookiesString)
429             callback(WebInspector.Cookies.buildCookiesFromString(cookiesString), false);
430         else
431             callback(cookies, true);
432     }
433     var callId = WebInspector.Callback.wrap(mycallback);
434     InspectorBackend.getCookies(callId);
435 }
436
437 WebInspector.Cookies.buildCookiesFromString = function(rawCookieString)
438 {
439     var rawCookies = rawCookieString.split(/;\s*/);
440     var cookies = [];
441
442     if (!(/^\s*$/.test(rawCookieString))) {
443         for (var i = 0; i < rawCookies.length; ++i) {
444             var cookie = rawCookies[i];
445             var delimIndex = cookie.indexOf("=");
446             var name = cookie.substring(0, delimIndex);
447             var value = cookie.substring(delimIndex + 1);
448             var size = name.length + value.length;
449             cookies.push({ name: name, value: value, size: size });
450         }
451     }
452
453     return cookies;
454 }
455
456 WebInspector.Cookies.cookieMatchesResourceURL = function(cookie, resourceURL)
457 {
458     var match = resourceURL.match(WebInspector.URLRegExp);
459     if (!match)
460         return false;
461     // See WebInspector.URLRegExp for definitions of the group index constants.
462     if (!this.cookieDomainMatchesResourceDomain(cookie.domain, match[2]))
463         return false;
464     var resourcePort = match[3] ? match[3] : undefined;
465     var resourcePath = match[4] ? match[4] : '/';
466     return (resourcePath.indexOf(cookie.path) === 0
467         && (!cookie.port || resourcePort == cookie.port)
468         && (!cookie.secure || match[1].toLowerCase() === 'https'));
469 }
470
471 WebInspector.Cookies.cookieDomainMatchesResourceDomain = function(cookieDomain, resourceDomain)
472 {
473     if (cookieDomain.charAt(0) !== '.')
474         return resourceDomain === cookieDomain;
475     return !!resourceDomain.match(new RegExp("^([^\\.]+\\.)?" + cookieDomain.substring(1).escapeForRegExp() + "$"), "i");
476 }
477
478 WebInspector.EventListeners = {}
479
480 WebInspector.EventListeners.getEventListenersForNodeAsync = function(node, callback)
481 {
482     if (!node)
483         return;
484
485     var callId = WebInspector.Callback.wrap(callback);
486     InspectorBackend.getEventListenersForNode(callId, node.id);
487 }
488
489 WebInspector.CSSStyleDeclaration = function(payload)
490 {
491     this.id = payload.id;
492     this.width = payload.width;
493     this.height = payload.height;
494     this.__disabledProperties = {};
495     this.__disabledPropertyValues = {};
496     this.__disabledPropertyPriorities = {};
497     if (payload.disabled) {
498         var disabledProperties = payload.disabled.properties;
499         var shorthandValues = payload.disabled.shorthandValues;
500         for (var name in shorthandValues) {
501             this.__disabledProperties[name] = true;
502             this.__disabledPropertyValues[name] = shorthandValues[name];
503         }
504         for (var i = 0; i < disabledProperties.length; ++i) {
505             var disabledProperty = disabledProperties[i];
506             if (disabledProperty.shorthand)
507                 continue;
508             var name = disabledProperty.name;
509             this.__disabledProperties[name] = true;
510             this.__disabledPropertyValues[name] = disabledProperty.value;
511             this.__disabledPropertyPriorities[name] = disabledProperty.priority;
512         }
513     }
514     
515     this._shorthandValues = payload.shorthandValues;
516     this._propertyMap = {};
517     this._longhandProperties = {};
518     this.length = payload.properties.length;
519
520     for (var i = 0; i < this.length; ++i) {
521         var property = payload.properties[i];
522         var name = property.name;
523         this[i] = name;
524         this._propertyMap[name] = property;
525
526         // Index longhand properties.
527         if (property.shorthand) {
528             var longhands = this._longhandProperties[property.shorthand];
529             if (!longhands) {
530                 longhands = [];
531                 this._longhandProperties[property.shorthand] = longhands;
532             }
533             longhands.push(name);
534         }
535     }
536 }
537
538 WebInspector.CSSStyleDeclaration.parseStyle = function(payload)
539 {
540     return new WebInspector.CSSStyleDeclaration(payload);
541 }
542
543 WebInspector.CSSStyleDeclaration.parseRule = function(payload)
544 {
545     var rule = {};
546     rule.id = payload.id;
547     rule.selectorText = payload.selectorText;
548     rule.style = new WebInspector.CSSStyleDeclaration(payload.style);
549     rule.style.parentRule = rule;
550     rule.isUserAgent = payload.isUserAgent;
551     rule.isUser = payload.isUser;
552     rule.isViaInspector = payload.isViaInspector;
553     rule.sourceLine = payload.sourceLine;
554     if (payload.parentStyleSheet)
555         rule.parentStyleSheet = { href: payload.parentStyleSheet.href };
556
557     return rule;
558 }
559
560 WebInspector.CSSStyleDeclaration.prototype = {
561     getPropertyValue: function(name)
562     {
563         var property = this._propertyMap[name];
564         return property ? property.value : "";
565     },
566
567     getPropertyPriority: function(name)
568     {
569         var property = this._propertyMap[name];
570         return property ? property.priority : "";
571     },
572
573     getPropertyShorthand: function(name)
574     {
575         var property = this._propertyMap[name];
576         return property ? property.shorthand : "";
577     },
578
579     isPropertyImplicit: function(name)
580     {
581         var property = this._propertyMap[name];
582         return property ? property.implicit : "";
583     },
584
585     styleTextWithShorthands: function()
586     {
587         var cssText = "";
588         var foundProperties = {};
589         for (var i = 0; i < this.length; ++i) {
590             var individualProperty = this[i];
591             var shorthandProperty = this.getPropertyShorthand(individualProperty);
592             var propertyName = (shorthandProperty || individualProperty);
593
594             if (propertyName in foundProperties)
595                 continue;
596
597             if (shorthandProperty) {
598                 var value = this.getPropertyValue(shorthandProperty);
599                 var priority = this.getShorthandPriority(shorthandProperty);
600             } else {
601                 var value = this.getPropertyValue(individualProperty);
602                 var priority = this.getPropertyPriority(individualProperty);
603             }
604
605             foundProperties[propertyName] = true;
606
607             cssText += propertyName + ": " + value;
608             if (priority)
609                 cssText += " !" + priority;
610             cssText += "; ";
611         }
612
613         return cssText;
614     },
615
616     getLonghandProperties: function(name)
617     {
618         return this._longhandProperties[name] || [];
619     },
620
621     getShorthandValue: function(shorthandProperty)
622     {
623         return this._shorthandValues[shorthandProperty];
624     },
625
626     getShorthandPriority: function(shorthandProperty)
627     {
628         var priority = this.getPropertyPriority(shorthandProperty);
629         if (priority)
630             return priority;
631
632         var longhands = this._longhandProperties[shorthandProperty];
633         return longhands ? this.getPropertyPriority(longhands[0]) : null;
634     }
635 }
636
637 WebInspector.attributesUpdated = function()
638 {
639     this.domAgent._attributesUpdated.apply(this.domAgent, arguments);
640 }
641
642 WebInspector.setDocument = function()
643 {
644     this.domAgent._setDocument.apply(this.domAgent, arguments);
645 }
646
647 WebInspector.setDetachedRoot = function()
648 {
649     this.domAgent._setDetachedRoot.apply(this.domAgent, arguments);
650 }
651
652 WebInspector.setChildNodes = function()
653 {
654     this.domAgent._setChildNodes.apply(this.domAgent, arguments);
655 }
656
657 WebInspector.childNodeCountUpdated = function()
658 {
659     this.domAgent._childNodeCountUpdated.apply(this.domAgent, arguments);
660 }
661
662 WebInspector.childNodeInserted = function()
663 {
664     this.domAgent._childNodeInserted.apply(this.domAgent, arguments);
665 }
666
667 WebInspector.childNodeRemoved = function()
668 {
669     this.domAgent._childNodeRemoved.apply(this.domAgent, arguments);
670 }
671
672 WebInspector.didGetCookies = WebInspector.Callback.processCallback;
673 WebInspector.didGetChildNodes = WebInspector.Callback.processCallback;
674 WebInspector.didPerformSearch = WebInspector.Callback.processCallback;
675 WebInspector.didApplyDomChange = WebInspector.Callback.processCallback;
676 WebInspector.didRemoveAttribute = WebInspector.Callback.processCallback;
677 WebInspector.didSetTextNodeValue = WebInspector.Callback.processCallback;
678 WebInspector.didRemoveNode = WebInspector.Callback.processCallback;
679 WebInspector.didGetEventListenersForNode = WebInspector.Callback.processCallback;
680
681 WebInspector.didGetStyles = WebInspector.Callback.processCallback;
682 WebInspector.didGetAllStyles = WebInspector.Callback.processCallback;
683 WebInspector.didGetInlineStyle = WebInspector.Callback.processCallback;
684 WebInspector.didGetComputedStyle = WebInspector.Callback.processCallback;
685 WebInspector.didApplyStyleText = WebInspector.Callback.processCallback;
686 WebInspector.didSetStyleText = WebInspector.Callback.processCallback;
687 WebInspector.didSetStyleProperty = WebInspector.Callback.processCallback;
688 WebInspector.didToggleStyleEnabled = WebInspector.Callback.processCallback;
689 WebInspector.didSetRuleSelector = WebInspector.Callback.processCallback;
690 WebInspector.didAddRule = WebInspector.Callback.processCallback;