99a6d82b7b18470a83ae632f18751a112d3220b3
[WebKit.git] / Source / WebCore / dom / Element.cpp
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2001 Peter Kelly (pmk@post.com)
5  *           (C) 2001 Dirk Mueller (mueller@kde.org)
6  *           (C) 2007 David Smith (catfish.man@gmail.com)
7  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
8  *           (C) 2007 Eric Seidel (eric@webkit.org)
9  *
10  * This library is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Library General Public
12  * License as published by the Free Software Foundation; either
13  * version 2 of the License, or (at your option) any later version.
14  *
15  * This library is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Library General Public License for more details.
19  *
20  * You should have received a copy of the GNU Library General Public License
21  * along with this library; see the file COPYING.LIB.  If not, write to
22  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
23  * Boston, MA 02110-1301, USA.
24  */
25
26 #include "config.h"
27 #include "Element.h"
28
29 #include "AXObjectCache.h"
30 #include "Attr.h"
31 #include "CSSParser.h"
32 #include "CSSSelectorList.h"
33 #include "CSSStyleSelector.h"
34 #include "ClassList.h"
35 #include "ClientRect.h"
36 #include "ClientRectList.h"
37 #include "DOMTokenList.h"
38 #include "DatasetDOMStringMap.h"
39 #include "Document.h"
40 #include "DocumentFragment.h"
41 #include "ElementRareData.h"
42 #include "ExceptionCode.h"
43 #include "FocusController.h"
44 #include "Frame.h"
45 #include "FrameView.h"
46 #include "HTMLCollection.h"
47 #include "HTMLDocument.h"
48 #include "HTMLElement.h"
49 #include "HTMLFrameOwnerElement.h"
50 #include "HTMLNames.h"
51 #include "HTMLParserIdioms.h"
52 #include "InspectorInstrumentation.h"
53 #include "MutationObserverInterestGroup.h"
54 #include "MutationRecord.h"
55 #include "NodeList.h"
56 #include "NodeRenderStyle.h"
57 #include "NodeRenderingContext.h"
58 #include "Page.h"
59 #include "RenderLayer.h"
60 #include "RenderView.h"
61 #include "RenderWidget.h"
62 #include "Settings.h"
63 #include "ShadowRoot.h"
64 #include "Text.h"
65 #include "TextIterator.h"
66 #include "WebKitMutationObserver.h"
67 #include "WebKitAnimationList.h"
68 #include "XMLNSNames.h"
69 #include "XMLNames.h"
70 #include "htmlediting.h"
71 #include <wtf/text/CString.h>
72
73 #if ENABLE(SVG)
74 #include "SVGElement.h"
75 #include "SVGNames.h"
76 #endif
77
78 namespace WebCore {
79
80 using namespace HTMLNames;
81 using namespace XMLNames;
82     
83 class StyleSelectorParentPusher {
84 public:
85     StyleSelectorParentPusher(Element* parent)
86         : m_parent(parent)
87         , m_pushedStyleSelector(0)
88     {
89     }
90     void push()
91     {
92         if (m_pushedStyleSelector)
93             return;
94         m_pushedStyleSelector = m_parent->document()->styleSelector();
95         m_pushedStyleSelector->pushParent(m_parent);
96     }
97     ~StyleSelectorParentPusher() 
98     {
99
100         if (!m_pushedStyleSelector)
101             return;
102
103         // This tells us that our pushed style selector is in a bad state,
104         // so we should just bail out in that scenario.
105         ASSERT(m_pushedStyleSelector == m_parent->document()->styleSelector());
106         if (m_pushedStyleSelector != m_parent->document()->styleSelector())
107             return;
108
109         m_pushedStyleSelector->popParent(m_parent); 
110     }
111
112 private:
113     Element* m_parent;
114     CSSStyleSelector* m_pushedStyleSelector;
115 };
116
117 PassRefPtr<Element> Element::create(const QualifiedName& tagName, Document* document)
118 {
119     return adoptRef(new Element(tagName, document, CreateElement));
120 }
121
122 Element::~Element()
123 {
124     removeShadowRoot();
125     if (m_attributeMap)
126         m_attributeMap->detachFromElement();
127 }
128
129 inline ElementRareData* Element::rareData() const
130 {
131     ASSERT(hasRareData());
132     return static_cast<ElementRareData*>(NodeRareData::rareDataFromMap(this));
133 }
134     
135 inline ElementRareData* Element::ensureRareData()
136 {
137     return static_cast<ElementRareData*>(Node::ensureRareData());
138 }
139     
140 OwnPtr<NodeRareData> Element::createRareData()
141 {
142     return adoptPtr(new ElementRareData);
143 }
144
145 DEFINE_VIRTUAL_ATTRIBUTE_EVENT_LISTENER(Element, blur);
146 DEFINE_VIRTUAL_ATTRIBUTE_EVENT_LISTENER(Element, error);
147 DEFINE_VIRTUAL_ATTRIBUTE_EVENT_LISTENER(Element, focus);
148 DEFINE_VIRTUAL_ATTRIBUTE_EVENT_LISTENER(Element, load);
149
150 PassRefPtr<Node> Element::cloneNode(bool deep)
151 {
152     return deep ? cloneElementWithChildren() : cloneElementWithoutChildren();
153 }
154
155 PassRefPtr<Element> Element::cloneElementWithChildren()
156 {
157     RefPtr<Element> clone = cloneElementWithoutChildren();
158     cloneChildNodes(clone.get());
159     return clone.release();
160 }
161
162 PassRefPtr<Element> Element::cloneElementWithoutChildren()
163 {
164     RefPtr<Element> clone = cloneElementWithoutAttributesAndChildren();
165     // This will catch HTML elements in the wrong namespace that are not correctly copied.
166     // This is a sanity check as HTML overloads some of the DOM methods.
167     ASSERT(isHTMLElement() == clone->isHTMLElement());
168
169     clone->setAttributesFromElement(*this);
170     clone->copyNonAttributeProperties(this);
171
172     return clone.release();
173 }
174
175 PassRefPtr<Element> Element::cloneElementWithoutAttributesAndChildren()
176 {
177     return document()->createElement(tagQName(), false);
178 }
179
180 void Element::copyNonAttributeProperties(const Element*)
181 {
182 }
183
184 void Element::removeAttribute(const QualifiedName& name)
185 {
186     if (!m_attributeMap)
187         return;
188
189     m_attributeMap->removeAttribute(name);
190 }
191
192 void Element::setBooleanAttribute(const QualifiedName& name, bool value)
193 {
194     if (value)
195         setAttribute(name, emptyAtom);
196     else
197         removeAttribute(name);
198 }
199
200 Node::NodeType Element::nodeType() const
201 {
202     return ELEMENT_NODE;
203 }
204
205 bool Element::hasAttribute(const QualifiedName& name) const
206 {
207     return hasAttributeNS(name.namespaceURI(), name.localName());
208 }
209
210 const AtomicString& Element::getAttribute(const QualifiedName& name) const
211 {
212     if (UNLIKELY(name == styleAttr) && !isStyleAttributeValid())
213         updateStyleAttribute();
214
215 #if ENABLE(SVG)
216     if (UNLIKELY(!areSVGAttributesValid()))
217         updateAnimatedSVGAttribute(name);
218 #endif
219
220     if (m_attributeMap) {
221         if (Attribute* attribute = m_attributeMap->getAttributeItem(name))
222             return attribute->value();
223     }
224     return nullAtom;
225 }
226
227 void Element::scrollIntoView(bool alignToTop) 
228 {
229     document()->updateLayoutIgnorePendingStylesheets();
230
231     if (!renderer())
232         return;
233
234     LayoutRect bounds = getRect();
235     // Align to the top / bottom and to the closest edge.
236     if (alignToTop)
237         renderer()->enclosingLayer()->scrollRectToVisible(bounds, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignTopAlways);
238     else
239         renderer()->enclosingLayer()->scrollRectToVisible(bounds, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignBottomAlways);
240 }
241
242 void Element::scrollIntoViewIfNeeded(bool centerIfNeeded)
243 {
244     document()->updateLayoutIgnorePendingStylesheets();
245
246     if (!renderer())
247         return;
248
249     LayoutRect bounds = getRect();
250     if (centerIfNeeded)
251         renderer()->enclosingLayer()->scrollRectToVisible(bounds, ScrollAlignment::alignCenterIfNeeded, ScrollAlignment::alignCenterIfNeeded);
252     else
253         renderer()->enclosingLayer()->scrollRectToVisible(bounds, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignToEdgeIfNeeded);
254 }
255
256 void Element::scrollByUnits(int units, ScrollGranularity granularity)
257 {
258     document()->updateLayoutIgnorePendingStylesheets();
259
260     if (!renderer())
261         return;
262
263     if (!renderer()->hasOverflowClip())
264         return;
265
266     ScrollDirection direction = ScrollDown;
267     if (units < 0) {
268         direction = ScrollUp;
269         units = -units;
270     }
271     toRenderBox(renderer())->layer()->scroll(direction, granularity, units);
272 }
273
274 void Element::scrollByLines(int lines)
275 {
276     scrollByUnits(lines, ScrollByLine);
277 }
278
279 void Element::scrollByPages(int pages)
280 {
281     scrollByUnits(pages, ScrollByPage);
282 }
283
284 static float localZoomForRenderer(RenderObject* renderer)
285 {
286     // FIXME: This does the wrong thing if two opposing zooms are in effect and canceled each
287     // other out, but the alternative is that we'd have to crawl up the whole render tree every
288     // time (or store an additional bit in the RenderStyle to indicate that a zoom was specified).
289     float zoomFactor = 1;
290     if (renderer->style()->effectiveZoom() != 1) {
291         // Need to find the nearest enclosing RenderObject that set up
292         // a differing zoom, and then we divide our result by it to eliminate the zoom.
293         RenderObject* prev = renderer;
294         for (RenderObject* curr = prev->parent(); curr; curr = curr->parent()) {
295             if (curr->style()->effectiveZoom() != prev->style()->effectiveZoom()) {
296                 zoomFactor = prev->style()->zoom();
297                 break;
298             }
299             prev = curr;
300         }
301         if (prev->isRenderView())
302             zoomFactor = prev->style()->zoom();
303     }
304     return zoomFactor;
305 }
306
307 static LayoutUnit adjustForLocalZoom(LayoutUnit value, RenderObject* renderer)
308 {
309     float zoomFactor = localZoomForRenderer(renderer);
310     if (zoomFactor == 1)
311         return value;
312     // Needed because computeLengthInt truncates (rather than rounds) when scaling up.
313     if (zoomFactor > 1)
314         value++;
315     return static_cast<LayoutUnit>(value / zoomFactor);
316 }
317
318 int Element::offsetLeft()
319 {
320     document()->updateLayoutIgnorePendingStylesheets();
321     if (RenderBoxModelObject* rend = renderBoxModelObject())
322         return adjustForLocalZoom(rend->offsetLeft(), rend);
323     return 0;
324 }
325
326 int Element::offsetTop()
327 {
328     document()->updateLayoutIgnorePendingStylesheets();
329     if (RenderBoxModelObject* rend = renderBoxModelObject())
330         return adjustForLocalZoom(rend->offsetTop(), rend);
331     return 0;
332 }
333
334 int Element::offsetWidth()
335 {
336     document()->updateLayoutIgnorePendingStylesheets();
337     if (RenderBoxModelObject* rend = renderBoxModelObject())
338         return adjustForAbsoluteZoom(rend->offsetWidth(), rend);
339     return 0;
340 }
341
342 int Element::offsetHeight()
343 {
344     document()->updateLayoutIgnorePendingStylesheets();
345     if (RenderBoxModelObject* rend = renderBoxModelObject())
346         return adjustForAbsoluteZoom(rend->offsetHeight(), rend);
347     return 0;
348 }
349
350 Element* Element::offsetParent()
351 {
352     document()->updateLayoutIgnorePendingStylesheets();
353     if (RenderObject* rend = renderer())
354         if (RenderObject* offsetParent = rend->offsetParent())
355             return static_cast<Element*>(offsetParent->node());
356     return 0;
357 }
358
359 int Element::clientLeft()
360 {
361     document()->updateLayoutIgnorePendingStylesheets();
362
363     if (RenderBox* rend = renderBox())
364         return adjustForAbsoluteZoom(rend->clientLeft(), rend);
365     return 0;
366 }
367
368 int Element::clientTop()
369 {
370     document()->updateLayoutIgnorePendingStylesheets();
371
372     if (RenderBox* rend = renderBox())
373         return adjustForAbsoluteZoom(rend->clientTop(), rend);
374     return 0;
375 }
376
377 int Element::clientWidth()
378 {
379     document()->updateLayoutIgnorePendingStylesheets();
380
381     // When in strict mode, clientWidth for the document element should return the width of the containing frame.
382     // When in quirks mode, clientWidth for the body element should return the width of the containing frame.
383     bool inQuirksMode = document()->inQuirksMode();
384     if ((!inQuirksMode && document()->documentElement() == this) ||
385         (inQuirksMode && isHTMLElement() && document()->body() == this)) {
386         if (FrameView* view = document()->view()) {
387             if (RenderView* renderView = document()->renderView())
388                 return adjustForAbsoluteZoom(view->layoutWidth(), renderView);
389         }
390     }
391     
392     if (RenderBox* rend = renderBox())
393         return adjustForAbsoluteZoom(rend->clientWidth(), rend);
394     return 0;
395 }
396
397 int Element::clientHeight()
398 {
399     document()->updateLayoutIgnorePendingStylesheets();
400
401     // When in strict mode, clientHeight for the document element should return the height of the containing frame.
402     // When in quirks mode, clientHeight for the body element should return the height of the containing frame.
403     bool inQuirksMode = document()->inQuirksMode();     
404
405     if ((!inQuirksMode && document()->documentElement() == this) ||
406         (inQuirksMode && isHTMLElement() && document()->body() == this)) {
407         if (FrameView* view = document()->view()) {
408             if (RenderView* renderView = document()->renderView())
409                 return adjustForAbsoluteZoom(view->layoutHeight(), renderView);
410         }
411     }
412     
413     if (RenderBox* rend = renderBox())
414         return adjustForAbsoluteZoom(rend->clientHeight(), rend);
415     return 0;
416 }
417
418 int Element::scrollLeft()
419 {
420     document()->updateLayoutIgnorePendingStylesheets();
421     if (RenderBox* rend = renderBox())
422         return adjustForAbsoluteZoom(rend->scrollLeft(), rend);
423     return 0;
424 }
425
426 int Element::scrollTop()
427 {
428     document()->updateLayoutIgnorePendingStylesheets();
429     if (RenderBox* rend = renderBox())
430         return adjustForAbsoluteZoom(rend->scrollTop(), rend);
431     return 0;
432 }
433
434 void Element::setScrollLeft(int newLeft)
435 {
436     document()->updateLayoutIgnorePendingStylesheets();
437     if (RenderBox* rend = renderBox())
438         rend->setScrollLeft(static_cast<int>(newLeft * rend->style()->effectiveZoom()));
439 }
440
441 void Element::setScrollTop(int newTop)
442 {
443     document()->updateLayoutIgnorePendingStylesheets();
444     if (RenderBox* rend = renderBox())
445         rend->setScrollTop(static_cast<int>(newTop * rend->style()->effectiveZoom()));
446 }
447
448 int Element::scrollWidth()
449 {
450     document()->updateLayoutIgnorePendingStylesheets();
451     if (RenderBox* rend = renderBox())
452         return adjustForAbsoluteZoom(rend->scrollWidth(), rend);
453     return 0;
454 }
455
456 int Element::scrollHeight()
457 {
458     document()->updateLayoutIgnorePendingStylesheets();
459     if (RenderBox* rend = renderBox())
460         return adjustForAbsoluteZoom(rend->scrollHeight(), rend);
461     return 0;
462 }
463
464 LayoutRect Element::boundsInRootViewSpace()
465 {
466     document()->updateLayoutIgnorePendingStylesheets();
467
468     FrameView* view = document()->view();
469     if (!view)
470         return LayoutRect();
471
472     Vector<FloatQuad> quads;
473 #if ENABLE(SVG)
474     if (isSVGElement() && renderer()) {
475         // Get the bounding rectangle from the SVG model.
476         SVGElement* svgElement = static_cast<SVGElement*>(this);
477         FloatRect localRect;
478         if (svgElement->boundingBox(localRect))
479             quads.append(renderer()->localToAbsoluteQuad(localRect));
480     } else
481 #endif
482     {
483         // Get the bounding rectangle from the box model.
484         if (renderBoxModelObject())
485             renderBoxModelObject()->absoluteQuads(quads);
486     }
487
488     if (quads.isEmpty())
489         return LayoutRect();
490
491     LayoutRect result = quads[0].enclosingBoundingBox();
492     for (size_t i = 1; i < quads.size(); ++i)
493         result.unite(quads[i].enclosingBoundingBox());
494
495     result = view->contentsToRootView(result);
496     return result;
497 }
498
499 PassRefPtr<ClientRectList> Element::getClientRects()
500 {
501     document()->updateLayoutIgnorePendingStylesheets();
502
503     RenderBoxModelObject* renderBoxModelObject = this->renderBoxModelObject();
504     if (!renderBoxModelObject)
505         return ClientRectList::create();
506
507     // FIXME: Handle SVG elements.
508     // FIXME: Handle table/inline-table with a caption.
509
510     Vector<FloatQuad> quads;
511     renderBoxModelObject->absoluteQuads(quads);
512
513     float pageScale = 1;
514     if (Page* page = document()->page()) 
515         pageScale = page->pageScaleFactor();
516
517     if (FrameView* view = document()->view()) {
518         LayoutRect visibleContentRect = view->visibleContentRect();
519         for (size_t i = 0; i < quads.size(); ++i) {
520             quads[i].move(-visibleContentRect.x(), -visibleContentRect.y());
521             adjustFloatQuadForAbsoluteZoom(quads[i], renderBoxModelObject);
522             if (pageScale != 1)
523                 adjustFloatQuadForPageScale(quads[i], pageScale);
524         }
525     }
526
527     return ClientRectList::create(quads);
528 }
529
530 PassRefPtr<ClientRect> Element::getBoundingClientRect()
531 {
532     document()->updateLayoutIgnorePendingStylesheets();
533
534     Vector<FloatQuad> quads;
535 #if ENABLE(SVG)
536     if (isSVGElement() && renderer()) {
537         // Get the bounding rectangle from the SVG model.
538         SVGElement* svgElement = static_cast<SVGElement*>(this);
539         FloatRect localRect;
540         if (svgElement->boundingBox(localRect))
541             quads.append(renderer()->localToAbsoluteQuad(localRect));
542     } else
543 #endif
544     {
545         // Get the bounding rectangle from the box model.
546         if (renderBoxModelObject())
547             renderBoxModelObject()->absoluteQuads(quads);
548     }
549
550     if (quads.isEmpty())
551         return ClientRect::create();
552
553     FloatRect result = quads[0].boundingBox();
554     for (size_t i = 1; i < quads.size(); ++i)
555         result.unite(quads[i].boundingBox());
556
557     if (FrameView* view = document()->view()) {
558         LayoutRect visibleContentRect = view->visibleContentRect();
559         result.move(-visibleContentRect.x(), -visibleContentRect.y());
560     }
561
562     adjustFloatRectForAbsoluteZoom(result, renderer());
563     if (Page* page = document()->page())
564         adjustFloatRectForPageScale(result, page->pageScaleFactor());
565
566     return ClientRect::create(result);
567 }
568     
569 LayoutRect Element::screenRect() const
570 {
571     if (!renderer())
572         return LayoutRect();
573     // FIXME: this should probably respect transforms
574     return renderer()->view()->frameView()->contentsToScreen(renderer()->absoluteBoundingBoxRectIgnoringTransforms());
575 }
576
577 static inline bool shouldIgnoreAttributeCase(const Element* e)
578 {
579     return e && e->document()->isHTMLDocument() && e->isHTMLElement();
580 }
581
582 const AtomicString& Element::getAttribute(const String& name) const
583 {
584     bool ignoreCase = shouldIgnoreAttributeCase(this);
585     
586     // Update the 'style' attribute if it's invalid and being requested:
587     if (!isStyleAttributeValid() && equalPossiblyIgnoringCase(name, styleAttr.localName(), ignoreCase))
588         updateStyleAttribute();
589
590 #if ENABLE(SVG)
591     if (!areSVGAttributesValid()) {
592         // We're not passing a namespace argument on purpose. SVGNames::*Attr are defined w/o namespaces as well.
593         updateAnimatedSVGAttribute(QualifiedName(nullAtom, name, nullAtom));
594     }
595 #endif
596
597     if (m_attributeMap) {
598         if (Attribute* attribute = m_attributeMap->getAttributeItem(name, ignoreCase))
599             return attribute->value();
600     }
601
602     return nullAtom;
603 }
604
605 const AtomicString& Element::getAttributeNS(const String& namespaceURI, const String& localName) const
606 {
607     return getAttribute(QualifiedName(nullAtom, localName, namespaceURI));
608 }
609
610 void Element::setAttribute(const AtomicString& name, const AtomicString& value, ExceptionCode& ec)
611 {
612     if (!Document::isValidName(name)) {
613         ec = INVALID_CHARACTER_ERR;
614         return;
615     }
616
617     const AtomicString& localName = shouldIgnoreAttributeCase(this) ? name.lower() : name;
618
619     size_t index = ensureUpdatedAttributes()->getAttributeItemIndex(localName, false);
620     const QualifiedName& qName = index != notFound ? m_attributeMap->attributeItem(index)->name() : QualifiedName(nullAtom, localName, nullAtom);
621     setAttributeInternal(index, qName, value);
622 }
623
624 void Element::setAttribute(const QualifiedName& name, const AtomicString& value)
625 {
626     setAttributeInternal(ensureUpdatedAttributes()->getAttributeItemIndex(name), name, value);
627 }
628
629 inline void Element::setAttributeInternal(size_t index, const QualifiedName& name, const AtomicString& value)
630 {
631     Attribute* old = index != notFound ? m_attributeMap->attributeItem(index) : 0;
632     if (value.isNull()) {
633         if (old)
634             m_attributeMap->removeAttribute(index);
635         return;
636     }
637
638     if (!old) {
639         m_attributeMap->addAttribute(createAttribute(name, value));
640         return;
641     }
642
643     willModifyAttribute(name, old ? old->value() : nullAtom, value);
644
645     if (Attr* attrNode = old->attr())
646         attrNode->setValue(value);
647     else
648         old->setValue(value);
649
650     didModifyAttribute(old);
651 }
652
653 PassRefPtr<Attribute> Element::createAttribute(const QualifiedName& name, const AtomicString& value)
654 {
655     return Attribute::create(name, value);
656 }
657
658 void Element::attributeChanged(Attribute* attr)
659 {
660     if (isIdAttributeName(attr->name()))
661         idAttributeChanged(attr);
662     recalcStyleIfNeededAfterAttributeChanged(attr);
663     updateAfterAttributeChanged(attr);
664 }
665
666 void Element::updateAfterAttributeChanged(Attribute* attr)
667 {
668     invalidateNodeListsCacheAfterAttributeChanged(attr->name());
669
670     if (!AXObjectCache::accessibilityEnabled())
671         return;
672
673     const QualifiedName& attrName = attr->name();
674     if (attrName == aria_activedescendantAttr) {
675         // any change to aria-activedescendant attribute triggers accessibility focus change, but document focus remains intact
676         document()->axObjectCache()->handleActiveDescendantChanged(renderer());
677     } else if (attrName == roleAttr) {
678         // the role attribute can change at any time, and the AccessibilityObject must pick up these changes
679         document()->axObjectCache()->handleAriaRoleChanged(renderer());
680     } else if (attrName == aria_valuenowAttr) {
681         // If the valuenow attribute changes, AX clients need to be notified.
682         document()->axObjectCache()->postNotification(renderer(), AXObjectCache::AXValueChanged, true);
683     } else if (attrName == aria_labelAttr || attrName == aria_labeledbyAttr || attrName == altAttr || attrName == titleAttr) {
684         // If the content of an element changes due to an attribute change, notify accessibility.
685         document()->axObjectCache()->contentChanged(renderer());
686     } else if (attrName == aria_checkedAttr)
687         document()->axObjectCache()->checkedStateChanged(renderer());
688     else if (attrName == aria_selectedAttr)
689         document()->axObjectCache()->selectedChildrenChanged(renderer());
690     else if (attrName == aria_expandedAttr)
691         document()->axObjectCache()->handleAriaExpandedChange(renderer());
692     else if (attrName == aria_hiddenAttr)
693         document()->axObjectCache()->childrenChanged(renderer());
694     else if (attrName == aria_invalidAttr)
695         document()->axObjectCache()->postNotification(renderer(), AXObjectCache::AXInvalidStatusChanged, true);
696 }
697     
698 void Element::recalcStyleIfNeededAfterAttributeChanged(Attribute* attr)
699 {
700     if (needsStyleRecalc())
701         return;
702     if (!document()->attached())
703         return;
704     CSSStyleSelector* styleSelector = document()->styleSelectorIfExists();
705     if (styleSelector && !styleSelector->hasSelectorForAttribute(attr->name().localName()))
706         return;
707     setNeedsStyleRecalc();
708 }
709
710 void Element::idAttributeChanged(Attribute* attr)
711 {
712     setHasID(!attr->isNull());
713     if (attributeData()) {
714         if (attr->isNull())
715             attributeData()->setIdForStyleResolution(nullAtom);
716         else if (document()->inQuirksMode())
717             attributeData()->setIdForStyleResolution(attr->value().lower());
718         else
719             attributeData()->setIdForStyleResolution(attr->value());
720     }
721     setNeedsStyleRecalc();
722 }
723     
724 // Returns true is the given attribute is an event handler.
725 // We consider an event handler any attribute that begins with "on".
726 // It is a simple solution that has the advantage of not requiring any
727 // code or configuration change if a new event handler is defined.
728
729 static bool isEventHandlerAttribute(const QualifiedName& name)
730 {
731     return name.namespaceURI().isNull() && name.localName().startsWith("on");
732 }
733
734 static bool isAttributeToRemove(const QualifiedName& name, const AtomicString& value)
735 {    
736     return (name.localName().endsWith(hrefAttr.localName()) || name == srcAttr || name == actionAttr) && protocolIsJavaScript(stripLeadingAndTrailingHTMLSpaces(value));       
737 }
738
739 void Element::parserSetAttributeMap(PassOwnPtr<NamedNodeMap> list, FragmentScriptingPermission scriptingPermission)
740 {
741     ASSERT(!inDocument());
742     ASSERT(!parentNode());
743
744     document()->incDOMTreeVersion();
745
746     ASSERT(!m_attributeMap);
747     m_attributeMap = list;
748
749     if (m_attributeMap) {
750         m_attributeMap->m_element = this;
751         // If the element is created as result of a paste or drag-n-drop operation
752         // we want to remove all the script and event handlers.
753         if (scriptingPermission == FragmentScriptingNotAllowed) {
754             unsigned i = 0;
755             while (i < m_attributeMap->length()) {
756                 const QualifiedName& attributeName = m_attributeMap->m_attributes[i]->name();
757                 if (isEventHandlerAttribute(attributeName)) {
758                     m_attributeMap->m_attributes.remove(i);
759                     continue;
760                 }
761
762                 if (isAttributeToRemove(attributeName, m_attributeMap->m_attributes[i]->value()))
763                     m_attributeMap->m_attributes[i]->setValue(nullAtom);
764                 i++;
765             }
766         }
767         // Store the set of attributes that changed on the stack in case
768         // attributeChanged mutates m_attributeMap.
769         Vector<RefPtr<Attribute> > attributes;
770         m_attributeMap->copyAttributesToVector(attributes);
771         for (Vector<RefPtr<Attribute> >::iterator iter = attributes.begin(); iter != attributes.end(); ++iter)
772             attributeChanged(iter->get());
773     }
774 }
775
776 bool Element::hasAttributes() const
777 {
778     updateInvalidAttributes();
779     return m_attributeMap && m_attributeMap->length();
780 }
781
782 String Element::nodeName() const
783 {
784     return m_tagName.toString();
785 }
786
787 String Element::nodeNamePreservingCase() const
788 {
789     return m_tagName.toString();
790 }
791
792 void Element::setPrefix(const AtomicString& prefix, ExceptionCode& ec)
793 {
794     ec = 0;
795     checkSetPrefix(prefix, ec);
796     if (ec)
797         return;
798
799     m_tagName.setPrefix(prefix.isEmpty() ? AtomicString() : prefix);
800 }
801
802 KURL Element::baseURI() const
803 {
804     const AtomicString& baseAttribute = getAttribute(baseAttr);
805     KURL base(KURL(), baseAttribute);
806     if (!base.protocol().isEmpty())
807         return base;
808
809     ContainerNode* parent = parentNode();
810     if (!parent)
811         return base;
812
813     const KURL& parentBase = parent->baseURI();
814     if (parentBase.isNull())
815         return base;
816
817     return KURL(parentBase, baseAttribute);
818 }
819
820 void Element::createAttributeMap() const
821 {
822     m_attributeMap = NamedNodeMap::create(const_cast<Element*>(this));
823 }
824
825 bool Element::isURLAttribute(Attribute*) const
826 {
827     return false;
828 }
829
830 const QualifiedName& Element::imageSourceAttributeName() const
831 {
832     return srcAttr;
833 }
834
835 RenderObject* Element::createRenderer(RenderArena* arena, RenderStyle* style)
836 {
837     if (document()->documentElement() == this && style->display() == NONE) {
838         // Ignore display: none on root elements.  Force a display of block in that case.
839         RenderBlock* result = new (arena) RenderBlock(this);
840         if (result)
841             result->setAnimatableStyle(style);
842         return result;
843     }
844     return RenderObject::createObject(this, style);
845 }
846
847 bool Element::wasChangedSinceLastFormControlChangeEvent() const
848 {
849     return false;
850 }
851
852 void Element::setChangedSinceLastFormControlChangeEvent(bool)
853 {
854 }
855
856 void Element::willRemove()
857 {
858 #if ENABLE(FULLSCREEN_API)
859     if (containsFullScreenElement())
860         setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(false);
861 #endif
862     ContainerNode::willRemove();
863 }
864
865 void Element::insertedIntoDocument()
866 {
867     // need to do superclass processing first so inDocument() is true
868     // by the time we reach updateId
869     ContainerNode::insertedIntoDocument();
870     if (ShadowRoot* shadow = shadowRoot())
871         shadow->insertedIntoDocument();
872
873     if (m_attributeMap) {
874         if (hasID()) {
875             Attribute* idItem = m_attributeMap->getAttributeItem(document()->idAttributeName());
876             if (idItem && !idItem->isNull())
877                 updateId(nullAtom, idItem->value());
878         }
879         if (hasName()) {
880             Attribute* nameItem = m_attributeMap->getAttributeItem(HTMLNames::nameAttr);
881             if (nameItem && !nameItem->isNull())
882                 updateName(nullAtom, nameItem->value());
883         }
884     }
885 }
886
887 void Element::removedFromDocument()
888 {
889     if (m_attributeMap) {
890         if (hasID()) {
891             Attribute* idItem = m_attributeMap->getAttributeItem(document()->idAttributeName());
892             if (idItem && !idItem->isNull())
893                 updateId(idItem->value(), nullAtom);
894         }
895         if (hasName()) {
896             Attribute* nameItem = m_attributeMap->getAttributeItem(HTMLNames::nameAttr);
897             if (nameItem && !nameItem->isNull())
898                 updateName(nameItem->value(), nullAtom);
899         }
900     }
901
902     ContainerNode::removedFromDocument();
903     if (ShadowRoot* shadow = shadowRoot())
904         shadow->removedFromDocument();
905 }
906
907 void Element::insertedIntoTree(bool deep)
908 {
909     ContainerNode::insertedIntoTree(deep);
910     if (!deep)
911         return;
912     if (ShadowRoot* shadow = shadowRoot())
913         shadow->insertedIntoTree(true);
914
915 #if ENABLE(FULLSCREEN_API)
916     if (containsFullScreenElement() && parentElement() && !parentElement()->containsFullScreenElement())
917         setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(true);
918 #endif
919 }
920
921 void Element::removedFromTree(bool deep)
922 {
923     ContainerNode::removedFromTree(deep);
924     if (!deep)
925         return;
926     if (ShadowRoot* shadow = shadowRoot())
927         shadow->removedFromTree(true);
928 }
929
930 void Element::attach()
931 {
932     suspendPostAttachCallbacks();
933     RenderWidget::suspendWidgetHierarchyUpdates();
934
935     createRendererIfNeeded();
936     StyleSelectorParentPusher parentPusher(this);
937
938     // When a shadow root exists, it does the work of attaching the children.
939     if (ShadowRoot* shadow = shadowRoot()) {
940         parentPusher.push();
941         Node::attach();
942         shadow->attach();
943
944         // In a shadow tree, some of light children may be attached by 'content' element.
945         // However, when there is no content element or content element does not select
946         // all light children, we have to attach the rest of light children here.
947         for (Node* child = firstChild(); child; child = child->nextSibling()) {
948             if (!child->attached())
949                 child->attach();
950         }
951     } else {
952         if (firstChild())
953             parentPusher.push();
954         ContainerNode::attach();
955     }
956
957     if (hasRareData()) {   
958         ElementRareData* data = rareData();
959         if (data->needsFocusAppearanceUpdateSoonAfterAttach()) {
960             if (isFocusable() && document()->focusedNode() == this)
961                 document()->updateFocusAppearanceSoon(false /* don't restore selection */);
962             data->setNeedsFocusAppearanceUpdateSoonAfterAttach(false);
963         }
964     }
965
966     RenderWidget::resumeWidgetHierarchyUpdates();
967     resumePostAttachCallbacks();
968 }
969
970 void Element::detach()
971 {
972     RenderWidget::suspendWidgetHierarchyUpdates();
973
974     cancelFocusAppearanceUpdate();
975     if (hasRareData())
976         rareData()->resetComputedStyle();
977     ContainerNode::detach();
978     if (ShadowRoot* shadow = shadowRoot())
979         shadow->detach();
980
981     RenderWidget::resumeWidgetHierarchyUpdates();
982 }
983
984 bool Element::pseudoStyleCacheIsInvalid(const RenderStyle* currentStyle, RenderStyle* newStyle)
985 {
986     ASSERT(currentStyle == renderStyle());
987
988     if (!renderer() || !currentStyle)
989         return false;
990
991     const PseudoStyleCache* pseudoStyleCache = currentStyle->cachedPseudoStyles();
992     if (!pseudoStyleCache)
993         return false;
994
995     size_t cacheSize = pseudoStyleCache->size();
996     for (size_t i = 0; i < cacheSize; ++i) {
997         RefPtr<RenderStyle> newPseudoStyle;
998         PseudoId pseudoId = pseudoStyleCache->at(i)->styleType();
999         if (pseudoId == FIRST_LINE || pseudoId == FIRST_LINE_INHERITED)
1000             newPseudoStyle = renderer()->uncachedFirstLineStyle(newStyle);
1001         else
1002             newPseudoStyle = renderer()->getUncachedPseudoStyle(pseudoId, newStyle, newStyle);
1003         if (!newPseudoStyle)
1004             return true;
1005         if (*newPseudoStyle != *pseudoStyleCache->at(i)) {
1006             if (pseudoId < FIRST_INTERNAL_PSEUDOID)
1007                 newStyle->setHasPseudoStyle(pseudoId);
1008             newStyle->addCachedPseudoStyle(newPseudoStyle);
1009             if (pseudoId == FIRST_LINE || pseudoId == FIRST_LINE_INHERITED) {
1010                 // FIXME: We should do an actual diff to determine whether a repaint vs. layout
1011                 // is needed, but for now just assume a layout will be required.  The diff code
1012                 // in RenderObject::setStyle would need to be factored out so that it could be reused.
1013                 renderer()->setNeedsLayoutAndPrefWidthsRecalc();
1014             }
1015             return true;
1016         }
1017     }
1018     return false;
1019 }
1020
1021 PassRefPtr<RenderStyle> Element::customStyleForRenderer()
1022 {
1023     ASSERT_NOT_REACHED(); 
1024     return 0; 
1025 }
1026
1027 PassRefPtr<RenderStyle> Element::styleForRenderer()
1028 {
1029     if (hasCustomStyleForRenderer())
1030         return customStyleForRenderer();
1031     return document()->styleSelector()->styleForElement(static_cast<Element*>(this), 0, true/*allowSharing*/);
1032 }
1033
1034 void Element::recalcStyle(StyleChange change)
1035 {
1036     if (hasCustomWillOrDidRecalcStyle()) {
1037         if (!willRecalcStyle(change))
1038             return;
1039     }
1040
1041     // Ref currentStyle in case it would otherwise be deleted when setRenderStyle() is called.
1042     RefPtr<RenderStyle> currentStyle(renderStyle());
1043     bool hasParentStyle = parentNodeForRenderingAndStyle() ? static_cast<bool>(parentNodeForRenderingAndStyle()->renderStyle()) : false;
1044     bool hasDirectAdjacentRules = currentStyle && currentStyle->childrenAffectedByDirectAdjacentRules();
1045     bool hasIndirectAdjacentRules = currentStyle && currentStyle->childrenAffectedByForwardPositionalRules();
1046
1047     if ((change > NoChange || needsStyleRecalc())) {
1048         if (hasRareData()) {
1049             ElementRareData* data = rareData();
1050             data->resetComputedStyle();
1051             data->m_styleAffectedByEmpty = false;
1052         }
1053     }
1054     if (hasParentStyle && (change >= Inherit || needsStyleRecalc())) {
1055         RefPtr<RenderStyle> newStyle = styleForRenderer();
1056         StyleChange ch = diff(currentStyle.get(), newStyle.get());
1057         if (ch == Detach || !currentStyle) {
1058             // FIXME: The style gets computed twice by calling attach. We could do better if we passed the style along.
1059             reattach();
1060             // attach recalculates the style for all children. No need to do it twice.
1061             clearNeedsStyleRecalc();
1062             clearChildNeedsStyleRecalc();
1063
1064             if (hasCustomWillOrDidRecalcStyle())
1065                 didRecalcStyle(change);
1066             return;
1067         }
1068
1069         if (currentStyle) {
1070             // Preserve "affected by" bits that were propagated to us from descendants in the case where we didn't do a full
1071             // style change (e.g., only inline style changed).
1072             if (currentStyle->affectedByHoverRules())
1073                 newStyle->setAffectedByHoverRules(true);
1074             if (currentStyle->affectedByActiveRules())
1075                 newStyle->setAffectedByActiveRules(true);
1076             if (currentStyle->affectedByDragRules())
1077                 newStyle->setAffectedByDragRules(true);
1078             if (currentStyle->childrenAffectedByForwardPositionalRules())
1079                 newStyle->setChildrenAffectedByForwardPositionalRules();
1080             if (currentStyle->childrenAffectedByBackwardPositionalRules())
1081                 newStyle->setChildrenAffectedByBackwardPositionalRules();
1082             if (currentStyle->childrenAffectedByFirstChildRules())
1083                 newStyle->setChildrenAffectedByFirstChildRules();
1084             if (currentStyle->childrenAffectedByLastChildRules())
1085                 newStyle->setChildrenAffectedByLastChildRules();
1086             if (currentStyle->childrenAffectedByDirectAdjacentRules())
1087                 newStyle->setChildrenAffectedByDirectAdjacentRules();
1088         }
1089
1090         if (ch != NoChange || pseudoStyleCacheIsInvalid(currentStyle.get(), newStyle.get()) || (change == Force && renderer() && renderer()->requiresForcedStyleRecalcPropagation())) {
1091             setRenderStyle(newStyle);
1092         } else if (needsStyleRecalc() && styleChangeType() != SyntheticStyleChange) {
1093             // Although no change occurred, we use the new style so that the cousin style sharing code won't get
1094             // fooled into believing this style is the same.
1095             if (renderer())
1096                 renderer()->setStyleInternal(newStyle.get());
1097             else
1098                 setRenderStyle(newStyle);
1099         } else if (styleChangeType() == SyntheticStyleChange)
1100              setRenderStyle(newStyle);
1101
1102         if (change != Force) {
1103             // If "rem" units are used anywhere in the document, and if the document element's font size changes, then go ahead and force font updating
1104             // all the way down the tree.  This is simpler than having to maintain a cache of objects (and such font size changes should be rare anyway).
1105             if (document()->usesRemUnits() && ch != NoChange && currentStyle && newStyle && currentStyle->fontSize() != newStyle->fontSize() && document()->documentElement() == this)
1106                 change = Force;
1107             else if (styleChangeType() >= FullStyleChange)
1108                 change = Force;
1109             else
1110                 change = ch;
1111         }
1112     }
1113     StyleSelectorParentPusher parentPusher(this);
1114     // FIXME: This check is good enough for :hover + foo, but it is not good enough for :hover + foo + bar.
1115     // For now we will just worry about the common case, since it's a lot trickier to get the second case right
1116     // without doing way too much re-resolution.
1117     bool forceCheckOfNextElementSibling = false;
1118     bool forceCheckOfAnyElementSibling = false;
1119     for (Node *n = firstChild(); n; n = n->nextSibling()) {
1120         if (n->isTextNode()) {
1121             static_cast<Text*>(n)->recalcTextStyle(change);
1122             continue;
1123         } 
1124         if (!n->isElementNode()) 
1125             continue;
1126         Element* element = static_cast<Element*>(n);
1127         bool childRulesChanged = element->needsStyleRecalc() && element->styleChangeType() == FullStyleChange;
1128         if ((forceCheckOfNextElementSibling || forceCheckOfAnyElementSibling))
1129             element->setNeedsStyleRecalc();
1130         if (change >= Inherit || element->childNeedsStyleRecalc() || element->needsStyleRecalc()) {
1131             parentPusher.push();
1132             element->recalcStyle(change);
1133         }
1134         forceCheckOfNextElementSibling = childRulesChanged && hasDirectAdjacentRules;
1135         forceCheckOfAnyElementSibling = forceCheckOfAnyElementSibling || (childRulesChanged && hasIndirectAdjacentRules);
1136     }
1137     // FIXME: This does not care about sibling combinators. Will be necessary in XBL2 world.
1138     if (ShadowRoot* shadow = shadowRoot()) {
1139         if (change >= Inherit || shadow->childNeedsStyleRecalc() || shadow->needsStyleRecalc()) {
1140             parentPusher.push();
1141             shadow->recalcShadowTreeStyle(change);
1142         }
1143     }
1144
1145     clearNeedsStyleRecalc();
1146     clearChildNeedsStyleRecalc();
1147     
1148     if (hasCustomWillOrDidRecalcStyle())
1149         didRecalcStyle(change);
1150 }
1151
1152 ShadowRoot* Element::shadowRoot() const
1153 {
1154     return hasRareData() ? rareData()->m_shadowRoot : 0;
1155 }
1156
1157 static bool validateShadowRoot(Document* document, ShadowRoot* shadowRoot, ExceptionCode& ec)
1158 {
1159     if (!shadowRoot)
1160         return true;
1161
1162     if (shadowRoot->shadowHost()) {
1163         ec = HIERARCHY_REQUEST_ERR;
1164         return false;
1165     }
1166
1167     if (shadowRoot->document() != document) {
1168         ec = WRONG_DOCUMENT_ERR;
1169         return false;
1170     }
1171
1172     return true;
1173 }
1174
1175 void Element::setShadowRoot(PassRefPtr<ShadowRoot> prpShadowRoot, ExceptionCode& ec)
1176 {
1177     RefPtr<ShadowRoot> shadowRoot = prpShadowRoot;
1178     if (!validateShadowRoot(document(), shadowRoot.get(), ec))
1179         return;
1180
1181     removeShadowRoot();
1182
1183     ensureRareData()->m_shadowRoot = shadowRoot.get();
1184     shadowRoot->setShadowHost(this);
1185     if (inDocument())
1186         shadowRoot->insertedIntoDocument();
1187     if (attached()) {
1188         shadowRoot->lazyAttach();
1189         for (Node* child = firstChild(); child; child = child->nextSibling())
1190             child->detach();
1191     }
1192 }
1193
1194 ShadowRoot* Element::ensureShadowRoot()
1195 {
1196     if (ShadowRoot* existingRoot = shadowRoot())
1197         return existingRoot;
1198
1199     ExceptionCode ec = 0;
1200     setShadowRoot(ShadowRoot::create(document()), ec);
1201     ASSERT(!ec);
1202     return shadowRoot();
1203 }
1204
1205 void Element::removeShadowRoot()
1206 {
1207     if (!hasRareData())
1208         return;
1209
1210     ElementRareData* data = rareData();
1211     if (RefPtr<ShadowRoot> oldRoot = data->m_shadowRoot) {
1212         data->m_shadowRoot = 0;
1213         document()->removeFocusedNodeOfSubtree(oldRoot.get());
1214
1215         // Remove from rendering tree
1216         if (oldRoot->attached())
1217             oldRoot->detach();
1218
1219         oldRoot->setShadowHost(0);
1220         document()->adoptIfNeeded(oldRoot.get());
1221         if (oldRoot->inDocument())
1222             oldRoot->removedFromDocument();
1223         else
1224             oldRoot->removedFromTree(true);
1225         if (attached()) {
1226             for (Node* child = firstChild(); child; child = child->nextSibling())
1227                 if (!child->attached())
1228                     child->lazyAttach();
1229         }
1230     }
1231 }
1232
1233 const AtomicString& Element::shadowPseudoId() const
1234 {
1235     return hasRareData() ? rareData()->m_shadowPseudoId : nullAtom;
1236 }
1237
1238 void Element::setShadowPseudoId(const AtomicString& id, ExceptionCode& ec)
1239 {
1240     if (!hasRareData() && id == nullAtom)
1241         return;
1242
1243     if (!CSSSelector::isUnknownPseudoType(id)) {
1244         ec = SYNTAX_ERR;
1245         return;
1246     }
1247
1248     ensureRareData()->m_shadowPseudoId = id;
1249 }
1250
1251 bool Element::childTypeAllowed(NodeType type) const
1252 {
1253     switch (type) {
1254     case ELEMENT_NODE:
1255     case TEXT_NODE:
1256     case COMMENT_NODE:
1257     case PROCESSING_INSTRUCTION_NODE:
1258     case CDATA_SECTION_NODE:
1259     case ENTITY_REFERENCE_NODE:
1260         return true;
1261     default:
1262         break;
1263     }
1264     return false;
1265 }
1266
1267 static void checkForEmptyStyleChange(Element* element, RenderStyle* style)
1268 {
1269     if (!style && !element->styleAffectedByEmpty())
1270         return;
1271
1272     if (!style || (style->affectedByEmpty() && (!style->emptyState() || element->hasChildNodes())))
1273         element->setNeedsStyleRecalc();
1274 }
1275
1276 static void checkForSiblingStyleChanges(Element* e, RenderStyle* style, bool finishedParsingCallback,
1277                                         Node* beforeChange, Node* afterChange, int childCountDelta)
1278 {
1279     if (!style || (e->needsStyleRecalc() && style->childrenAffectedByPositionalRules()))
1280         return;
1281
1282     // :first-child.  In the parser callback case, we don't have to check anything, since we were right the first time.
1283     // In the DOM case, we only need to do something if |afterChange| is not 0.
1284     // |afterChange| is 0 in the parser case, so it works out that we'll skip this block.
1285     if (style->childrenAffectedByFirstChildRules() && afterChange) {
1286         // Find our new first child.
1287         Node* newFirstChild = 0;
1288         for (newFirstChild = e->firstChild(); newFirstChild && !newFirstChild->isElementNode(); newFirstChild = newFirstChild->nextSibling()) {};
1289         
1290         // Find the first element node following |afterChange|
1291         Node* firstElementAfterInsertion = 0;
1292         for (firstElementAfterInsertion = afterChange;
1293              firstElementAfterInsertion && !firstElementAfterInsertion->isElementNode();
1294              firstElementAfterInsertion = firstElementAfterInsertion->nextSibling()) {};
1295         
1296         // This is the insert/append case.
1297         if (newFirstChild != firstElementAfterInsertion && firstElementAfterInsertion && firstElementAfterInsertion->attached() &&
1298             firstElementAfterInsertion->renderStyle() && firstElementAfterInsertion->renderStyle()->firstChildState())
1299             firstElementAfterInsertion->setNeedsStyleRecalc();
1300             
1301         // We also have to handle node removal.
1302         if (childCountDelta < 0 && newFirstChild == firstElementAfterInsertion && newFirstChild && newFirstChild->renderStyle() && !newFirstChild->renderStyle()->firstChildState())
1303             newFirstChild->setNeedsStyleRecalc();
1304     }
1305
1306     // :last-child.  In the parser callback case, we don't have to check anything, since we were right the first time.
1307     // In the DOM case, we only need to do something if |afterChange| is not 0.
1308     if (style->childrenAffectedByLastChildRules() && beforeChange) {
1309         // Find our new last child.
1310         Node* newLastChild = 0;
1311         for (newLastChild = e->lastChild(); newLastChild && !newLastChild->isElementNode(); newLastChild = newLastChild->previousSibling()) {};
1312         
1313         // Find the last element node going backwards from |beforeChange|
1314         Node* lastElementBeforeInsertion = 0;
1315         for (lastElementBeforeInsertion = beforeChange;
1316              lastElementBeforeInsertion && !lastElementBeforeInsertion->isElementNode();
1317              lastElementBeforeInsertion = lastElementBeforeInsertion->previousSibling()) {};
1318         
1319         if (newLastChild != lastElementBeforeInsertion && lastElementBeforeInsertion && lastElementBeforeInsertion->attached() &&
1320             lastElementBeforeInsertion->renderStyle() && lastElementBeforeInsertion->renderStyle()->lastChildState())
1321             lastElementBeforeInsertion->setNeedsStyleRecalc();
1322             
1323         // We also have to handle node removal.  The parser callback case is similar to node removal as well in that we need to change the last child
1324         // to match now.
1325         if ((childCountDelta < 0 || finishedParsingCallback) && newLastChild == lastElementBeforeInsertion && newLastChild && newLastChild->renderStyle() && !newLastChild->renderStyle()->lastChildState())
1326             newLastChild->setNeedsStyleRecalc();
1327     }
1328
1329     // The + selector.  We need to invalidate the first element following the insertion point.  It is the only possible element
1330     // that could be affected by this DOM change.
1331     if (style->childrenAffectedByDirectAdjacentRules() && afterChange) {
1332         Node* firstElementAfterInsertion = 0;
1333         for (firstElementAfterInsertion = afterChange;
1334              firstElementAfterInsertion && !firstElementAfterInsertion->isElementNode();
1335              firstElementAfterInsertion = firstElementAfterInsertion->nextSibling()) {};
1336         if (firstElementAfterInsertion && firstElementAfterInsertion->attached())
1337             firstElementAfterInsertion->setNeedsStyleRecalc();
1338     }
1339
1340     // Forward positional selectors include the ~ selector, nth-child, nth-of-type, first-of-type and only-of-type.
1341     // Backward positional selectors include nth-last-child, nth-last-of-type, last-of-type and only-of-type.
1342     // We have to invalidate everything following the insertion point in the forward case, and everything before the insertion point in the
1343     // backward case.
1344     // |afterChange| is 0 in the parser callback case, so we won't do any work for the forward case if we don't have to.
1345     // For performance reasons we just mark the parent node as changed, since we don't want to make childrenChanged O(n^2) by crawling all our kids
1346     // here.  recalcStyle will then force a walk of the children when it sees that this has happened.
1347     if ((style->childrenAffectedByForwardPositionalRules() && afterChange) ||
1348         (style->childrenAffectedByBackwardPositionalRules() && beforeChange))
1349         e->setNeedsStyleRecalc();
1350     
1351     // :empty selector.
1352     checkForEmptyStyleChange(e, style);
1353 }
1354
1355 void Element::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)
1356 {
1357     ContainerNode::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
1358     if (changedByParser)
1359         checkForEmptyStyleChange(this, renderStyle());
1360     else
1361         checkForSiblingStyleChanges(this, renderStyle(), false, beforeChange, afterChange, childCountDelta);
1362
1363     if (hasRareData()) {
1364         if (ShadowRoot* root = shadowRoot())
1365             root->hostChildrenChanged();
1366     }
1367 }
1368
1369 void Element::beginParsingChildren()
1370 {
1371     clearIsParsingChildrenFinished();
1372     CSSStyleSelector* styleSelector = document()->styleSelectorIfExists();
1373     if (styleSelector && attached())
1374         styleSelector->pushParent(this);
1375 }
1376
1377 void Element::finishParsingChildren()
1378 {
1379     ContainerNode::finishParsingChildren();
1380     setIsParsingChildrenFinished();
1381     checkForSiblingStyleChanges(this, renderStyle(), true, lastChild(), 0, 0);
1382     if (CSSStyleSelector* styleSelector = document()->styleSelectorIfExists())
1383         styleSelector->popParent(this);
1384 }
1385
1386 #ifndef NDEBUG
1387 void Element::formatForDebugger(char* buffer, unsigned length) const
1388 {
1389     String result;
1390     String s;
1391     
1392     s = nodeName();
1393     if (s.length() > 0) {
1394         result += s;
1395     }
1396           
1397     s = getIdAttribute();
1398     if (s.length() > 0) {
1399         if (result.length() > 0)
1400             result += "; ";
1401         result += "id=";
1402         result += s;
1403     }
1404           
1405     s = getAttribute(classAttr);
1406     if (s.length() > 0) {
1407         if (result.length() > 0)
1408             result += "; ";
1409         result += "class=";
1410         result += s;
1411     }
1412           
1413     strncpy(buffer, result.utf8().data(), length - 1);
1414 }
1415 #endif
1416
1417 PassRefPtr<Attr> Element::setAttributeNode(Attr* attr, ExceptionCode& ec)
1418 {
1419     if (!attr) {
1420         ec = TYPE_MISMATCH_ERR;
1421         return 0;
1422     }
1423     return static_pointer_cast<Attr>(ensureUpdatedAttributes()->setNamedItem(attr, ec));
1424 }
1425
1426 PassRefPtr<Attr> Element::setAttributeNodeNS(Attr* attr, ExceptionCode& ec)
1427 {
1428     if (!attr) {
1429         ec = TYPE_MISMATCH_ERR;
1430         return 0;
1431     }
1432     return static_pointer_cast<Attr>(ensureUpdatedAttributes()->setNamedItem(attr, ec));
1433 }
1434
1435 PassRefPtr<Attr> Element::removeAttributeNode(Attr* attr, ExceptionCode& ec)
1436 {
1437     if (!attr) {
1438         ec = TYPE_MISMATCH_ERR;
1439         return 0;
1440     }
1441     if (attr->ownerElement() != this) {
1442         ec = NOT_FOUND_ERR;
1443         return 0;
1444     }
1445
1446     ASSERT(document() == attr->document());
1447
1448     NamedNodeMap* attrs = updatedAttributes();
1449     if (!attrs)
1450         return 0;
1451
1452     return static_pointer_cast<Attr>(attrs->removeNamedItem(attr->qualifiedName(), ec));
1453 }
1454
1455 void Element::setAttributeNS(const AtomicString& namespaceURI, const AtomicString& qualifiedName, const AtomicString& value, ExceptionCode& ec, FragmentScriptingPermission scriptingPermission)
1456 {
1457     String prefix, localName;
1458     if (!Document::parseQualifiedName(qualifiedName, prefix, localName, ec))
1459         return;
1460
1461     QualifiedName qName(prefix, localName, namespaceURI);
1462
1463     if (!Document::hasValidNamespaceForAttributes(qName)) {
1464         ec = NAMESPACE_ERR;
1465         return;
1466     }
1467
1468     if (scriptingPermission == FragmentScriptingNotAllowed && (isEventHandlerAttribute(qName) || isAttributeToRemove(qName, value)))
1469         return;
1470
1471     setAttribute(qName, value);
1472 }
1473
1474 void Element::removeAttribute(const String& name)
1475 {
1476     if (!m_attributeMap)
1477         return;
1478
1479     String localName = shouldIgnoreAttributeCase(this) ? name.lower() : name;
1480     size_t index = m_attributeMap->getAttributeItemIndex(localName, false);
1481     if (index == notFound)
1482         return;
1483
1484     m_attributeMap->removeAttribute(index);
1485 }
1486
1487 void Element::removeAttributeNS(const String& namespaceURI, const String& localName)
1488 {
1489     removeAttribute(QualifiedName(nullAtom, localName, namespaceURI));
1490 }
1491
1492 PassRefPtr<Attr> Element::getAttributeNode(const String& name)
1493 {
1494     NamedNodeMap* attrs = updatedAttributes();
1495     if (!attrs)
1496         return 0;
1497     String localName = shouldIgnoreAttributeCase(this) ? name.lower() : name;
1498     return static_pointer_cast<Attr>(attrs->getNamedItem(localName));
1499 }
1500
1501 PassRefPtr<Attr> Element::getAttributeNodeNS(const String& namespaceURI, const String& localName)
1502 {
1503     NamedNodeMap* attrs = updatedAttributes();
1504     if (!attrs)
1505         return 0;
1506     return static_pointer_cast<Attr>(attrs->getNamedItem(QualifiedName(nullAtom, localName, namespaceURI)));
1507 }
1508
1509 bool Element::hasAttribute(const String& name) const
1510 {
1511     NamedNodeMap* attrs = updatedAttributes();
1512     if (!attrs)
1513         return false;
1514
1515     // This call to String::lower() seems to be required but
1516     // there may be a way to remove it.
1517     String localName = shouldIgnoreAttributeCase(this) ? name.lower() : name;
1518     return attrs->getAttributeItem(localName, false);
1519 }
1520
1521 bool Element::hasAttributeNS(const String& namespaceURI, const String& localName) const
1522 {
1523     NamedNodeMap* attrs = updatedAttributes();
1524     if (!attrs)
1525         return false;
1526     return attrs->getAttributeItem(QualifiedName(nullAtom, localName, namespaceURI));
1527 }
1528
1529 CSSStyleDeclaration *Element::style()
1530 {
1531     return 0;
1532 }
1533
1534 void Element::focus(bool restorePreviousSelection)
1535 {
1536     if (!inDocument())
1537         return;
1538
1539     Document* doc = document();
1540     if (doc->focusedNode() == this)
1541         return;
1542
1543     // If the stylesheets have already been loaded we can reliably check isFocusable.
1544     // If not, we continue and set the focused node on the focus controller below so
1545     // that it can be updated soon after attach. 
1546     if (doc->haveStylesheetsLoaded()) {
1547         doc->updateLayoutIgnorePendingStylesheets();
1548         if (!isFocusable())
1549             return;
1550     }
1551
1552     if (!supportsFocus())
1553         return;
1554
1555     RefPtr<Node> protect;
1556     if (Page* page = doc->page()) {
1557         // Focus and change event handlers can cause us to lose our last ref.
1558         // If a focus event handler changes the focus to a different node it
1559         // does not make sense to continue and update appearence.
1560         protect = this;
1561         if (shadowRoot() && page->focusController()->transferFocusToElementInShadowRoot(this, restorePreviousSelection))
1562             return;
1563         if (!page->focusController()->setFocusedNode(this, doc->frame()))
1564             return;
1565     }
1566
1567     // Setting the focused node above might have invalidated the layout due to scripts.
1568     doc->updateLayoutIgnorePendingStylesheets();
1569
1570     if (!isFocusable()) {
1571         ensureRareData()->setNeedsFocusAppearanceUpdateSoonAfterAttach(true);
1572         return;
1573     }
1574         
1575     cancelFocusAppearanceUpdate();
1576     updateFocusAppearance(restorePreviousSelection);
1577 }
1578
1579 void Element::updateFocusAppearance(bool /*restorePreviousSelection*/)
1580 {
1581     if (this == rootEditableElement()) { 
1582         Frame* frame = document()->frame();
1583         if (!frame)
1584             return;
1585         
1586         // When focusing an editable element in an iframe, don't reset the selection if it already contains a selection.
1587         if (this == frame->selection()->rootEditableElement())
1588             return;
1589
1590         // FIXME: We should restore the previous selection if there is one.
1591         VisibleSelection newSelection = VisibleSelection(firstPositionInOrBeforeNode(this), DOWNSTREAM);
1592         
1593         if (frame->selection()->shouldChangeSelection(newSelection)) {
1594             frame->selection()->setSelection(newSelection);
1595             frame->selection()->revealSelection();
1596         }
1597     } else if (renderer() && !renderer()->isWidget())
1598         renderer()->enclosingLayer()->scrollRectToVisible(getRect());
1599 }
1600
1601 void Element::blur()
1602 {
1603     cancelFocusAppearanceUpdate();
1604     Document* doc = document();
1605     if (doc->focusedNode() == this) {
1606         if (doc->frame())
1607             doc->frame()->page()->focusController()->setFocusedNode(0, doc->frame());
1608         else
1609             doc->setFocusedNode(0);
1610     }
1611 }
1612
1613 String Element::innerText()
1614 {
1615     // We need to update layout, since plainText uses line boxes in the render tree.
1616     document()->updateLayoutIgnorePendingStylesheets();
1617
1618     if (!renderer())
1619         return textContent(true);
1620
1621     return plainText(rangeOfContents(const_cast<Element*>(this)).get());
1622 }
1623
1624 String Element::outerText()
1625 {
1626     // Getting outerText is the same as getting innerText, only
1627     // setting is different. You would think this should get the plain
1628     // text for the outer range, but this is wrong, <br> for instance
1629     // would return different values for inner and outer text by such
1630     // a rule, but it doesn't in WinIE, and we want to match that.
1631     return innerText();
1632 }
1633
1634 String Element::title() const
1635 {
1636     return String();
1637 }
1638
1639 LayoutSize Element::minimumSizeForResizing() const
1640 {
1641     return hasRareData() ? rareData()->m_minimumSizeForResizing : defaultMinimumSizeForResizing();
1642 }
1643
1644 void Element::setMinimumSizeForResizing(const LayoutSize& size)
1645 {
1646     if (size == defaultMinimumSizeForResizing() && !hasRareData())
1647         return;
1648     ensureRareData()->m_minimumSizeForResizing = size;
1649 }
1650
1651 RenderStyle* Element::computedStyle(PseudoId pseudoElementSpecifier)
1652 {
1653     // FIXME: Find and use the renderer from the pseudo element instead of the actual element so that the 'length'
1654     // properties, which are only known by the renderer because it did the layout, will be correct and so that the
1655     // values returned for the ":selection" pseudo-element will be correct.
1656     if (RenderStyle* usedStyle = renderStyle())
1657         return pseudoElementSpecifier ? usedStyle->getCachedPseudoStyle(pseudoElementSpecifier) : usedStyle;
1658
1659     if (!attached())
1660         // FIXME: Try to do better than this. Ensure that styleForElement() works for elements that are not in the
1661         // document tree and figure out when to destroy the computed style for such elements.
1662         return 0;
1663
1664     ElementRareData* data = ensureRareData();
1665     if (!data->m_computedStyle)
1666         data->m_computedStyle = document()->styleForElementIgnoringPendingStylesheets(this);
1667     return pseudoElementSpecifier ? data->m_computedStyle->getCachedPseudoStyle(pseudoElementSpecifier) : data->m_computedStyle.get();
1668 }
1669
1670 void Element::setStyleAffectedByEmpty()
1671 {
1672     ElementRareData* data = ensureRareData();
1673     data->m_styleAffectedByEmpty = true;
1674 }
1675
1676 bool Element::styleAffectedByEmpty() const
1677 {
1678     return hasRareData() && rareData()->m_styleAffectedByEmpty;
1679 }
1680
1681 AtomicString Element::computeInheritedLanguage() const
1682 {
1683     const Node* n = this;
1684     AtomicString value;
1685     // The language property is inherited, so we iterate over the parents to find the first language.
1686     while (n && value.isNull()) {
1687         if (n->isElementNode()) {
1688             // Spec: xml:lang takes precedence -- http://www.w3.org/TR/xhtml1/#C_7
1689             value = static_cast<const Element*>(n)->fastGetAttribute(XMLNames::langAttr);
1690             if (value.isNull())
1691                 value = static_cast<const Element*>(n)->fastGetAttribute(HTMLNames::langAttr);
1692         } else if (n->isDocumentNode()) {
1693             // checking the MIME content-language
1694             value = static_cast<const Document*>(n)->contentLanguage();
1695         }
1696
1697         n = n->parentNode();
1698     }
1699
1700     return value;
1701 }
1702
1703 void Element::cancelFocusAppearanceUpdate()
1704 {
1705     if (hasRareData())
1706         rareData()->setNeedsFocusAppearanceUpdateSoonAfterAttach(false);
1707     if (document()->focusedNode() == this)
1708         document()->cancelFocusAppearanceUpdate();
1709 }
1710
1711 void Element::normalizeAttributes()
1712 {
1713     NamedNodeMap* attrs = updatedAttributes();
1714     if (!attrs)
1715         return;
1716
1717     if (attrs->isEmpty())
1718         return;
1719
1720     Vector<RefPtr<Attribute> > attributeVector;
1721     attrs->copyAttributesToVector(attributeVector);
1722     size_t numAttrs = attributeVector.size();
1723     for (size_t i = 0; i < numAttrs; ++i) {
1724         if (Attr* attr = attributeVector[i]->attr())
1725             attr->normalize();
1726     }
1727 }
1728
1729 // ElementTraversal API
1730 Element* Element::firstElementChild() const
1731 {
1732     return WebCore::firstElementChild(this);
1733 }
1734
1735 Element* Element::lastElementChild() const
1736 {
1737     Node* n = lastChild();
1738     while (n && !n->isElementNode())
1739         n = n->previousSibling();
1740     return static_cast<Element*>(n);
1741 }
1742
1743 unsigned Element::childElementCount() const
1744 {
1745     unsigned count = 0;
1746     Node* n = firstChild();
1747     while (n) {
1748         count += n->isElementNode();
1749         n = n->nextSibling();
1750     }
1751     return count;
1752 }
1753
1754 #if ENABLE(STYLE_SCOPED)
1755 bool Element::hasScopedHTMLStyleChild() const
1756 {
1757     return hasRareData() && rareData()->hasScopedHTMLStyleChild();
1758 }
1759
1760 size_t Element::numberOfScopedHTMLStyleChildren() const
1761 {
1762     return hasRareData() ? rareData()->numberOfScopedHTMLStyleChildren() : 0;
1763 }
1764
1765 void Element::registerScopedHTMLStyleChild()
1766 {
1767     ensureRareData()->registerScopedHTMLStyleChild();
1768 }
1769
1770 void Element::unregisterScopedHTMLStyleChild()
1771 {
1772     ASSERT(hasRareData());
1773     if (hasRareData())
1774         rareData()->unregisterScopedHTMLStyleChild();
1775 }
1776 #endif
1777
1778 bool Element::webkitMatchesSelector(const String& selector, ExceptionCode& ec)
1779 {
1780     if (selector.isEmpty()) {
1781         ec = SYNTAX_ERR;
1782         return false;
1783     }
1784
1785     bool strictParsing = !document()->inQuirksMode();
1786     CSSParser p(strictParsing);
1787
1788     CSSSelectorList selectorList;
1789     p.parseSelector(selector, document(), selectorList);
1790
1791     if (!selectorList.first()) {
1792         ec = SYNTAX_ERR;
1793         return false;
1794     }
1795
1796     // Throw a NAMESPACE_ERR if the selector includes any namespace prefixes.
1797     if (selectorList.selectorsNeedNamespaceResolution()) {
1798         ec = NAMESPACE_ERR;
1799         return false;
1800     }
1801
1802     SelectorChecker selectorChecker(document(), strictParsing);
1803     for (CSSSelector* selector = selectorList.first(); selector; selector = CSSSelectorList::next(selector)) {
1804         if (selectorChecker.checkSelector(selector, this))
1805             return true;
1806     }
1807
1808     return false;
1809 }
1810
1811 DOMTokenList* Element::classList()
1812 {
1813     ElementRareData* data = ensureRareData();
1814     if (!data->m_classList)
1815         data->m_classList = ClassList::create(this);
1816     return data->m_classList.get();
1817 }
1818
1819 DOMTokenList* Element::optionalClassList() const
1820 {
1821     if (!hasRareData())
1822         return 0;
1823     return rareData()->m_classList.get();
1824 }
1825
1826 DOMStringMap* Element::dataset()
1827 {
1828     ElementRareData* data = ensureRareData();
1829     if (!data->m_datasetDOMStringMap)
1830         data->m_datasetDOMStringMap = DatasetDOMStringMap::create(this);
1831     return data->m_datasetDOMStringMap.get();
1832 }
1833
1834 KURL Element::getURLAttribute(const QualifiedName& name) const
1835 {
1836 #if !ASSERT_DISABLED
1837     if (m_attributeMap) {
1838         if (Attribute* attribute = m_attributeMap->getAttributeItem(name))
1839             ASSERT(isURLAttribute(attribute));
1840     }
1841 #endif
1842     return document()->completeURL(stripLeadingAndTrailingHTMLSpaces(getAttribute(name)));
1843 }
1844
1845 KURL Element::getNonEmptyURLAttribute(const QualifiedName& name) const
1846 {
1847 #if !ASSERT_DISABLED
1848     if (m_attributeMap) {
1849         if (Attribute* attribute = m_attributeMap->getAttributeItem(name))
1850             ASSERT(isURLAttribute(attribute));
1851     }
1852 #endif
1853     String value = stripLeadingAndTrailingHTMLSpaces(getAttribute(name));
1854     if (value.isEmpty())
1855         return KURL();
1856     return document()->completeURL(value);
1857 }
1858
1859 int Element::getIntegralAttribute(const QualifiedName& attributeName) const
1860 {
1861     return getAttribute(attributeName).string().toInt();
1862 }
1863
1864 void Element::setIntegralAttribute(const QualifiedName& attributeName, int value)
1865 {
1866     // FIXME: Need an AtomicString version of String::number.
1867     setAttribute(attributeName, String::number(value));
1868 }
1869
1870 unsigned Element::getUnsignedIntegralAttribute(const QualifiedName& attributeName) const
1871 {
1872     return getAttribute(attributeName).string().toUInt();
1873 }
1874
1875 void Element::setUnsignedIntegralAttribute(const QualifiedName& attributeName, unsigned value)
1876 {
1877     // FIXME: Need an AtomicString version of String::number.
1878     setAttribute(attributeName, String::number(value));
1879 }
1880
1881 #if ENABLE(SVG)
1882 bool Element::childShouldCreateRenderer(Node* child) const
1883 {
1884     // Only create renderers for SVG elements whose parents are SVG elements, or for proper <svg xmlns="svgNS"> subdocuments.
1885     if (child->isSVGElement())
1886         return child->hasTagName(SVGNames::svgTag) || isSVGElement();
1887
1888     return Node::childShouldCreateRenderer(child);
1889 }
1890 #endif
1891     
1892 #if ENABLE(FULLSCREEN_API)
1893 void Element::webkitRequestFullScreen(unsigned short flags)
1894 {
1895     document()->requestFullScreenForElement(this, flags, Document::EnforceIFrameAllowFulScreenRequirement);
1896 }
1897
1898 bool Element::containsFullScreenElement() const
1899 {
1900     return hasRareData() ? rareData()->m_containsFullScreenElement : false;
1901 }
1902
1903 void Element::setContainsFullScreenElement(bool flag)
1904 {
1905     ensureRareData()->m_containsFullScreenElement = flag;
1906     setNeedsStyleRecalc(SyntheticStyleChange);
1907 }
1908
1909 static Element* parentCrossingFrameBoundaries(Element* element)
1910 {
1911     ASSERT(element);
1912     return element->parentElement() ? element->parentElement() : element->document()->ownerElement();
1913 }
1914
1915 void Element::setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(bool flag)
1916 {
1917     Element* element = this;
1918     while ((element = parentCrossingFrameBoundaries(element)))
1919         element->setContainsFullScreenElement(flag);
1920 }
1921 #endif    
1922
1923 SpellcheckAttributeState Element::spellcheckAttributeState() const
1924 {
1925     const AtomicString& value = getAttribute(HTMLNames::spellcheckAttr);
1926     if (value == nullAtom)
1927         return SpellcheckAttributeDefault;
1928     if (equalIgnoringCase(value, "true") || equalIgnoringCase(value, ""))
1929         return SpellcheckAttributeTrue;
1930     if (equalIgnoringCase(value, "false"))
1931         return SpellcheckAttributeFalse;
1932
1933     return SpellcheckAttributeDefault;
1934 }
1935
1936 bool Element::isSpellCheckingEnabled() const
1937 {
1938     const Element* element = this;
1939     while (element) {
1940         switch (element->spellcheckAttributeState()) {
1941         case SpellcheckAttributeTrue:
1942             return true;
1943         case SpellcheckAttributeFalse:
1944             return false;
1945         case SpellcheckAttributeDefault:
1946             break;
1947         }
1948
1949         ContainerNode* parent = const_cast<Element*>(element)->parentOrHostNode();
1950         if (parent && parent->isElementNode())
1951             element = toElement(parent);
1952         else if (parent && parent->isShadowRoot())
1953             element = toElement(parent->parentOrHostNode());
1954         else
1955             element = 0;
1956     }
1957
1958     return true;
1959 }
1960
1961 PassRefPtr<WebKitAnimationList> Element::webkitGetAnimations() const
1962 {
1963     if (!renderer())
1964         return 0;
1965
1966     AnimationController* animController = renderer()->animation();
1967
1968     if (!animController)
1969         return 0;
1970     
1971     return animController->animationsForRenderer(renderer());
1972 }
1973
1974 #ifndef NDEBUG
1975 bool Element::fastAttributeLookupAllowed(const QualifiedName& name) const
1976 {
1977     if (name == HTMLNames::styleAttr)
1978         return false;
1979
1980 #if ENABLE(SVG)
1981     if (isSVGElement())
1982         return !SVGElement::isAnimatableAttribute(name);
1983 #endif
1984
1985     return true;
1986 }
1987 #endif
1988
1989 void Element::willModifyAttribute(const QualifiedName& name, const AtomicString& oldValue, const AtomicString& newValue)
1990 {
1991     document()->incDOMTreeVersion();
1992
1993     if (isIdAttributeName(name))
1994         updateId(oldValue, newValue);
1995     else if (name == HTMLNames::nameAttr)
1996         updateName(oldValue, newValue);
1997
1998 #if ENABLE(MUTATION_OBSERVERS)
1999     if (!isSynchronizingStyleAttribute()) {
2000         if (OwnPtr<MutationObserverInterestGroup> recipients = MutationObserverInterestGroup::createForAttributesMutation(this, name))
2001             recipients->enqueueMutationRecord(MutationRecord::createAttributes(this, name, oldValue));
2002     }
2003 #endif
2004
2005 #if ENABLE(INSPECTOR)
2006     if (!isSynchronizingStyleAttribute())
2007         InspectorInstrumentation::willModifyDOMAttr(document(), this);
2008 #endif
2009 }
2010
2011 void Element::didModifyAttribute(Attribute* attr)
2012 {
2013     attributeChanged(attr);
2014
2015     if (!isSynchronizingStyleAttribute()) {
2016         InspectorInstrumentation::didModifyDOMAttr(document(), this, attr->name().localName(), attr->value());
2017         dispatchSubtreeModifiedEvent();
2018     }
2019 }
2020
2021 void Element::didRemoveAttribute(Attribute* attr)
2022 {
2023     if (attr->isNull())
2024         return;
2025
2026     AtomicString savedValue = attr->value();
2027     attr->setValue(nullAtom);
2028     attributeChanged(attr);
2029     attr->setValue(savedValue);
2030
2031     if (!isSynchronizingStyleAttribute()) {
2032         InspectorInstrumentation::didRemoveDOMAttr(document(), this, attr->name().localName());
2033         dispatchSubtreeModifiedEvent();
2034     }
2035 }
2036
2037
2038 void Element::updateNamedItemRegistration(const AtomicString& oldName, const AtomicString& newName)
2039 {
2040     if (!document()->isHTMLDocument())
2041         return;
2042
2043     if (!oldName.isEmpty())
2044         static_cast<HTMLDocument*>(document())->removeNamedItem(oldName);
2045
2046     if (!newName.isEmpty())
2047         static_cast<HTMLDocument*>(document())->addNamedItem(newName);
2048 }
2049
2050 void Element::updateExtraNamedItemRegistration(const AtomicString& oldId, const AtomicString& newId)
2051 {
2052     if (!document()->isHTMLDocument())
2053         return;
2054
2055     if (!oldId.isEmpty())
2056         static_cast<HTMLDocument*>(document())->removeExtraNamedItem(oldId);
2057
2058     if (!newId.isEmpty())
2059         static_cast<HTMLDocument*>(document())->addExtraNamedItem(newId);
2060 }
2061
2062 HTMLCollection* Element::ensureCachedHTMLCollection(CollectionType type)
2063 {
2064     return ensureRareData()->ensureCachedHTMLCollection(this, type);
2065 }
2066
2067 } // namespace WebCore