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, 2012, 2013 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 "ClassList.h"
  34 #include "ClientRect.h"
  35 #include "ClientRectList.h"
  36 #include "DOMTokenList.h"
  37 #include "DatasetDOMStringMap.h"
  38 #include "Document.h"
  39 #include "DocumentFragment.h"
  40 #include "DocumentSharedObjectPool.h"
  41 #include "ElementRareData.h"
  42 #include "ExceptionCode.h"
  43 #include "FlowThreadController.h"
  44 #include "FocusController.h"
  45 #include "Frame.h"
  46 #include "FrameView.h"
  47 #include "HTMLCollection.h"
  48 #include "HTMLDocument.h"
  49 #include "HTMLElement.h"
  50 #include "HTMLFormControlsCollection.h"
  51 #include "HTMLFrameOwnerElement.h"
  52 #include "HTMLLabelElement.h"
  53 #include "HTMLNames.h"
  54 #include "HTMLOptionsCollection.h"
  55 #include "HTMLParserIdioms.h"
  56 #include "HTMLTableRowsCollection.h"
  57 #include "InsertionPoint.h"
  58 #include "InspectorInstrumentation.h"
  59 #include "MutationObserverInterestGroup.h"
  60 #include "MutationRecord.h"
  61 #include "NamedNodeMap.h"
  62 #include "NodeList.h"
  63 #include "NodeRenderStyle.h"
  64 #include "NodeRenderingContext.h"
  65 #include "NodeTraversal.h"
  66 #include "Page.h"
  67 #include "PointerLockController.h"
  68 #include "PseudoElement.h"
  69 #include "RenderRegion.h"
  70 #include "RenderView.h"
  71 #include "RenderWidget.h"
  72 #include "SelectorQuery.h"
  73 #include "Settings.h"
  74 #include "ShadowRoot.h"
  75 #include "StylePropertySet.h"
  76 #include "StyleResolver.h"
  77 #include "Text.h"
  78 #include "TextIterator.h"
  79 #include "VoidCallback.h"
  80 #include "WebCoreMemoryInstrumentation.h"
  81 #include "XMLNSNames.h"
  82 #include "XMLNames.h"
  83 #include "htmlediting.h"
  84 #include <wtf/BitVector.h>
  85 #include <wtf/MemoryInstrumentationVector.h>
  86 #include <wtf/text/CString.h>
  87
  88 #if ENABLE(SVG)
  89 #include "SVGDocumentExtensions.h"
  90 #include "SVGElement.h"
  91 #include "SVGNames.h"
  92 #endif
  93
  94 namespace WebCore {
  95
  96 using namespace HTMLNames;
  97 using namespace XMLNames;
  98
  99 static inline bool shouldIgnoreAttributeCase(const Element* e)
 100 {
 101     return e && e->document()->isHTMLDocument() && e->isHTMLElement();
 102 }
 103
 104 class StyleResolverParentPusher {
 105 public:
 106     StyleResolverParentPusher(Element* parent)
 107         : m_parent(parent)
 108         , m_pushedStyleResolver(0)
 109     {
 110     }
 111     void push()
 112     {
 113         if (m_pushedStyleResolver)
 114             return;
 115         m_pushedStyleResolver = m_parent->document()->styleResolver();
 116         m_pushedStyleResolver->pushParentElement(m_parent);
 117     }
 118     ~StyleResolverParentPusher()
 119     {
 120
 121         if (!m_pushedStyleResolver)
 122             return;
 123
 124         // This tells us that our pushed style selector is in a bad state,
 125         // so we should just bail out in that scenario.
 126         ASSERT(m_pushedStyleResolver == m_parent->document()->styleResolver());
 127         if (m_pushedStyleResolver != m_parent->document()->styleResolver())
 128             return;
 129
 130         m_pushedStyleResolver->popParentElement(m_parent);
 131     }
 132
 133 private:
 134     Element* m_parent;
 135     StyleResolver* m_pushedStyleResolver;
 136 };
 137
 138 typedef Vector<RefPtr<Attr> > AttrNodeList;
 139 typedef HashMap<Element*, OwnPtr<AttrNodeList> > AttrNodeListMap;
 140
 141 static AttrNodeListMap& attrNodeListMap()
 142 {
 143     DEFINE_STATIC_LOCAL(AttrNodeListMap, map, ());
 144     return map;
 145 }
 146
 147 static AttrNodeList* attrNodeListForElement(Element* element)
 148 {
 149     if (!element->hasSyntheticAttrChildNodes())
 150         return 0;
 151     ASSERT(attrNodeListMap().contains(element));
 152     return attrNodeListMap().get(element);
 153 }
 154
 155 static AttrNodeList* ensureAttrNodeListForElement(Element* element)
 156 {
 157     if (element->hasSyntheticAttrChildNodes()) {
 158         ASSERT(attrNodeListMap().contains(element));
 159         return attrNodeListMap().get(element);
 160     }
 161     ASSERT(!attrNodeListMap().contains(element));
 162     element->setHasSyntheticAttrChildNodes(true);
 163     AttrNodeListMap::AddResult result = attrNodeListMap().add(element, adoptPtr(new AttrNodeList));
 164     return result.iterator->value.get();
 165 }
 166
 167 static void removeAttrNodeListForElement(Element* element)
 168 {
 169     ASSERT(element->hasSyntheticAttrChildNodes());
 170     ASSERT(attrNodeListMap().contains(element));
 171     attrNodeListMap().remove(element);
 172     element->setHasSyntheticAttrChildNodes(false);
 173 }
 174
 175 static Attr* findAttrNodeInList(AttrNodeList* attrNodeList, const QualifiedName& name)
 176 {
 177     for (unsigned i = 0; i < attrNodeList->size(); ++i) {
 178         if (attrNodeList->at(i)->qualifiedName() == name)
 179             return attrNodeList->at(i).get();
 180     }
 181     return 0;
 182 }
 183
 184 PassRefPtr<Element> Element::create(const QualifiedName& tagName, Document* document)
 185 {
 186     return adoptRef(new Element(tagName, document, CreateElement));
 187 }
 188
 189 Element::~Element()
 190 {
 191 #ifndef NDEBUG
 192     if (document() && document()->renderer()) {
 193         // When the document is not destroyed, an element that was part of a named flow
 194         // content nodes should have been removed from the content nodes collection
 195         // and the inNamedFlow flag reset.
 196         ASSERT(!inNamedFlow());
 197     }
 198 #endif
 199
 200     if (hasRareData()) {
 201         ElementRareData* data = elementRareData();
 202         data->setPseudoElement(BEFORE, 0);
 203         data->setPseudoElement(AFTER, 0);
 204         data->clearShadow();
 205     }
 206
 207     if (hasSyntheticAttrChildNodes())
 208         detachAllAttrNodesFromElement();
 209
 210 #if ENABLE(SVG)
 211     if (hasPendingResources()) {
 212         document()->accessSVGExtensions()->removeElementFromPendingResources(this);
 213         ASSERT(!hasPendingResources());
 214     }
 215 #endif
 216 }
 217
 218 inline ElementRareData* Element::elementRareData() const
 219 {
 220     ASSERT(hasRareData());
 221     return static_cast<ElementRareData*>(rareData());
 222 }
 223
 224 inline ElementRareData* Element::ensureElementRareData()
 225 {
 226     return static_cast<ElementRareData*>(ensureRareData());
 227 }
 228
 229 void Element::clearTabIndexExplicitlyIfNeeded()
 230 {
 231     if (hasRareData())
 232         elementRareData()->clearTabIndexExplicitly();
 233 }
 234
 235 void Element::setTabIndexExplicitly(short tabIndex)
 236 {
 237     ensureElementRareData()->setTabIndexExplicitly(tabIndex);
 238 }
 239
 240 bool Element::supportsFocus() const
 241 {
 242     return hasRareData() && elementRareData()->tabIndexSetExplicitly();
 243 }
 244
 245 short Element::tabIndex() const
 246 {
 247     return hasRareData() ? elementRareData()->tabIndex() : 0;
 248 }
 249
 250 DEFINE_VIRTUAL_ATTRIBUTE_EVENT_LISTENER(Element, blur);
 251 DEFINE_VIRTUAL_ATTRIBUTE_EVENT_LISTENER(Element, error);
 252 DEFINE_VIRTUAL_ATTRIBUTE_EVENT_LISTENER(Element, focus);
 253 DEFINE_VIRTUAL_ATTRIBUTE_EVENT_LISTENER(Element, load);
 254
 255 PassRefPtr<Node> Element::cloneNode(bool deep)
 256 {
 257     return deep ? cloneElementWithChildren() : cloneElementWithoutChildren();
 258 }
 259
 260 PassRefPtr<Element> Element::cloneElementWithChildren()
 261 {
 262     RefPtr<Element> clone = cloneElementWithoutChildren();
 263     cloneChildNodes(clone.get());
 264     return clone.release();
 265 }
 266
 267 PassRefPtr<Element> Element::cloneElementWithoutChildren()
 268 {
 269     RefPtr<Element> clone = cloneElementWithoutAttributesAndChildren();
 270     // This will catch HTML elements in the wrong namespace that are not correctly copied.
 271     // This is a sanity check as HTML overloads some of the DOM methods.
 272     ASSERT(isHTMLElement() == clone->isHTMLElement());
 273
 274     clone->cloneDataFromElement(*this);
 275     return clone.release();
 276 }
 277
 278 PassRefPtr<Element> Element::cloneElementWithoutAttributesAndChildren()
 279 {
 280     return document()->createElement(tagQName(), false);
 281 }
 282
 283 PassRefPtr<Attr> Element::detachAttribute(size_t index)
 284 {
 285     ASSERT(elementData());
 286
 287     const Attribute* attribute = elementData()->attributeItem(index);
 288     ASSERT(attribute);
 289
 290     RefPtr<Attr> attrNode = attrIfExists(attribute->name());
 291     if (attrNode)
 292         detachAttrNodeFromElementWithValue(attrNode.get(), attribute->value());
 293     else
 294         attrNode = Attr::create(document(), attribute->name(), attribute->value());
 295
 296     removeAttributeInternal(index, NotInSynchronizationOfLazyAttribute);
 297     return attrNode.release();
 298 }
 299
 300 void Element::removeAttribute(const QualifiedName& name)
 301 {
 302     if (!elementData())
 303         return;
 304
 305     size_t index = elementData()->getAttributeItemIndex(name);
 306     if (index == notFound)
 307         return;
 308
 309     removeAttributeInternal(index, NotInSynchronizationOfLazyAttribute);
 310 }
 311
 312 void Element::setBooleanAttribute(const QualifiedName& name, bool value)
 313 {
 314     if (value)
 315         setAttribute(name, emptyAtom);
 316     else
 317         removeAttribute(name);
 318 }
 319
 320 NamedNodeMap* Element::attributes() const
 321 {
 322     ElementRareData* rareData = const_cast<Element*>(this)->ensureElementRareData();
 323     if (NamedNodeMap* attributeMap = rareData->attributeMap())
 324         return attributeMap;
 325
 326     rareData->setAttributeMap(NamedNodeMap::create(const_cast<Element*>(this)));
 327     return rareData->attributeMap();
 328 }
 329
 330 Node::NodeType Element::nodeType() const
 331 {
 332     return ELEMENT_NODE;
 333 }
 334
 335 bool Element::hasAttribute(const QualifiedName& name) const
 336 {
 337     return hasAttributeNS(name.namespaceURI(), name.localName());
 338 }
 339
 340 void Element::synchronizeAllAttributes() const
 341 {
 342     if (!elementData())
 343         return;
 344     if (elementData()->m_styleAttributeIsDirty) {
 345         ASSERT(isStyledElement());
 346         static_cast<const StyledElement*>(this)->synchronizeStyleAttributeInternal();
 347     }
 348 #if ENABLE(SVG)
 349     if (elementData()->m_animatedSVGAttributesAreDirty) {
 350         ASSERT(isSVGElement());
 351         toSVGElement(this)->synchronizeAnimatedSVGAttribute(anyQName());
 352     }
 353 #endif
 354 }
 355
 356 inline void Element::synchronizeAttribute(const QualifiedName& name) const
 357 {
 358     if (!elementData())
 359         return;
 360     if (UNLIKELY(name == styleAttr && elementData()->m_styleAttributeIsDirty)) {
 361         ASSERT(isStyledElement());
 362         static_cast<const StyledElement*>(this)->synchronizeStyleAttributeInternal();
 363         return;
 364     }
 365 #if ENABLE(SVG)
 366     if (UNLIKELY(elementData()->m_animatedSVGAttributesAreDirty)) {
 367         ASSERT(isSVGElement());
 368         toSVGElement(this)->synchronizeAnimatedSVGAttribute(name);
 369     }
 370 #endif
 371 }
 372
 373 inline void Element::synchronizeAttribute(const AtomicString& localName) const
 374 {
 375     // This version of synchronizeAttribute() is streamlined for the case where you don't have a full QualifiedName,
 376     // e.g when called from DOM API.
 377     if (!elementData())
 378         return;
 379     if (elementData()->m_styleAttributeIsDirty && equalPossiblyIgnoringCase(localName, styleAttr.localName(), shouldIgnoreAttributeCase(this))) {
 380         ASSERT(isStyledElement());
 381         static_cast<const StyledElement*>(this)->synchronizeStyleAttributeInternal();
 382         return;
 383     }
 384 #if ENABLE(SVG)
 385     if (elementData()->m_animatedSVGAttributesAreDirty) {
 386         // We're not passing a namespace argument on purpose. SVGNames::*Attr are defined w/o namespaces as well.
 387         ASSERT(isSVGElement());
 388         static_cast<const SVGElement*>(this)->synchronizeAnimatedSVGAttribute(QualifiedName(nullAtom, localName, nullAtom));
 389     }
 390 #endif
 391 }
 392
 393 const AtomicString& Element::getAttribute(const QualifiedName& name) const
 394 {
 395     if (!elementData())
 396         return nullAtom;
 397     synchronizeAttribute(name);
 398     if (const Attribute* attribute = getAttributeItem(name))
 399         return attribute->value();
 400     return nullAtom;
 401 }
 402
 403 void Element::scrollIntoView(bool alignToTop)
 404 {
 405     document()->updateLayoutIgnorePendingStylesheets();
 406
 407     if (!renderer())
 408         return;
 409
 410     LayoutRect bounds = boundingBox();
 411     // Align to the top / bottom and to the closest edge.
 412     if (alignToTop)
 413         renderer()->scrollRectToVisible(bounds, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignTopAlways);
 414     else
 415         renderer()->scrollRectToVisible(bounds, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignBottomAlways);
 416 }
 417
 418 void Element::scrollIntoViewIfNeeded(bool centerIfNeeded)
 419 {
 420     document()->updateLayoutIgnorePendingStylesheets();
 421
 422     if (!renderer())
 423         return;
 424
 425     LayoutRect bounds = boundingBox();
 426     if (centerIfNeeded)
 427         renderer()->scrollRectToVisible(bounds, ScrollAlignment::alignCenterIfNeeded, ScrollAlignment::alignCenterIfNeeded);
 428     else
 429         renderer()->scrollRectToVisible(bounds, ScrollAlignment::alignToEdgeIfNeeded, ScrollAlignment::alignToEdgeIfNeeded);
 430 }
 431
 432 void Element::scrollByUnits(int units, ScrollGranularity granularity)
 433 {
 434     document()->updateLayoutIgnorePendingStylesheets();
 435
 436     if (!renderer())
 437         return;
 438
 439     if (!renderer()->hasOverflowClip())
 440         return;
 441
 442     ScrollDirection direction = ScrollDown;
 443     if (units < 0) {
 444         direction = ScrollUp;
 445         units = -units;
 446     }
 447     Node* stopNode = this;
 448     toRenderBox(renderer())->scroll(direction, granularity, units, &stopNode);
 449 }
 450
 451 void Element::scrollByLines(int lines)
 452 {
 453     scrollByUnits(lines, ScrollByLine);
 454 }
 455
 456 void Element::scrollByPages(int pages)
 457 {
 458     scrollByUnits(pages, ScrollByPage);
 459 }
 460
 461 static float localZoomForRenderer(RenderObject* renderer)
 462 {
 463     // FIXME: This does the wrong thing if two opposing zooms are in effect and canceled each
 464     // other out, but the alternative is that we'd have to crawl up the whole render tree every
 465     // time (or store an additional bit in the RenderStyle to indicate that a zoom was specified).
 466     float zoomFactor = 1;
 467     if (renderer->style()->effectiveZoom() != 1) {
 468         // Need to find the nearest enclosing RenderObject that set up
 469         // a differing zoom, and then we divide our result by it to eliminate the zoom.
 470         RenderObject* prev = renderer;
 471         for (RenderObject* curr = prev->parent(); curr; curr = curr->parent()) {
 472             if (curr->style()->effectiveZoom() != prev->style()->effectiveZoom()) {
 473                 zoomFactor = prev->style()->zoom();
 474                 break;
 475             }
 476             prev = curr;
 477         }
 478         if (prev->isRenderView())
 479             zoomFactor = prev->style()->zoom();
 480     }
 481     return zoomFactor;
 482 }
 483
 484 static int adjustForLocalZoom(LayoutUnit value, RenderObject* renderer)
 485 {
 486     float zoomFactor = localZoomForRenderer(renderer);
 487     if (zoomFactor == 1)
 488         return value;
 489 #if ENABLE(SUBPIXEL_LAYOUT)
 490     return lroundf(value / zoomFactor);
 491 #else
 492     // Needed because computeLengthInt truncates (rather than rounds) when scaling up.
 493     if (zoomFactor > 1)
 494         value++;
 495     return static_cast<int>(value / zoomFactor);
 496 #endif
 497 }
 498
 499 int Element::offsetLeft()
 500 {
 501     document()->updateLayoutIgnorePendingStylesheets();
 502     if (RenderBoxModelObject* renderer = renderBoxModelObject())
 503         return adjustForLocalZoom(renderer->pixelSnappedOffsetLeft(), renderer);
 504     return 0;
 505 }
 506
 507 int Element::offsetTop()
 508 {
 509     document()->updateLayoutIgnorePendingStylesheets();
 510     if (RenderBoxModelObject* renderer = renderBoxModelObject())
 511         return adjustForLocalZoom(renderer->pixelSnappedOffsetTop(), renderer);
 512     return 0;
 513 }
 514
 515 int Element::offsetWidth()
 516 {
 517     document()->updateLayoutIgnorePendingStylesheets();
 518     if (RenderBoxModelObject* renderer = renderBoxModelObject())
 519 #if ENABLE(SUBPIXEL_LAYOUT)
 520         return adjustLayoutUnitForAbsoluteZoom(renderer->pixelSnappedOffsetWidth(), renderer).round();
 521 #else
 522         return adjustForAbsoluteZoom(renderer->pixelSnappedOffsetWidth(), renderer);
 523 #endif
 524     return 0;
 525 }
 526
 527 int Element::offsetHeight()
 528 {
 529     document()->updateLayoutIgnorePendingStylesheets();
 530     if (RenderBoxModelObject* renderer = renderBoxModelObject())
 531 #if ENABLE(SUBPIXEL_LAYOUT)
 532         return adjustLayoutUnitForAbsoluteZoom(renderer->pixelSnappedOffsetHeight(), renderer).round();
 533 #else
 534         return adjustForAbsoluteZoom(renderer->pixelSnappedOffsetHeight(), renderer);
 535 #endif
 536     return 0;
 537 }
 538
 539 Element* Element::offsetParent()
 540 {
 541     document()->updateLayoutIgnorePendingStylesheets();
 542     if (RenderObject* rend = renderer())
 543         if (RenderObject* offsetParent = rend->offsetParent())
 544             return static_cast<Element*>(offsetParent->node());
 545     return 0;
 546 }
 547
 548 int Element::clientLeft()
 549 {
 550     document()->updateLayoutIgnorePendingStylesheets();
 551
 552     if (RenderBox* renderer = renderBox())
 553         return adjustForAbsoluteZoom(roundToInt(renderer->clientLeft()), renderer);
 554     return 0;
 555 }
 556
 557 int Element::clientTop()
 558 {
 559     document()->updateLayoutIgnorePendingStylesheets();
 560
 561     if (RenderBox* renderer = renderBox())
 562         return adjustForAbsoluteZoom(roundToInt(renderer->clientTop()), renderer);
 563     return 0;
 564 }
 565
 566 int Element::clientWidth()
 567 {
 568     document()->updateLayoutIgnorePendingStylesheets();
 569
 570     // When in strict mode, clientWidth for the document element should return the width of the containing frame.
 571     // When in quirks mode, clientWidth for the body element should return the width of the containing frame.
 572     bool inQuirksMode = document()->inQuirksMode();
 573     if ((!inQuirksMode && document()->documentElement() == this) ||
 574         (inQuirksMode && isHTMLElement() && document()->body() == this)) {
 575         if (FrameView* view = document()->view()) {
 576             if (RenderView* renderView = document()->renderView())
 577                 return adjustForAbsoluteZoom(view->layoutWidth(), renderView);
 578         }
 579     }
 580
 581     if (RenderBox* renderer = renderBox())
 582 #if ENABLE(SUBPIXEL_LAYOUT)
 583         return adjustLayoutUnitForAbsoluteZoom(renderer->pixelSnappedClientWidth(), renderer).round();
 584 #else
 585         return adjustForAbsoluteZoom(renderer->pixelSnappedClientWidth(), renderer);
 586 #endif
 587     return 0;
 588 }
 589
 590 int Element::clientHeight()
 591 {
 592     document()->updateLayoutIgnorePendingStylesheets();
 593
 594     // When in strict mode, clientHeight for the document element should return the height of the containing frame.
 595     // When in quirks mode, clientHeight for the body element should return the height of the containing frame.
 596     bool inQuirksMode = document()->inQuirksMode();
 597
 598     if ((!inQuirksMode && document()->documentElement() == this) ||
 599         (inQuirksMode && isHTMLElement() && document()->body() == this)) {
 600         if (FrameView* view = document()->view()) {
 601             if (RenderView* renderView = document()->renderView())
 602                 return adjustForAbsoluteZoom(view->layoutHeight(), renderView);
 603         }
 604     }
 605
 606     if (RenderBox* renderer = renderBox())
 607 #if ENABLE(SUBPIXEL_LAYOUT)
 608         return adjustLayoutUnitForAbsoluteZoom(renderer->pixelSnappedClientHeight(), renderer).round();
 609 #else
 610         return adjustForAbsoluteZoom(renderer->pixelSnappedClientHeight(), renderer);
 611 #endif
 612     return 0;
 613 }
 614
 615 int Element::scrollLeft()
 616 {
 617     document()->updateLayoutIgnorePendingStylesheets();
 618     if (RenderBox* rend = renderBox())
 619         return adjustForAbsoluteZoom(rend->scrollLeft(), rend);
 620     return 0;
 621 }
 622
 623 int Element::scrollTop()
 624 {
 625     document()->updateLayoutIgnorePendingStylesheets();
 626     if (RenderBox* rend = renderBox())
 627         return adjustForAbsoluteZoom(rend->scrollTop(), rend);
 628     return 0;
 629 }
 630
 631 void Element::setScrollLeft(int newLeft)
 632 {
 633     document()->updateLayoutIgnorePendingStylesheets();
 634     if (RenderBox* rend = renderBox())
 635         rend->setScrollLeft(static_cast<int>(newLeft * rend->style()->effectiveZoom()));
 636 }
 637
 638 void Element::setScrollTop(int newTop)
 639 {
 640     document()->updateLayoutIgnorePendingStylesheets();
 641     if (RenderBox* rend = renderBox())
 642         rend->setScrollTop(static_cast<int>(newTop * rend->style()->effectiveZoom()));
 643 }
 644
 645 int Element::scrollWidth()
 646 {
 647     document()->updateLayoutIgnorePendingStylesheets();
 648     if (RenderBox* rend = renderBox())
 649         return adjustForAbsoluteZoom(rend->scrollWidth(), rend);
 650     return 0;
 651 }
 652
 653 int Element::scrollHeight()
 654 {
 655     document()->updateLayoutIgnorePendingStylesheets();
 656     if (RenderBox* rend = renderBox())
 657         return adjustForAbsoluteZoom(rend->scrollHeight(), rend);
 658     return 0;
 659 }
 660
 661 IntRect Element::boundsInRootViewSpace()
 662 {
 663     document()->updateLayoutIgnorePendingStylesheets();
 664
 665     FrameView* view = document()->view();
 666     if (!view)
 667         return IntRect();
 668
 669     Vector<FloatQuad> quads;
 670 #if ENABLE(SVG)
 671     if (isSVGElement() && renderer()) {
 672         // Get the bounding rectangle from the SVG model.
 673         SVGElement* svgElement = static_cast<SVGElement*>(this);
 674         FloatRect localRect;
 675         if (svgElement->getBoundingBox(localRect))
 676             quads.append(renderer()->localToAbsoluteQuad(localRect));
 677     } else
 678 #endif
 679     {
 680         // Get the bounding rectangle from the box model.
 681         if (renderBoxModelObject())
 682             renderBoxModelObject()->absoluteQuads(quads);
 683     }
 684
 685     if (quads.isEmpty())
 686         return IntRect();
 687
 688     IntRect result = quads[0].enclosingBoundingBox();
 689     for (size_t i = 1; i < quads.size(); ++i)
 690         result.unite(quads[i].enclosingBoundingBox());
 691
 692     result = view->contentsToRootView(result);
 693     return result;
 694 }
 695
 696 PassRefPtr<ClientRectList> Element::getClientRects()
 697 {
 698     document()->updateLayoutIgnorePendingStylesheets();
 699
 700     RenderBoxModelObject* renderBoxModelObject = this->renderBoxModelObject();
 701     if (!renderBoxModelObject)
 702         return ClientRectList::create();
 703
 704     // FIXME: Handle SVG elements.
 705     // FIXME: Handle table/inline-table with a caption.
 706
 707     Vector<FloatQuad> quads;
 708     renderBoxModelObject->absoluteQuads(quads);
 709     document()->adjustFloatQuadsForScrollAndAbsoluteZoomAndFrameScale(quads, renderBoxModelObject);
 710     return ClientRectList::create(quads);
 711 }
 712
 713 PassRefPtr<ClientRect> Element::getBoundingClientRect()
 714 {
 715     document()->updateLayoutIgnorePendingStylesheets();
 716
 717     Vector<FloatQuad> quads;
 718 #if ENABLE(SVG)
 719     if (isSVGElement() && renderer() && !renderer()->isSVGRoot()) {
 720         // Get the bounding rectangle from the SVG model.
 721         SVGElement* svgElement = static_cast<SVGElement*>(this);
 722         FloatRect localRect;
 723         if (svgElement->getBoundingBox(localRect))
 724             quads.append(renderer()->localToAbsoluteQuad(localRect));
 725     } else
 726 #endif
 727     {
 728         // Get the bounding rectangle from the box model.
 729         if (renderBoxModelObject())
 730             renderBoxModelObject()->absoluteQuads(quads);
 731     }
 732
 733     if (quads.isEmpty())
 734         return ClientRect::create();
 735
 736     FloatRect result = quads[0].boundingBox();
 737     for (size_t i = 1; i < quads.size(); ++i)
 738         result.unite(quads[i].boundingBox());
 739
 740     document()->adjustFloatRectForScrollAndAbsoluteZoomAndFrameScale(result, renderer());
 741     return ClientRect::create(result);
 742 }
 743
 744 IntRect Element::screenRect() const
 745 {
 746     if (!renderer())
 747         return IntRect();
 748     // FIXME: this should probably respect transforms
 749     return document()->view()->contentsToScreen(renderer()->absoluteBoundingBoxRectIgnoringTransforms());
 750 }
 751
 752 const AtomicString& Element::getAttribute(const AtomicString& localName) const
 753 {
 754     if (!elementData())
 755         return nullAtom;
 756     synchronizeAttribute(localName);
 757     if (const Attribute* attribute = elementData()->getAttributeItem(localName, shouldIgnoreAttributeCase(this)))
 758         return attribute->value();
 759     return nullAtom;
 760 }
 761
 762 const AtomicString& Element::getAttributeNS(const AtomicString& namespaceURI, const AtomicString& localName) const
 763 {
 764     return getAttribute(QualifiedName(nullAtom, localName, namespaceURI));
 765 }
 766
 767 void Element::setAttribute(const AtomicString& localName, const AtomicString& value, ExceptionCode& ec)
 768 {
 769     if (!Document::isValidName(localName)) {
 770         ec = INVALID_CHARACTER_ERR;
 771         return;
 772     }
 773
 774     synchronizeAttribute(localName);
 775     const AtomicString& caseAdjustedLocalName = shouldIgnoreAttributeCase(this) ? localName.lower() : localName;
 776
 777     size_t index = elementData() ? elementData()->getAttributeItemIndex(caseAdjustedLocalName, false) : notFound;
 778     const QualifiedName& qName = index != notFound ? attributeItem(index)->name() : QualifiedName(nullAtom, caseAdjustedLocalName, nullAtom);
 779     setAttributeInternal(index, qName, value, NotInSynchronizationOfLazyAttribute);
 780 }
 781
 782 void Element::setAttribute(const QualifiedName& name, const AtomicString& value)
 783 {
 784     synchronizeAttribute(name);
 785     size_t index = elementData() ? elementData()->getAttributeItemIndex(name) : notFound;
 786     setAttributeInternal(index, name, value, NotInSynchronizationOfLazyAttribute);
 787 }
 788
 789 void Element::setSynchronizedLazyAttribute(const QualifiedName& name, const AtomicString& value)
 790 {
 791     size_t index = elementData() ? elementData()->getAttributeItemIndex(name) : notFound;
 792     setAttributeInternal(index, name, value, InSynchronizationOfLazyAttribute);
 793 }
 794
 795 inline void Element::setAttributeInternal(size_t index, const QualifiedName& name, const AtomicString& newValue, SynchronizationOfLazyAttribute inSynchronizationOfLazyAttribute)
 796 {
 797     if (newValue.isNull()) {
 798         if (index != notFound)
 799             removeAttributeInternal(index, inSynchronizationOfLazyAttribute);
 800         return;
 801     }
 802
 803     if (index == notFound) {
 804         addAttributeInternal(name, newValue, inSynchronizationOfLazyAttribute);
 805         return;
 806     }
 807
 808     if (!inSynchronizationOfLazyAttribute)
 809         willModifyAttribute(name, attributeItem(index)->value(), newValue);
 810
 811     if (newValue != attributeItem(index)->value()) {
 812         ensureUniqueElementData()->attributeItem(index)->setValue(newValue);
 813
 814         if (RefPtr<Attr> attrNode = inSynchronizationOfLazyAttribute ? 0 : attrIfExists(name))
 815             attrNode->recreateTextChildAfterAttributeValueChanged();
 816     }
 817
 818     if (!inSynchronizationOfLazyAttribute)
 819         didModifyAttribute(name, newValue);
 820 }
 821
 822 static inline AtomicString makeIdForStyleResolution(const AtomicString& value, bool inQuirksMode)
 823 {
 824     if (inQuirksMode)
 825         return value.lower();
 826     return value;
 827 }
 828
 829 static bool checkNeedsStyleInvalidationForIdChange(const AtomicString& oldId, const AtomicString& newId, StyleResolver* styleResolver)
 830 {
 831     ASSERT(newId != oldId);
 832     if (!oldId.isEmpty() && styleResolver->hasSelectorForId(oldId))
 833         return true;
 834     if (!newId.isEmpty() && styleResolver->hasSelectorForId(newId))
 835         return true;
 836     return false;
 837 }
 838
 839 void Element::attributeChanged(const QualifiedName& name, const AtomicString& newValue)
 840 {
 841     if (ElementShadow* parentElementShadow = shadowOfParentForDistribution(this)) {
 842         if (shouldInvalidateDistributionWhenAttributeChanged(parentElementShadow, name, newValue))
 843             parentElementShadow->invalidateDistribution();
 844     }
 845
 846     parseAttribute(name, newValue);
 847
 848     document()->incDOMTreeVersion();
 849
 850     StyleResolver* styleResolver = document()->styleResolverIfExists();
 851     bool testShouldInvalidateStyle = attached() && styleResolver && styleChangeType() < FullStyleChange;
 852     bool shouldInvalidateStyle = false;
 853
 854     if (isIdAttributeName(name)) {
 855         AtomicString oldId = elementData()->idForStyleResolution();
 856         AtomicString newId = makeIdForStyleResolution(newValue, document()->inQuirksMode());
 857         if (newId != oldId) {
 858             elementData()->setIdForStyleResolution(newId);
 859             shouldInvalidateStyle = testShouldInvalidateStyle && checkNeedsStyleInvalidationForIdChange(oldId, newId, styleResolver);
 860         }
 861     } else if (name == classAttr)
 862         classAttributeChanged(newValue);
 863     else if (name == HTMLNames::nameAttr)
 864         setHasName(!newValue.isNull());
 865     else if (name == HTMLNames::pseudoAttr)
 866         shouldInvalidateStyle |= testShouldInvalidateStyle && isInShadowTree();
 867
 868     shouldInvalidateStyle |= testShouldInvalidateStyle && styleResolver->hasSelectorForAttribute(name.localName());
 869
 870     invalidateNodeListCachesInAncestors(&name, this);
 871
 872     // If there is currently no StyleResolver, we can't be sure that this attribute change won't affect style.
 873     shouldInvalidateStyle |= !styleResolver;
 874
 875     if (shouldInvalidateStyle)
 876         setNeedsStyleRecalc();
 877
 878     if (AXObjectCache::accessibilityEnabled())
 879         document()->axObjectCache()->handleAttributeChanged(name, this);
 880 }
 881
 882 template <typename CharacterType>
 883 static inline bool classStringHasClassName(const CharacterType* characters, unsigned length)
 884 {
 885     ASSERT(length > 0);
 886
 887     unsigned i = 0;
 888     do {
 889         if (isNotHTMLSpace(characters[i]))
 890             break;
 891         ++i;
 892     } while (i < length);
 893
 894     return i < length;
 895 }
 896
 897 static inline bool classStringHasClassName(const AtomicString& newClassString)
 898 {
 899     unsigned length = newClassString.length();
 900
 901     if (!length)
 902         return false;
 903
 904     if (newClassString.is8Bit())
 905         return classStringHasClassName(newClassString.characters8(), length);
 906     return classStringHasClassName(newClassString.characters16(), length);
 907 }
 908
 909 template<typename Checker>
 910 static bool checkSelectorForClassChange(const SpaceSplitString& changedClasses, const Checker& checker)
 911 {
 912     unsigned changedSize = changedClasses.size();
 913     for (unsigned i = 0; i < changedSize; ++i) {
 914         if (checker.hasSelectorForClass(changedClasses[i]))
 915             return true;
 916     }
 917     return false;
 918 }
 919
 920 template<typename Checker>
 921 static bool checkSelectorForClassChange(const SpaceSplitString& oldClasses, const SpaceSplitString& newClasses, const Checker& checker)
 922 {
 923     unsigned oldSize = oldClasses.size();
 924     if (!oldSize)
 925         return checkSelectorForClassChange(newClasses, checker);
 926     BitVector remainingClassBits;
 927     remainingClassBits.ensureSize(oldSize);
 928     // Class vectors tend to be very short. This is faster than using a hash table.
 929     unsigned newSize = newClasses.size();
 930     for (unsigned i = 0; i < newSize; ++i) {
 931         for (unsigned j = 0; j < oldSize; ++j) {
 932             if (newClasses[i] == oldClasses[j]) {
 933                 remainingClassBits.quickSet(j);
 934                 continue;
 935             }
 936         }
 937         if (checker.hasSelectorForClass(newClasses[i]))
 938             return true;
 939     }
 940     for (unsigned i = 0; i < oldSize; ++i) {
 941         // If the bit is not set the the corresponding class has been removed.
 942         if (remainingClassBits.quickGet(i))
 943             continue;
 944         if (checker.hasSelectorForClass(oldClasses[i]))
 945             return true;
 946     }
 947     return false;
 948 }
 949
 950 void Element::classAttributeChanged(const AtomicString& newClassString)
 951 {
 952     StyleResolver* styleResolver = document()->styleResolverIfExists();
 953     bool testShouldInvalidateStyle = attached() && styleResolver && styleChangeType() < FullStyleChange;
 954     bool shouldInvalidateStyle = false;
 955
 956     if (classStringHasClassName(newClassString)) {
 957         const bool shouldFoldCase = document()->inQuirksMode();
 958         const SpaceSplitString oldClasses = elementData()->classNames();
 959         elementData()->setClass(newClassString, shouldFoldCase);
 960         const SpaceSplitString& newClasses = elementData()->classNames();
 961         shouldInvalidateStyle = testShouldInvalidateStyle && checkSelectorForClassChange(oldClasses, newClasses, *styleResolver);
 962     } else {
 963         const SpaceSplitString& oldClasses = elementData()->classNames();
 964         shouldInvalidateStyle = testShouldInvalidateStyle && checkSelectorForClassChange(oldClasses, *styleResolver);
 965         elementData()->clearClass();
 966     }
 967
 968     if (hasRareData())
 969         elementRareData()->clearClassListValueForQuirksMode();
 970
 971     if (shouldInvalidateStyle)
 972         setNeedsStyleRecalc();
 973 }
 974
 975 bool Element::shouldInvalidateDistributionWhenAttributeChanged(ElementShadow* elementShadow, const QualifiedName& name, const AtomicString& newValue)
 976 {
 977     ASSERT(elementShadow);
 978     const SelectRuleFeatureSet& featureSet = elementShadow->distributor().ensureSelectFeatureSet(elementShadow);
 979
 980     if (isIdAttributeName(name)) {
 981         AtomicString oldId = elementData()->idForStyleResolution();
 982         AtomicString newId = makeIdForStyleResolution(newValue, document()->inQuirksMode());
 983         if (newId != oldId) {
 984             if (!oldId.isEmpty() && featureSet.hasSelectorForId(oldId))
 985                 return true;
 986             if (!newId.isEmpty() && featureSet.hasSelectorForId(newId))
 987                 return true;
 988         }
 989     }
 990
 991     if (name == HTMLNames::classAttr) {
 992         const AtomicString& newClassString = newValue;
 993         if (classStringHasClassName(newClassString)) {
 994             const bool shouldFoldCase = document()->inQuirksMode();
 995             const SpaceSplitString& oldClasses = elementData()->classNames();
 996             const SpaceSplitString newClasses(newClassString, shouldFoldCase);
 997             if (checkSelectorForClassChange(oldClasses, newClasses, featureSet))
 998                 return true;
 999         } else {
1000             const SpaceSplitString& oldClasses = elementData()->classNames();
1001             if (checkSelectorForClassChange(oldClasses, featureSet))
1002                 return true;
1003         }
1004     }
1005
1006     return featureSet.hasSelectorForAttribute(name.localName());
1007 }
1008
1009 // Returns true is the given attribute is an event handler.
1010 // We consider an event handler any attribute that begins with "on".
1011 // It is a simple solution that has the advantage of not requiring any
1012 // code or configuration change if a new event handler is defined.
1013
1014 static bool isEventHandlerAttribute(const QualifiedName& name)
1015 {
1016     return name.namespaceURI().isNull() && name.localName().startsWith("on");
1017 }
1018
1019 // FIXME: Share code with Element::isURLAttribute.
1020 static bool isAttributeToRemove(const QualifiedName& name, const AtomicString& value)
1021 {
1022     return (name.localName() == hrefAttr.localName() || name.localName() == nohrefAttr.localName()
1023         || name == srcAttr || name == actionAttr || name == formactionAttr) && protocolIsJavaScript(stripLeadingAndTrailingHTMLSpaces(value));
1024 }
1025
1026 void Element::parserSetAttributes(const Vector<Attribute>& attributeVector, FragmentScriptingPermission scriptingPermission)
1027 {
1028     ASSERT(!inDocument());
1029     ASSERT(!parentNode());
1030
1031     ASSERT(!m_elementData);
1032
1033     if (attributeVector.isEmpty())
1034         return;
1035
1036     Vector<Attribute> filteredAttributes = attributeVector;
1037
1038     // If the element is created as result of a paste or drag-n-drop operation
1039     // we want to remove all the script and event handlers.
1040     if (!scriptingContentIsAllowed(scriptingPermission)) {
1041         size_t i = 0;
1042         while (i < filteredAttributes.size()) {
1043             Attribute& attribute = filteredAttributes[i];
1044             if (isEventHandlerAttribute(attribute.name())) {
1045                 filteredAttributes.remove(i);
1046                 continue;
1047             }
1048
1049             if (isAttributeToRemove(attribute.name(), attribute.value()))
1050                 attribute.setValue(emptyAtom);
1051             i++;
1052         }
1053     }
1054
1055     if (document() && document()->sharedObjectPool())
1056         m_elementData = document()->sharedObjectPool()->cachedShareableElementDataWithAttributes(filteredAttributes);
1057     else
1058         m_elementData = ShareableElementData::createWithAttributes(filteredAttributes);
1059
1060     // Iterate over the set of attributes we already have on the stack in case
1061     // attributeChanged mutates m_elementData.
1062     // FIXME: Find a way so we don't have to do this.
1063     for (unsigned i = 0; i < filteredAttributes.size(); ++i)
1064         attributeChanged(filteredAttributes[i].name(), filteredAttributes[i].value());
1065 }
1066
1067 bool Element::hasAttributes() const
1068 {
1069     synchronizeAllAttributes();
1070     return elementData() && elementData()->length();
1071 }
1072
1073 bool Element::hasEquivalentAttributes(const Element* other) const
1074 {
1075     synchronizeAllAttributes();
1076     other->synchronizeAllAttributes();
1077     if (elementData() == other->elementData())
1078         return true;
1079     if (elementData())
1080         return elementData()->isEquivalent(other->elementData());
1081     if (other->elementData())
1082         return other->elementData()->isEquivalent(elementData());
1083     return true;
1084 }
1085
1086 String Element::nodeName() const
1087 {
1088     return m_tagName.toString();
1089 }
1090
1091 String Element::nodeNamePreservingCase() const
1092 {
1093     return m_tagName.toString();
1094 }
1095
1096 void Element::setPrefix(const AtomicString& prefix, ExceptionCode& ec)
1097 {
1098     ec = 0;
1099     checkSetPrefix(prefix, ec);
1100     if (ec)
1101         return;
1102
1103     m_tagName.setPrefix(prefix.isEmpty() ? AtomicString() : prefix);
1104 }
1105
1106 KURL Element::baseURI() const
1107 {
1108     const AtomicString& baseAttribute = getAttribute(baseAttr);
1109     KURL base(KURL(), baseAttribute);
1110     if (!base.protocol().isEmpty())
1111         return base;
1112
1113     ContainerNode* parent = parentNode();
1114     if (!parent)
1115         return base;
1116
1117     const KURL& parentBase = parent->baseURI();
1118     if (parentBase.isNull())
1119         return base;
1120
1121     return KURL(parentBase, baseAttribute);
1122 }
1123
1124 const QualifiedName& Element::imageSourceAttributeName() const
1125 {
1126     return srcAttr;
1127 }
1128
1129 bool Element::rendererIsNeeded(const NodeRenderingContext& context)
1130 {
1131     return context.style()->display() != NONE;
1132 }
1133
1134 RenderObject* Element::createRenderer(RenderArena*, RenderStyle* style)
1135 {
1136     return RenderObject::createObject(this, style);
1137 }
1138
1139 #if ENABLE(INPUT_MULTIPLE_FIELDS_UI)
1140 bool Element::isDateTimeFieldElement() const
1141 {
1142     return false;
1143 }
1144 #endif
1145
1146 bool Element::wasChangedSinceLastFormControlChangeEvent() const
1147 {
1148     return false;
1149 }
1150
1151 void Element::setChangedSinceLastFormControlChangeEvent(bool)
1152 {
1153 }
1154
1155 Node::InsertionNotificationRequest Element::insertedInto(ContainerNode* insertionPoint)
1156 {
1157     // need to do superclass processing first so inDocument() is true
1158     // by the time we reach updateId
1159     ContainerNode::insertedInto(insertionPoint);
1160
1161 #if ENABLE(FULLSCREEN_API)
1162     if (containsFullScreenElement() && parentElement() && !parentElement()->containsFullScreenElement())
1163         setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(true);
1164 #endif
1165
1166     if (Element* before = pseudoElement(BEFORE))
1167         before->insertedInto(insertionPoint);
1168
1169     if (Element* after = pseudoElement(AFTER))
1170         after->insertedInto(insertionPoint);
1171
1172     if (!insertionPoint->isInTreeScope())
1173         return InsertionDone;
1174
1175     if (hasRareData())
1176         elementRareData()->clearClassListValueForQuirksMode();
1177
1178     TreeScope* scope = insertionPoint->treeScope();
1179     if (scope != treeScope())
1180         return InsertionDone;
1181
1182     const AtomicString& idValue = getIdAttribute();
1183     if (!idValue.isNull())
1184         updateId(scope, nullAtom, idValue);
1185
1186     const AtomicString& nameValue = getNameAttribute();
1187     if (!nameValue.isNull())
1188         updateName(nullAtom, nameValue);
1189
1190     if (hasTagName(labelTag)) {
1191         if (scope->shouldCacheLabelsByForAttribute())
1192             updateLabel(scope, nullAtom, fastGetAttribute(forAttr));
1193     }
1194
1195     return InsertionDone;
1196 }
1197
1198 void Element::removedFrom(ContainerNode* insertionPoint)
1199 {
1200 #if ENABLE(SVG)
1201     bool wasInDocument = insertionPoint->document();
1202 #endif
1203
1204     if (Element* before = pseudoElement(BEFORE))
1205         before->removedFrom(insertionPoint);
1206
1207     if (Element* after = pseudoElement(AFTER))
1208         after->removedFrom(insertionPoint);
1209
1210 #if ENABLE(DIALOG_ELEMENT)
1211     document()->removeFromTopLayer(this);
1212 #endif
1213 #if ENABLE(FULLSCREEN_API)
1214     if (containsFullScreenElement())
1215         setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(false);
1216 #endif
1217 #if ENABLE(POINTER_LOCK)
1218     if (document()->page())
1219         document()->page()->pointerLockController()->elementRemoved(this);
1220 #endif
1221
1222     setSavedLayerScrollOffset(IntSize());
1223
1224     if (insertionPoint->isInTreeScope() && treeScope() == document()) {
1225         const AtomicString& idValue = getIdAttribute();
1226         if (!idValue.isNull())
1227             updateId(insertionPoint->treeScope(), idValue, nullAtom);
1228
1229         const AtomicString& nameValue = getNameAttribute();
1230         if (!nameValue.isNull())
1231             updateName(nameValue, nullAtom);
1232
1233         if (hasTagName(labelTag)) {
1234             TreeScope* treeScope = insertionPoint->treeScope();
1235             if (treeScope->shouldCacheLabelsByForAttribute())
1236                 updateLabel(treeScope, fastGetAttribute(forAttr), nullAtom);
1237         }
1238     }
1239
1240     ContainerNode::removedFrom(insertionPoint);
1241 #if ENABLE(SVG)
1242     if (wasInDocument && hasPendingResources())
1243         document()->accessSVGExtensions()->removeElementFromPendingResources(this);
1244 #endif
1245 }
1246
1247 void Element::createRendererIfNeeded()
1248 {
1249     NodeRenderingContext(this).createRendererForElementIfNeeded();
1250 }
1251
1252 void Element::attach()
1253 {
1254     PostAttachCallbackDisabler callbackDisabler(this);
1255     StyleResolverParentPusher parentPusher(this);
1256     WidgetHierarchyUpdatesSuspensionScope suspendWidgetHierarchyUpdates;
1257
1258     createRendererIfNeeded();
1259
1260     if (parentElement() && parentElement()->isInCanvasSubtree())
1261         setIsInCanvasSubtree(true);
1262
1263     updatePseudoElement(BEFORE);
1264
1265     // When a shadow root exists, it does the work of attaching the children.
1266     if (ElementShadow* shadow = this->shadow()) {
1267         parentPusher.push();
1268         shadow->attach();
1269     } else if (firstChild())
1270         parentPusher.push();
1271
1272     ContainerNode::attach();
1273
1274     updatePseudoElement(AFTER);
1275
1276     if (hasRareData()) {
1277         ElementRareData* data = elementRareData();
1278         if (data->needsFocusAppearanceUpdateSoonAfterAttach()) {
1279             if (isFocusable() && document()->focusedNode() == this)
1280                 document()->updateFocusAppearanceSoon(false /* don't restore selection */);
1281             data->setNeedsFocusAppearanceUpdateSoonAfterAttach(false);
1282         }
1283     }
1284 }
1285
1286 void Element::unregisterNamedFlowContentNode()
1287 {
1288     if (document()->cssRegionsEnabled() && inNamedFlow() && document()->renderView())
1289         document()->renderView()->flowThreadController()->unregisterNamedFlowContentNode(this);
1290 }
1291
1292 void Element::detach()
1293 {
1294     WidgetHierarchyUpdatesSuspensionScope suspendWidgetHierarchyUpdates;
1295     unregisterNamedFlowContentNode();
1296     cancelFocusAppearanceUpdate();
1297     if (hasRareData()) {
1298         ElementRareData* data = elementRareData();
1299         data->setPseudoElement(BEFORE, 0);
1300         data->setPseudoElement(AFTER, 0);
1301         data->setIsInCanvasSubtree(false);
1302         data->resetComputedStyle();
1303         data->resetDynamicRestyleObservations();
1304     }
1305
1306     if (ElementShadow* shadow = this->shadow()) {
1307         detachChildrenIfNeeded();
1308         shadow->detach();
1309     }
1310     ContainerNode::detach();
1311 }
1312
1313 bool Element::pseudoStyleCacheIsInvalid(const RenderStyle* currentStyle, RenderStyle* newStyle)
1314 {
1315     ASSERT(currentStyle == renderStyle());
1316     ASSERT(renderer());
1317
1318     if (!currentStyle)
1319         return false;
1320
1321     const PseudoStyleCache* pseudoStyleCache = currentStyle->cachedPseudoStyles();
1322     if (!pseudoStyleCache)
1323         return false;
1324
1325     size_t cacheSize = pseudoStyleCache->size();
1326     for (size_t i = 0; i < cacheSize; ++i) {
1327         RefPtr<RenderStyle> newPseudoStyle;
1328         PseudoId pseudoId = pseudoStyleCache->at(i)->styleType();
1329         if (pseudoId == FIRST_LINE || pseudoId == FIRST_LINE_INHERITED)
1330             newPseudoStyle = renderer()->uncachedFirstLineStyle(newStyle);
1331         else
1332             newPseudoStyle = renderer()->getUncachedPseudoStyle(PseudoStyleRequest(pseudoId), newStyle, newStyle);
1333         if (!newPseudoStyle)
1334             return true;
1335         if (*newPseudoStyle != *pseudoStyleCache->at(i)) {
1336             if (pseudoId < FIRST_INTERNAL_PSEUDOID)
1337                 newStyle->setHasPseudoStyle(pseudoId);
1338             newStyle->addCachedPseudoStyle(newPseudoStyle);
1339             if (pseudoId == FIRST_LINE || pseudoId == FIRST_LINE_INHERITED) {
1340                 // FIXME: We should do an actual diff to determine whether a repaint vs. layout
1341                 // is needed, but for now just assume a layout will be required.  The diff code
1342                 // in RenderObject::setStyle would need to be factored out so that it could be reused.
1343                 renderer()->setNeedsLayoutAndPrefWidthsRecalc();
1344             }
1345             return true;
1346         }
1347     }
1348     return false;
1349 }
1350
1351 PassRefPtr<RenderStyle> Element::styleForRenderer()
1352 {
1353     if (hasCustomStyleCallbacks()) {
1354         if (RefPtr<RenderStyle> style = customStyleForRenderer())
1355             return style.release();
1356     }
1357
1358     return document()->styleResolver()->styleForElement(this);
1359 }
1360
1361 void Element::recalcStyle(StyleChange change)
1362 {
1363     if (hasCustomStyleCallbacks()) {
1364         if (!willRecalcStyle(change))
1365             return;
1366     }
1367
1368     // Ref currentStyle in case it would otherwise be deleted when setting the new style in the renderer.
1369     RefPtr<RenderStyle> currentStyle(renderStyle());
1370     bool hasParentStyle = parentNodeForRenderingAndStyle() ? static_cast<bool>(parentNodeForRenderingAndStyle()->renderStyle()) : false;
1371     bool hasDirectAdjacentRules = childrenAffectedByDirectAdjacentRules();
1372     bool hasIndirectAdjacentRules = childrenAffectedByForwardPositionalRules();
1373
1374     if ((change > NoChange || needsStyleRecalc())) {
1375         if (hasRareData())
1376             elementRareData()->resetComputedStyle();
1377     }
1378     if (hasParentStyle && (change >= Inherit || needsStyleRecalc())) {
1379         RefPtr<RenderStyle> newStyle = styleForRenderer();
1380         StyleChange ch = Node::diff(currentStyle.get(), newStyle.get(), document());
1381         if (ch == Detach || !currentStyle) {
1382             // FIXME: The style gets computed twice by calling attach. We could do better if we passed the style along.
1383             reattach();
1384             // attach recalculates the style for all children. No need to do it twice.
1385             clearNeedsStyleRecalc();
1386             clearChildNeedsStyleRecalc();
1387
1388             if (hasCustomStyleCallbacks())
1389                 didRecalcStyle(change);
1390             return;
1391         }
1392
1393         if (RenderObject* renderer = this->renderer()) {
1394             if (ch != NoChange || pseudoStyleCacheIsInvalid(currentStyle.get(), newStyle.get()) || (change == Force && renderer->requiresForcedStyleRecalcPropagation()) || styleChangeType() == SyntheticStyleChange)
1395                 renderer->setAnimatableStyle(newStyle.get());
1396             else if (needsStyleRecalc()) {
1397                 // Although no change occurred, we use the new style so that the cousin style sharing code won't get
1398                 // fooled into believing this style is the same.
1399                 renderer->setStyleInternal(newStyle.get());
1400             }
1401         }
1402
1403         // 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
1404         // 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).
1405         if (document()->styleSheetCollection()->usesRemUnits() && document()->documentElement() == this && ch != NoChange && currentStyle && newStyle && currentStyle->fontSize() != newStyle->fontSize()) {
1406             // Cached RenderStyles may depend on the re units.
1407             document()->styleResolver()->invalidateMatchedPropertiesCache();
1408             change = Force;
1409         }
1410
1411         if (change != Force) {
1412             if (styleChangeType() >= FullStyleChange)
1413                 change = Force;
1414             else
1415                 change = ch;
1416         }
1417     }
1418     StyleResolverParentPusher parentPusher(this);
1419
1420     // FIXME: This does not care about sibling combinators. Will be necessary in XBL2 world.
1421     if (ElementShadow* shadow = this->shadow()) {
1422         if (change >= Inherit || shadow->childNeedsStyleRecalc() || shadow->needsStyleRecalc()) {
1423             parentPusher.push();
1424             shadow->recalcStyle(change);
1425         }
1426     }
1427
1428     updatePseudoElement(BEFORE, change);
1429
1430     // FIXME: This check is good enough for :hover + foo, but it is not good enough for :hover + foo + bar.
1431     // For now we will just worry about the common case, since it's a lot trickier to get the second case right
1432     // without doing way too much re-resolution.
1433     bool forceCheckOfNextElementSibling = false;
1434     bool forceCheckOfAnyElementSibling = false;
1435     for (Node *n = firstChild(); n; n = n->nextSibling()) {
1436         if (n->isTextNode()) {
1437             toText(n)->recalcTextStyle(change);
1438             continue;
1439         }
1440         if (!n->isElementNode())
1441             continue;
1442         Element* element = static_cast<Element*>(n);
1443         bool childRulesChanged = element->needsStyleRecalc() && element->styleChangeType() == FullStyleChange;
1444         if ((forceCheckOfNextElementSibling || forceCheckOfAnyElementSibling))
1445             element->setNeedsStyleRecalc();
1446         if (change >= Inherit || element->childNeedsStyleRecalc() || element->needsStyleRecalc()) {
1447             parentPusher.push();
1448             element->recalcStyle(change);
1449         }
1450         forceCheckOfNextElementSibling = childRulesChanged && hasDirectAdjacentRules;
1451         forceCheckOfAnyElementSibling = forceCheckOfAnyElementSibling || (childRulesChanged && hasIndirectAdjacentRules);
1452     }
1453
1454     updatePseudoElement(AFTER, change);
1455
1456     clearNeedsStyleRecalc();
1457     clearChildNeedsStyleRecalc();
1458
1459     if (hasCustomStyleCallbacks())
1460         didRecalcStyle(change);
1461 }
1462
1463 ElementShadow* Element::shadow() const
1464 {
1465     return hasRareData() ? elementRareData()->shadow() : 0;
1466 }
1467
1468 ElementShadow* Element::ensureShadow()
1469 {
1470     return ensureElementRareData()->ensureShadow();
1471 }
1472
1473 void Element::didAffectSelector(AffectedSelectorMask mask)
1474 {
1475     setNeedsStyleRecalc();
1476     if (ElementShadow* elementShadow = shadowOfParentForDistribution(this))
1477         elementShadow->didAffectSelector(mask);
1478 }
1479
1480 PassRefPtr<ShadowRoot> Element::createShadowRoot(ExceptionCode& ec)
1481 {
1482     if (alwaysCreateUserAgentShadowRoot())
1483         ensureUserAgentShadowRoot();
1484
1485 #if ENABLE(SHADOW_DOM)
1486     if (RuntimeEnabledFeatures::authorShadowDOMForAnyElementEnabled())
1487         return ensureShadow()->addShadowRoot(this, ShadowRoot::AuthorShadowRoot);
1488 #endif
1489
1490     // Since some elements recreates shadow root dynamically, multiple shadow
1491     // subtrees won't work well in that element. Until they are fixed, we disable
1492     // adding author shadow root for them.
1493     if (!areAuthorShadowsAllowed()) {
1494         ec = HIERARCHY_REQUEST_ERR;
1495         return 0;
1496     }
1497     return ensureShadow()->addShadowRoot(this, ShadowRoot::AuthorShadowRoot);
1498 }
1499
1500 ShadowRoot* Element::shadowRoot() const
1501 {
1502     ElementShadow* elementShadow = shadow();
1503     if (!elementShadow)
1504         return 0;
1505     ShadowRoot* shadowRoot = elementShadow->youngestShadowRoot();
1506     if (shadowRoot->type() == ShadowRoot::AuthorShadowRoot)
1507         return shadowRoot;
1508     return 0;
1509 }
1510
1511 ShadowRoot* Element::userAgentShadowRoot() const
1512 {
1513     if (ElementShadow* elementShadow = shadow()) {
1514         if (ShadowRoot* shadowRoot = elementShadow->oldestShadowRoot()) {
1515             ASSERT(shadowRoot->type() == ShadowRoot::UserAgentShadowRoot);
1516             return shadowRoot;
1517         }
1518     }
1519
1520     return 0;
1521 }
1522
1523 ShadowRoot* Element::ensureUserAgentShadowRoot()
1524 {
1525     if (ShadowRoot* shadowRoot = userAgentShadowRoot())
1526         return shadowRoot;
1527     ShadowRoot* shadowRoot = ensureShadow()->addShadowRoot(this, ShadowRoot::UserAgentShadowRoot);
1528     didAddUserAgentShadowRoot(shadowRoot);
1529     return shadowRoot;
1530 }
1531
1532 const AtomicString& Element::shadowPseudoId() const
1533 {
1534     return pseudo();
1535 }
1536
1537 bool Element::childTypeAllowed(NodeType type) const
1538 {
1539     switch (type) {
1540     case ELEMENT_NODE:
1541     case TEXT_NODE:
1542     case COMMENT_NODE:
1543     case PROCESSING_INSTRUCTION_NODE:
1544     case CDATA_SECTION_NODE:
1545     case ENTITY_REFERENCE_NODE:
1546         return true;
1547     default:
1548         break;
1549     }
1550     return false;
1551 }
1552
1553 static void checkForEmptyStyleChange(Element* element, RenderStyle* style)
1554 {
1555     if (!style && !element->styleAffectedByEmpty())
1556         return;
1557
1558     if (!style || (element->styleAffectedByEmpty() && (!style->emptyState() || element->hasChildNodes())))
1559         element->setNeedsStyleRecalc();
1560 }
1561
1562 static void checkForSiblingStyleChanges(Element* e, RenderStyle* style, bool finishedParsingCallback,
1563                                         Node* beforeChange, Node* afterChange, int childCountDelta)
1564 {
1565     // :empty selector.
1566     checkForEmptyStyleChange(e, style);
1567
1568     if (!style || (e->needsStyleRecalc() && e->childrenAffectedByPositionalRules()))
1569         return;
1570
1571     // :first-child.  In the parser callback case, we don't have to check anything, since we were right the first time.
1572     // In the DOM case, we only need to do something if |afterChange| is not 0.
1573     // |afterChange| is 0 in the parser case, so it works out that we'll skip this block.
1574     if (e->childrenAffectedByFirstChildRules() && afterChange) {
1575         // Find our new first child.
1576         Node* newFirstChild = 0;
1577         for (newFirstChild = e->firstChild(); newFirstChild && !newFirstChild->isElementNode(); newFirstChild = newFirstChild->nextSibling()) {};
1578
1579         // Find the first element node following |afterChange|
1580         Node* firstElementAfterInsertion = 0;
1581         for (firstElementAfterInsertion = afterChange;
1582              firstElementAfterInsertion && !firstElementAfterInsertion->isElementNode();
1583              firstElementAfterInsertion = firstElementAfterInsertion->nextSibling()) {};
1584
1585         // This is the insert/append case.
1586         if (newFirstChild != firstElementAfterInsertion && firstElementAfterInsertion && firstElementAfterInsertion->attached() &&
1587             firstElementAfterInsertion->renderStyle() && firstElementAfterInsertion->renderStyle()->firstChildState())
1588             firstElementAfterInsertion->setNeedsStyleRecalc();
1589
1590         // We also have to handle node removal.
1591         if (childCountDelta < 0 && newFirstChild == firstElementAfterInsertion && newFirstChild && (!newFirstChild->renderStyle() || !newFirstChild->renderStyle()->firstChildState()))
1592             newFirstChild->setNeedsStyleRecalc();
1593     }
1594
1595     // :last-child.  In the parser callback case, we don't have to check anything, since we were right the first time.
1596     // In the DOM case, we only need to do something if |afterChange| is not 0.
1597     if (e->childrenAffectedByLastChildRules() && beforeChange) {
1598         // Find our new last child.
1599         Node* newLastChild = 0;
1600         for (newLastChild = e->lastChild(); newLastChild && !newLastChild->isElementNode(); newLastChild = newLastChild->previousSibling()) {};
1601
1602         // Find the last element node going backwards from |beforeChange|
1603         Node* lastElementBeforeInsertion = 0;
1604         for (lastElementBeforeInsertion = beforeChange;
1605              lastElementBeforeInsertion && !lastElementBeforeInsertion->isElementNode();
1606              lastElementBeforeInsertion = lastElementBeforeInsertion->previousSibling()) {};
1607
1608         if (newLastChild != lastElementBeforeInsertion && lastElementBeforeInsertion && lastElementBeforeInsertion->attached() &&
1609             lastElementBeforeInsertion->renderStyle() && lastElementBeforeInsertion->renderStyle()->lastChildState())
1610             lastElementBeforeInsertion->setNeedsStyleRecalc();
1611
1612         // 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
1613         // to match now.
1614         if ((childCountDelta < 0 || finishedParsingCallback) && newLastChild == lastElementBeforeInsertion && newLastChild && (!newLastChild->renderStyle() || !newLastChild->renderStyle()->lastChildState()))
1615             newLastChild->setNeedsStyleRecalc();
1616     }
1617
1618     // The + selector.  We need to invalidate the first element following the insertion point.  It is the only possible element
1619     // that could be affected by this DOM change.
1620     if (e->childrenAffectedByDirectAdjacentRules() && afterChange) {
1621         Node* firstElementAfterInsertion = 0;
1622         for (firstElementAfterInsertion = afterChange;
1623              firstElementAfterInsertion && !firstElementAfterInsertion->isElementNode();
1624              firstElementAfterInsertion = firstElementAfterInsertion->nextSibling()) {};
1625         if (firstElementAfterInsertion && firstElementAfterInsertion->attached())
1626             firstElementAfterInsertion->setNeedsStyleRecalc();
1627     }
1628
1629     // Forward positional selectors include the ~ selector, nth-child, nth-of-type, first-of-type and only-of-type.
1630     // Backward positional selectors include nth-last-child, nth-last-of-type, last-of-type and only-of-type.
1631     // We have to invalidate everything following the insertion point in the forward case, and everything before the insertion point in the
1632     // backward case.
1633     // |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.
1634     // 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
1635     // here.  recalcStyle will then force a walk of the children when it sees that this has happened.
1636     if ((e->childrenAffectedByForwardPositionalRules() && afterChange)
1637         || (e->childrenAffectedByBackwardPositionalRules() && beforeChange))
1638         e->setNeedsStyleRecalc();
1639 }
1640
1641 void Element::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)
1642 {
1643     ContainerNode::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
1644     if (changedByParser)
1645         checkForEmptyStyleChange(this, renderStyle());
1646     else
1647         checkForSiblingStyleChanges(this, renderStyle(), false, beforeChange, afterChange, childCountDelta);
1648
1649     if (ElementShadow * shadow = this->shadow())
1650         shadow->invalidateDistribution();
1651 }
1652
1653 void Element::beginParsingChildren()
1654 {
1655     clearIsParsingChildrenFinished();
1656     StyleResolver* styleResolver = document()->styleResolverIfExists();
1657     if (styleResolver && attached())
1658         styleResolver->pushParentElement(this);
1659 }
1660
1661 void Element::finishParsingChildren()
1662 {
1663     ContainerNode::finishParsingChildren();
1664     setIsParsingChildrenFinished();
1665     checkForSiblingStyleChanges(this, renderStyle(), true, lastChild(), 0, 0);
1666     if (StyleResolver* styleResolver = document()->styleResolverIfExists())
1667         styleResolver->popParentElement(this);
1668 }
1669
1670 #ifndef NDEBUG
1671 void Element::formatForDebugger(char* buffer, unsigned length) const
1672 {
1673     StringBuilder result;
1674     String s;
1675
1676     result.append(nodeName());
1677
1678     s = getIdAttribute();
1679     if (s.length() > 0) {
1680         if (result.length() > 0)
1681             result.appendLiteral("; ");
1682         result.appendLiteral("id=");
1683         result.append(s);
1684     }
1685
1686     s = getAttribute(classAttr);
1687     if (s.length() > 0) {
1688         if (result.length() > 0)
1689             result.appendLiteral("; ");
1690         result.appendLiteral("class=");
1691         result.append(s);
1692     }
1693
1694     strncpy(buffer, result.toString().utf8().data(), length - 1);
1695 }
1696 #endif
1697
1698 const Vector<RefPtr<Attr> >& Element::attrNodeList()
1699 {
1700     ASSERT(hasSyntheticAttrChildNodes());
1701     return *attrNodeListForElement(this);
1702 }
1703
1704 PassRefPtr<Attr> Element::setAttributeNode(Attr* attrNode, ExceptionCode& ec)
1705 {
1706     if (!attrNode) {
1707         ec = TYPE_MISMATCH_ERR;
1708         return 0;
1709     }
1710
1711     RefPtr<Attr> oldAttrNode = attrIfExists(attrNode->qualifiedName());
1712     if (oldAttrNode.get() == attrNode)
1713         return attrNode; // This Attr is already attached to the element.
1714
1715     // INUSE_ATTRIBUTE_ERR: Raised if node is an Attr that is already an attribute of another Element object.
1716     // The DOM user must explicitly clone Attr nodes to re-use them in other elements.
1717     if (attrNode->ownerElement()) {
1718         ec = INUSE_ATTRIBUTE_ERR;
1719         return 0;
1720     }
1721
1722     synchronizeAllAttributes();
1723     UniqueElementData* elementData = ensureUniqueElementData();
1724
1725     size_t index = elementData->getAttributeItemIndex(attrNode->qualifiedName());
1726     if (index != notFound) {
1727         if (oldAttrNode)
1728             detachAttrNodeFromElementWithValue(oldAttrNode.get(), elementData->attributeItem(index)->value());
1729         else
1730             oldAttrNode = Attr::create(document(), attrNode->qualifiedName(), elementData->attributeItem(index)->value());
1731     }
1732
1733     setAttributeInternal(index, attrNode->qualifiedName(), attrNode->value(), NotInSynchronizationOfLazyAttribute);
1734
1735     attrNode->attachToElement(this);
1736     ensureAttrNodeListForElement(this)->append(attrNode);
1737
1738     return oldAttrNode.release();
1739 }
1740
1741 PassRefPtr<Attr> Element::setAttributeNodeNS(Attr* attr, ExceptionCode& ec)
1742 {
1743     return setAttributeNode(attr, ec);
1744 }
1745
1746 PassRefPtr<Attr> Element::removeAttributeNode(Attr* attr, ExceptionCode& ec)
1747 {
1748     if (!attr) {
1749         ec = TYPE_MISMATCH_ERR;
1750         return 0;
1751     }
1752     if (attr->ownerElement() != this) {
1753         ec = NOT_FOUND_ERR;
1754         return 0;
1755     }
1756
1757     ASSERT(document() == attr->document());
1758
1759     synchronizeAttribute(attr->qualifiedName());
1760
1761     size_t index = elementData()->getAttributeItemIndex(attr->qualifiedName());
1762     if (index == notFound) {
1763         ec = NOT_FOUND_ERR;
1764         return 0;
1765     }
1766
1767     return detachAttribute(index);
1768 }
1769
1770 bool Element::parseAttributeName(QualifiedName& out, const AtomicString& namespaceURI, const AtomicString& qualifiedName, ExceptionCode& ec)
1771 {
1772     String prefix, localName;
1773     if (!Document::parseQualifiedName(qualifiedName, prefix, localName, ec))
1774         return false;
1775     ASSERT(!ec);
1776
1777     QualifiedName qName(prefix, localName, namespaceURI);
1778
1779     if (!Document::hasValidNamespaceForAttributes(qName)) {
1780         ec = NAMESPACE_ERR;
1781         return false;
1782     }
1783
1784     out = qName;
1785     return true;
1786 }
1787
1788 void Element::setAttributeNS(const AtomicString& namespaceURI, const AtomicString& qualifiedName, const AtomicString& value, ExceptionCode& ec)
1789 {
1790     QualifiedName parsedName = anyName;
1791     if (!parseAttributeName(parsedName, namespaceURI, qualifiedName, ec))
1792         return;
1793     setAttribute(parsedName, value);
1794 }
1795
1796 void Element::removeAttributeInternal(size_t index, SynchronizationOfLazyAttribute inSynchronizationOfLazyAttribute)
1797 {
1798     ASSERT_WITH_SECURITY_IMPLICATION(index < attributeCount());
1799
1800     UniqueElementData* elementData = ensureUniqueElementData();
1801
1802     QualifiedName name = elementData->attributeItem(index)->name();
1803     AtomicString valueBeingRemoved = elementData->attributeItem(index)->value();
1804
1805     if (!inSynchronizationOfLazyAttribute) {
1806         if (!valueBeingRemoved.isNull())
1807             willModifyAttribute(name, valueBeingRemoved, nullAtom);
1808     }
1809
1810     if (RefPtr<Attr> attrNode = attrIfExists(name))
1811         detachAttrNodeFromElementWithValue(attrNode.get(), elementData->attributeItem(index)->value());
1812
1813     elementData->removeAttribute(index);
1814
1815     if (!inSynchronizationOfLazyAttribute)
1816         didRemoveAttribute(name);
1817 }
1818
1819 void Element::addAttributeInternal(const QualifiedName& name, const AtomicString& value, SynchronizationOfLazyAttribute inSynchronizationOfLazyAttribute)
1820 {
1821     if (!inSynchronizationOfLazyAttribute)
1822         willModifyAttribute(name, nullAtom, value);
1823     ensureUniqueElementData()->addAttribute(name, value);
1824     if (!inSynchronizationOfLazyAttribute)
1825         didAddAttribute(name, value);
1826 }
1827
1828 void Element::removeAttribute(const AtomicString& name)
1829 {
1830     if (!elementData())
1831         return;
1832
1833     AtomicString localName = shouldIgnoreAttributeCase(this) ? name.lower() : name;
1834     size_t index = elementData()->getAttributeItemIndex(localName, false);
1835     if (index == notFound) {
1836         if (UNLIKELY(localName == styleAttr) && elementData()->m_styleAttributeIsDirty && isStyledElement())
1837             static_cast<StyledElement*>(this)->removeAllInlineStyleProperties();
1838         return;
1839     }
1840
1841     removeAttributeInternal(index, NotInSynchronizationOfLazyAttribute);
1842 }
1843
1844 void Element::removeAttributeNS(const AtomicString& namespaceURI, const AtomicString& localName)
1845 {
1846     removeAttribute(QualifiedName(nullAtom, localName, namespaceURI));
1847 }
1848
1849 PassRefPtr<Attr> Element::getAttributeNode(const AtomicString& localName)
1850 {
1851     if (!elementData())
1852         return 0;
1853     synchronizeAttribute(localName);
1854     const Attribute* attribute = elementData()->getAttributeItem(localName, shouldIgnoreAttributeCase(this));
1855     if (!attribute)
1856         return 0;
1857     return ensureAttr(attribute->name());
1858 }
1859
1860 PassRefPtr<Attr> Element::getAttributeNodeNS(const AtomicString& namespaceURI, const AtomicString& localName)
1861 {
1862     if (!elementData())
1863         return 0;
1864     QualifiedName qName(nullAtom, localName, namespaceURI);
1865     synchronizeAttribute(qName);
1866     const Attribute* attribute = elementData()->getAttributeItem(qName);
1867     if (!attribute)
1868         return 0;
1869     return ensureAttr(attribute->name());
1870 }
1871
1872 bool Element::hasAttribute(const AtomicString& localName) const
1873 {
1874     if (!elementData())
1875         return false;
1876     synchronizeAttribute(localName);
1877     return elementData()->getAttributeItem(shouldIgnoreAttributeCase(this) ? localName.lower() : localName, false);
1878 }
1879
1880 bool Element::hasAttributeNS(const AtomicString& namespaceURI, const AtomicString& localName) const
1881 {
1882     if (!elementData())
1883         return false;
1884     QualifiedName qName(nullAtom, localName, namespaceURI);
1885     synchronizeAttribute(qName);
1886     return elementData()->getAttributeItem(qName);
1887 }
1888
1889 CSSStyleDeclaration *Element::style()
1890 {
1891     return 0;
1892 }
1893
1894 void Element::focus(bool restorePreviousSelection, FocusDirection direction)
1895 {
1896     if (!inDocument())
1897         return;
1898
1899     Document* doc = document();
1900     if (doc->focusedNode() == this)
1901         return;
1902
1903     // If the stylesheets have already been loaded we can reliably check isFocusable.
1904     // If not, we continue and set the focused node on the focus controller below so
1905     // that it can be updated soon after attach.
1906     if (doc->haveStylesheetsLoaded()) {
1907         doc->updateLayoutIgnorePendingStylesheets();
1908         if (!isFocusable())
1909             return;
1910     }
1911
1912     if (!supportsFocus())
1913         return;
1914
1915     RefPtr<Node> protect;
1916     if (Page* page = doc->page()) {
1917         // Focus and change event handlers can cause us to lose our last ref.
1918         // If a focus event handler changes the focus to a different node it
1919         // does not make sense to continue and update appearence.
1920         protect = this;
1921         if (!page->focusController()->setFocusedNode(this, doc->frame(), direction))
1922             return;
1923     }
1924
1925     // Setting the focused node above might have invalidated the layout due to scripts.
1926     doc->updateLayoutIgnorePendingStylesheets();
1927
1928     if (!isFocusable()) {
1929         ensureElementRareData()->setNeedsFocusAppearanceUpdateSoonAfterAttach(true);
1930         return;
1931     }
1932
1933     cancelFocusAppearanceUpdate();
1934     updateFocusAppearance(restorePreviousSelection);
1935 }
1936
1937 void Element::updateFocusAppearance(bool /*restorePreviousSelection*/)
1938 {
1939     if (isRootEditableElement()) {
1940         Frame* frame = document()->frame();
1941         if (!frame)
1942             return;
1943
1944         // When focusing an editable element in an iframe, don't reset the selection if it already contains a selection.
1945         if (this == frame->selection()->rootEditableElement())
1946             return;
1947
1948         // FIXME: We should restore the previous selection if there is one.
1949         VisibleSelection newSelection = VisibleSelection(firstPositionInOrBeforeNode(this), DOWNSTREAM);
1950
1951         if (frame->selection()->shouldChangeSelection(newSelection)) {
1952             frame->selection()->setSelection(newSelection);
1953             frame->selection()->revealSelection();
1954         }
1955     } else if (renderer() && !renderer()->isWidget())
1956         renderer()->scrollRectToVisible(boundingBox());
1957 }
1958
1959 void Element::blur()
1960 {
1961     cancelFocusAppearanceUpdate();
1962     Document* doc = document();
1963     if (treeScope()->focusedNode() == this) {
1964         if (doc->frame())
1965             doc->frame()->page()->focusController()->setFocusedNode(0, doc->frame());
1966         else
1967             doc->setFocusedNode(0);
1968     }
1969 }
1970
1971 String Element::innerText()
1972 {
1973     // We need to update layout, since plainText uses line boxes in the render tree.
1974     document()->updateLayoutIgnorePendingStylesheets();
1975
1976     if (!renderer())
1977         return textContent(true);
1978
1979     return plainText(rangeOfContents(const_cast<Element*>(this)).get());
1980 }
1981
1982 String Element::outerText()
1983 {
1984     // Getting outerText is the same as getting innerText, only
1985     // setting is different. You would think this should get the plain
1986     // text for the outer range, but this is wrong, <br> for instance
1987     // would return different values for inner and outer text by such
1988     // a rule, but it doesn't in WinIE, and we want to match that.
1989     return innerText();
1990 }
1991
1992 String Element::title() const
1993 {
1994     return String();
1995 }
1996
1997 const AtomicString& Element::pseudo() const
1998 {
1999     return getAttribute(pseudoAttr);
2000 }
2001
2002 void Element::setPseudo(const AtomicString& value)
2003 {
2004     setAttribute(pseudoAttr, value);
2005 }
2006
2007 LayoutSize Element::minimumSizeForResizing() const
2008 {
2009     return hasRareData() ? elementRareData()->minimumSizeForResizing() : defaultMinimumSizeForResizing();
2010 }
2011
2012 void Element::setMinimumSizeForResizing(const LayoutSize& size)
2013 {
2014     if (!hasRareData() && size == defaultMinimumSizeForResizing())
2015         return;
2016     ensureElementRareData()->setMinimumSizeForResizing(size);
2017 }
2018
2019 RenderStyle* Element::computedStyle(PseudoId pseudoElementSpecifier)
2020 {
2021     if (PseudoElement* element = pseudoElement(pseudoElementSpecifier))
2022         return element->computedStyle();
2023
2024     // FIXME: Find and use the renderer from the pseudo element instead of the actual element so that the 'length'
2025     // properties, which are only known by the renderer because it did the layout, will be correct and so that the
2026     // values returned for the ":selection" pseudo-element will be correct.
2027     if (RenderStyle* usedStyle = renderStyle()) {
2028         if (pseudoElementSpecifier) {
2029             RenderStyle* cachedPseudoStyle = usedStyle->getCachedPseudoStyle(pseudoElementSpecifier);
2030             return cachedPseudoStyle ? cachedPseudoStyle : usedStyle;
2031          } else
2032             return usedStyle;
2033     }
2034
2035     if (!attached())
2036         // FIXME: Try to do better than this. Ensure that styleForElement() works for elements that are not in the
2037         // document tree and figure out when to destroy the computed style for such elements.
2038         return 0;
2039
2040     ElementRareData* data = ensureElementRareData();
2041     if (!data->computedStyle())
2042         data->setComputedStyle(document()->styleForElementIgnoringPendingStylesheets(this));
2043     return pseudoElementSpecifier ? data->computedStyle()->getCachedPseudoStyle(pseudoElementSpecifier) : data->computedStyle();
2044 }
2045
2046 void Element::setStyleAffectedByEmpty()
2047 {
2048     ensureElementRareData()->setStyleAffectedByEmpty(true);
2049 }
2050
2051 void Element::setChildrenAffectedByHover(bool value)
2052 {
2053     if (value || hasRareData())
2054         ensureElementRareData()->setChildrenAffectedByHover(value);
2055 }
2056
2057 void Element::setChildrenAffectedByActive(bool value)
2058 {
2059     if (value || hasRareData())
2060         ensureElementRareData()->setChildrenAffectedByActive(value);
2061 }
2062
2063 void Element::setChildrenAffectedByDrag(bool value)
2064 {
2065     if (value || hasRareData())
2066         ensureElementRareData()->setChildrenAffectedByDrag(value);
2067 }
2068
2069 void Element::setChildrenAffectedByFirstChildRules()
2070 {
2071     ensureElementRareData()->setChildrenAffectedByFirstChildRules(true);
2072 }
2073
2074 void Element::setChildrenAffectedByLastChildRules()
2075 {
2076     ensureElementRareData()->setChildrenAffectedByLastChildRules(true);
2077 }
2078
2079 void Element::setChildrenAffectedByDirectAdjacentRules()
2080 {
2081     ensureElementRareData()->setChildrenAffectedByDirectAdjacentRules(true);
2082 }
2083
2084 void Element::setChildrenAffectedByForwardPositionalRules()
2085 {
2086     ensureElementRareData()->setChildrenAffectedByForwardPositionalRules(true);
2087 }
2088
2089 void Element::setChildrenAffectedByBackwardPositionalRules()
2090 {
2091     ensureElementRareData()->setChildrenAffectedByBackwardPositionalRules(true);
2092 }
2093
2094 void Element::setChildIndex(unsigned index)
2095 {
2096     ElementRareData* rareData = ensureElementRareData();
2097     if (RenderStyle* style = renderStyle())
2098         style->setUnique();
2099     rareData->setChildIndex(index);
2100 }
2101
2102 bool Element::hasFlagsSetDuringStylingOfChildren() const
2103 {
2104     if (!hasRareData())
2105         return false;
2106     return rareDataChildrenAffectedByHover()
2107         || rareDataChildrenAffectedByActive()
2108         || rareDataChildrenAffectedByDrag()
2109         || rareDataChildrenAffectedByFirstChildRules()
2110         || rareDataChildrenAffectedByLastChildRules()
2111         || rareDataChildrenAffectedByDirectAdjacentRules()
2112         || rareDataChildrenAffectedByForwardPositionalRules()
2113         || rareDataChildrenAffectedByBackwardPositionalRules();
2114 }
2115
2116 bool Element::rareDataStyleAffectedByEmpty() const
2117 {
2118     ASSERT(hasRareData());
2119     return elementRareData()->styleAffectedByEmpty();
2120 }
2121
2122 bool Element::rareDataChildrenAffectedByHover() const
2123 {
2124     ASSERT(hasRareData());
2125     return elementRareData()->childrenAffectedByHover();
2126 }
2127
2128 bool Element::rareDataChildrenAffectedByActive() const
2129 {
2130     ASSERT(hasRareData());
2131     return elementRareData()->childrenAffectedByActive();
2132 }
2133
2134 bool Element::rareDataChildrenAffectedByDrag() const
2135 {
2136     ASSERT(hasRareData());
2137     return elementRareData()->childrenAffectedByDrag();
2138 }
2139
2140 bool Element::rareDataChildrenAffectedByFirstChildRules() const
2141 {
2142     ASSERT(hasRareData());
2143     return elementRareData()->childrenAffectedByFirstChildRules();
2144 }
2145
2146 bool Element::rareDataChildrenAffectedByLastChildRules() const
2147 {
2148     ASSERT(hasRareData());
2149     return elementRareData()->childrenAffectedByLastChildRules();
2150 }
2151
2152 bool Element::rareDataChildrenAffectedByDirectAdjacentRules() const
2153 {
2154     ASSERT(hasRareData());
2155     return elementRareData()->childrenAffectedByDirectAdjacentRules();
2156 }
2157
2158 bool Element::rareDataChildrenAffectedByForwardPositionalRules() const
2159 {
2160     ASSERT(hasRareData());
2161     return elementRareData()->childrenAffectedByForwardPositionalRules();
2162 }
2163
2164 bool Element::rareDataChildrenAffectedByBackwardPositionalRules() const
2165 {
2166     ASSERT(hasRareData());
2167     return elementRareData()->childrenAffectedByBackwardPositionalRules();
2168 }
2169
2170 unsigned Element::rareDataChildIndex() const
2171 {
2172     ASSERT(hasRareData());
2173     return elementRareData()->childIndex();
2174 }
2175
2176 void Element::setIsInCanvasSubtree(bool isInCanvasSubtree)
2177 {
2178     ensureElementRareData()->setIsInCanvasSubtree(isInCanvasSubtree);
2179 }
2180
2181 bool Element::isInCanvasSubtree() const
2182 {
2183     return hasRareData() && elementRareData()->isInCanvasSubtree();
2184 }
2185
2186 AtomicString Element::computeInheritedLanguage() const
2187 {
2188     const Node* n = this;
2189     AtomicString value;
2190     // The language property is inherited, so we iterate over the parents to find the first language.
2191     do {
2192         if (n->isElementNode()) {
2193             if (const ElementData* elementData = static_cast<const Element*>(n)->elementData()) {
2194                 // Spec: xml:lang takes precedence -- http://www.w3.org/TR/xhtml1/#C_7
2195                 if (const Attribute* attribute = elementData->getAttributeItem(XMLNames::langAttr))
2196                     value = attribute->value();
2197                 else if (const Attribute* attribute = elementData->getAttributeItem(HTMLNames::langAttr))
2198                     value = attribute->value();
2199             }
2200         } else if (n->isDocumentNode()) {
2201             // checking the MIME content-language
2202             value = static_cast<const Document*>(n)->contentLanguage();
2203         }
2204
2205         n = n->parentNode();
2206     } while (n && value.isNull());
2207
2208     return value;
2209 }
2210
2211 Locale& Element::locale() const
2212 {
2213     return document()->getCachedLocale(computeInheritedLanguage());
2214 }
2215
2216 void Element::cancelFocusAppearanceUpdate()
2217 {
2218     if (hasRareData())
2219         elementRareData()->setNeedsFocusAppearanceUpdateSoonAfterAttach(false);
2220     if (document()->focusedNode() == this)
2221         document()->cancelFocusAppearanceUpdate();
2222 }
2223
2224 void Element::normalizeAttributes()
2225 {
2226     if (!hasAttributes())
2227         return;
2228     for (unsigned i = 0; i < attributeCount(); ++i) {
2229         if (RefPtr<Attr> attr = attrIfExists(attributeItem(i)->name()))
2230             attr->normalize();
2231     }
2232 }
2233
2234 void Element::updatePseudoElement(PseudoId pseudoId, StyleChange change)
2235 {
2236     PseudoElement* existing = pseudoElement(pseudoId);
2237     if (existing) {
2238         // PseudoElement styles hang off their parent element's style so if we needed
2239         // a style recalc we should Force one on the pseudo.
2240         existing->recalcStyle(needsStyleRecalc() ? Force : change);
2241
2242         // Wait until our parent is not displayed or pseudoElementRendererIsNeeded
2243         // is false, otherwise we could continously create and destroy PseudoElements
2244         // when RenderObject::isChildAllowed on our parent returns false for the
2245         // PseudoElement's renderer for each style recalc.
2246         if (!renderer() || !pseudoElementRendererIsNeeded(renderer()->getCachedPseudoStyle(pseudoId)))
2247             setPseudoElement(pseudoId, 0);
2248     } else if (RefPtr<PseudoElement> element = createPseudoElementIfNeeded(pseudoId)) {
2249         element->attach();
2250         setPseudoElement(pseudoId, element.release());
2251     }
2252 }
2253
2254 PassRefPtr<PseudoElement> Element::createPseudoElementIfNeeded(PseudoId pseudoId)
2255 {
2256     if (!document()->styleSheetCollection()->usesBeforeAfterRules())
2257         return 0;
2258
2259     if (!renderer() || !renderer()->canHaveGeneratedChildren())
2260         return 0;
2261
2262     if (isPseudoElement())
2263         return 0;
2264
2265     if (!pseudoElementRendererIsNeeded(renderer()->getCachedPseudoStyle(pseudoId)))
2266         return 0;
2267
2268     return PseudoElement::create(this, pseudoId);
2269 }
2270
2271 bool Element::hasPseudoElements() const
2272 {
2273     return hasRareData() && elementRareData()->hasPseudoElements();
2274 }
2275
2276 PseudoElement* Element::pseudoElement(PseudoId pseudoId) const
2277 {
2278     return hasRareData() ? elementRareData()->pseudoElement(pseudoId) : 0;
2279 }
2280
2281 void Element::setPseudoElement(PseudoId pseudoId, PassRefPtr<PseudoElement> element)
2282 {
2283     ensureElementRareData()->setPseudoElement(pseudoId, element);
2284     resetNeedsShadowTreeWalker();
2285 }
2286
2287 RenderObject* Element::pseudoElementRenderer(PseudoId pseudoId) const
2288 {
2289     if (PseudoElement* element = pseudoElement(pseudoId))
2290         return element->renderer();
2291     return 0;
2292 }
2293
2294 // ElementTraversal API
2295 Element* Element::firstElementChild() const
2296 {
2297     return ElementTraversal::firstWithin(this);
2298 }
2299
2300 Element* Element::lastElementChild() const
2301 {
2302     Node* n = lastChild();
2303     while (n && !n->isElementNode())
2304         n = n->previousSibling();
2305     return static_cast<Element*>(n);
2306 }
2307
2308 unsigned Element::childElementCount() const
2309 {
2310     unsigned count = 0;
2311     Node* n = firstChild();
2312     while (n) {
2313         count += n->isElementNode();
2314         n = n->nextSibling();
2315     }
2316     return count;
2317 }
2318
2319 bool Element::matchesReadOnlyPseudoClass() const
2320 {
2321     return false;
2322 }
2323
2324 bool Element::matchesReadWritePseudoClass() const
2325 {
2326     return false;
2327 }
2328
2329 bool Element::webkitMatchesSelector(const String& selector, ExceptionCode& ec)
2330 {
2331     if (selector.isEmpty()) {
2332         ec = SYNTAX_ERR;
2333         return false;
2334     }
2335
2336     SelectorQuery* selectorQuery = document()->selectorQueryCache()->add(selector, document(), ec);
2337     if (!selectorQuery)
2338         return false;
2339     return selectorQuery->matches(this);
2340 }
2341
2342 DOMTokenList* Element::classList()
2343 {
2344     ElementRareData* data = ensureElementRareData();
2345     if (!data->classList())
2346         data->setClassList(ClassList::create(this));
2347     return data->classList();
2348 }
2349
2350 DOMStringMap* Element::dataset()
2351 {
2352     ElementRareData* data = ensureElementRareData();
2353     if (!data->dataset())
2354         data->setDataset(DatasetDOMStringMap::create(this));
2355     return data->dataset();
2356 }
2357
2358 KURL Element::getURLAttribute(const QualifiedName& name) const
2359 {
2360 #if !ASSERT_DISABLED
2361     if (elementData()) {
2362         if (const Attribute* attribute = getAttributeItem(name))
2363             ASSERT(isURLAttribute(*attribute));
2364     }
2365 #endif
2366     return document()->completeURL(stripLeadingAndTrailingHTMLSpaces(getAttribute(name)));
2367 }
2368
2369 KURL Element::getNonEmptyURLAttribute(const QualifiedName& name) const
2370 {
2371 #if !ASSERT_DISABLED
2372     if (elementData()) {
2373         if (const Attribute* attribute = getAttributeItem(name))
2374             ASSERT(isURLAttribute(*attribute));
2375     }
2376 #endif
2377     String value = stripLeadingAndTrailingHTMLSpaces(getAttribute(name));
2378     if (value.isEmpty())
2379         return KURL();
2380     return document()->completeURL(value);
2381 }
2382
2383 int Element::getIntegralAttribute(const QualifiedName& attributeName) const
2384 {
2385     return getAttribute(attributeName).string().toInt();
2386 }
2387
2388 void Element::setIntegralAttribute(const QualifiedName& attributeName, int value)
2389 {
2390     // FIXME: Need an AtomicString version of String::number.
2391     setAttribute(attributeName, String::number(value));
2392 }
2393
2394 unsigned Element::getUnsignedIntegralAttribute(const QualifiedName& attributeName) const
2395 {
2396     return getAttribute(attributeName).string().toUInt();
2397 }
2398
2399 void Element::setUnsignedIntegralAttribute(const QualifiedName& attributeName, unsigned value)
2400 {
2401     // FIXME: Need an AtomicString version of String::number.
2402     setAttribute(attributeName, String::number(value));
2403 }
2404
2405 #if ENABLE(SVG)
2406 bool Element::childShouldCreateRenderer(const NodeRenderingContext& childContext) const
2407 {
2408     // Only create renderers for SVG elements whose parents are SVG elements, or for proper <svg xmlns="svgNS"> subdocuments.
2409     if (childContext.node()->isSVGElement())
2410         return childContext.node()->hasTagName(SVGNames::svgTag) || isSVGElement();
2411
2412     return ContainerNode::childShouldCreateRenderer(childContext);
2413 }
2414 #endif
2415
2416 #if ENABLE(FULLSCREEN_API)
2417 void Element::webkitRequestFullscreen()
2418 {
2419     document()->requestFullScreenForElement(this, ALLOW_KEYBOARD_INPUT, Document::EnforceIFrameAllowFullScreenRequirement);
2420 }
2421
2422 void Element::webkitRequestFullScreen(unsigned short flags)
2423 {
2424     document()->requestFullScreenForElement(this, (flags | LEGACY_MOZILLA_REQUEST), Document::EnforceIFrameAllowFullScreenRequirement);
2425 }
2426
2427 bool Element::containsFullScreenElement() const
2428 {
2429     return hasRareData() && elementRareData()->containsFullScreenElement();
2430 }
2431
2432 void Element::setContainsFullScreenElement(bool flag)
2433 {
2434     ensureElementRareData()->setContainsFullScreenElement(flag);
2435     setNeedsStyleRecalc(SyntheticStyleChange);
2436 }
2437
2438 static Element* parentCrossingFrameBoundaries(Element* element)
2439 {
2440     ASSERT(element);
2441     return element->parentElement() ? element->parentElement() : element->document()->ownerElement();
2442 }
2443
2444 void Element::setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(bool flag)
2445 {
2446     Element* element = this;
2447     while ((element = parentCrossingFrameBoundaries(element)))
2448         element->setContainsFullScreenElement(flag);
2449 }
2450 #endif
2451
2452 #if ENABLE(DIALOG_ELEMENT)
2453 bool Element::isInTopLayer() const
2454 {
2455     return hasRareData() && elementRareData()->isInTopLayer();
2456 }
2457
2458 void Element::setIsInTopLayer(bool inTopLayer)
2459 {
2460     if (isInTopLayer() == inTopLayer)
2461         return;
2462     ensureElementRareData()->setIsInTopLayer(inTopLayer);
2463
2464     // We must ensure a reattach occurs so the renderer is inserted in the correct sibling order under RenderView according to its
2465     // top layer position, or in its usual place if not in the top layer.
2466     reattachIfAttached();
2467 }
2468 #endif
2469
2470 #if ENABLE(POINTER_LOCK)
2471 void Element::webkitRequestPointerLock()
2472 {
2473     if (document()->page())
2474         document()->page()->pointerLockController()->requestPointerLock(this);
2475 }
2476 #endif
2477
2478 SpellcheckAttributeState Element::spellcheckAttributeState() const
2479 {
2480     const AtomicString& value = getAttribute(HTMLNames::spellcheckAttr);
2481     if (value == nullAtom)
2482         return SpellcheckAttributeDefault;
2483     if (equalIgnoringCase(value, "true") || equalIgnoringCase(value, ""))
2484         return SpellcheckAttributeTrue;
2485     if (equalIgnoringCase(value, "false"))
2486         return SpellcheckAttributeFalse;
2487
2488     return SpellcheckAttributeDefault;
2489 }
2490
2491 bool Element::isSpellCheckingEnabled() const
2492 {
2493     for (const Element* element = this; element; element = element->parentOrShadowHostElement()) {
2494         switch (element->spellcheckAttributeState()) {
2495         case SpellcheckAttributeTrue:
2496             return true;
2497         case SpellcheckAttributeFalse:
2498             return false;
2499         case SpellcheckAttributeDefault:
2500             break;
2501         }
2502     }
2503
2504     return true;
2505 }
2506
2507 RenderRegion* Element::renderRegion() const
2508 {
2509     if (renderer() && renderer()->isRenderRegion())
2510         return toRenderRegion(renderer());
2511
2512     return 0;
2513 }
2514
2515 #if ENABLE(CSS_REGIONS)
2516
2517 const AtomicString& Element::webkitRegionOverset() const
2518 {
2519     document()->updateLayoutIgnorePendingStylesheets();
2520
2521     DEFINE_STATIC_LOCAL(AtomicString, undefinedState, ("undefined", AtomicString::ConstructFromLiteral));
2522     if (!document()->cssRegionsEnabled() || !renderRegion())
2523         return undefinedState;
2524
2525     switch (renderRegion()->regionState()) {
2526     case RenderRegion::RegionFit: {
2527         DEFINE_STATIC_LOCAL(AtomicString, fitState, ("fit", AtomicString::ConstructFromLiteral));
2528         return fitState;
2529     }
2530     case RenderRegion::RegionEmpty: {
2531         DEFINE_STATIC_LOCAL(AtomicString, emptyState, ("empty", AtomicString::ConstructFromLiteral));
2532         return emptyState;
2533     }
2534     case RenderRegion::RegionOverset: {
2535         DEFINE_STATIC_LOCAL(AtomicString, overflowState, ("overset", AtomicString::ConstructFromLiteral));
2536         return overflowState;
2537     }
2538     case RenderRegion::RegionUndefined:
2539         return undefinedState;
2540     }
2541
2542     ASSERT_NOT_REACHED();
2543     return undefinedState;
2544 }
2545
2546 Vector<RefPtr<Range> > Element::webkitGetRegionFlowRanges() const
2547 {
2548     document()->updateLayoutIgnorePendingStylesheets();
2549
2550     Vector<RefPtr<Range> > rangeObjects;
2551     if (document()->cssRegionsEnabled() && renderer() && renderer()->isRenderRegion()) {
2552         RenderRegion* region = toRenderRegion(renderer());
2553         if (region->isValid())
2554             region->getRanges(rangeObjects);
2555     }
2556
2557     return rangeObjects;
2558 }
2559
2560 #endif
2561
2562 #ifndef NDEBUG
2563 bool Element::fastAttributeLookupAllowed(const QualifiedName& name) const
2564 {
2565     if (name == HTMLNames::styleAttr)
2566         return false;
2567
2568 #if ENABLE(SVG)
2569     if (isSVGElement())
2570         return !static_cast<const SVGElement*>(this)->isAnimatableAttribute(name);
2571 #endif
2572
2573     return true;
2574 }
2575 #endif
2576
2577 #ifdef DUMP_NODE_STATISTICS
2578 bool Element::hasNamedNodeMap() const
2579 {
2580     return hasRareData() && elementRareData()->attributeMap();
2581 }
2582 #endif
2583
2584 inline void Element::updateName(const AtomicString& oldName, const AtomicString& newName)
2585 {
2586     if (!inDocument() || isInShadowTree())
2587         return;
2588
2589     if (oldName == newName)
2590         return;
2591
2592     if (shouldRegisterAsNamedItem())
2593         updateNamedItemRegistration(oldName, newName);
2594 }
2595
2596 inline void Element::updateId(const AtomicString& oldId, const AtomicString& newId)
2597 {
2598     if (!isInTreeScope())
2599         return;
2600
2601     if (oldId == newId)
2602         return;
2603
2604     updateId(treeScope(), oldId, newId);
2605 }
2606
2607 inline void Element::updateId(TreeScope* scope, const AtomicString& oldId, const AtomicString& newId)
2608 {
2609     ASSERT(isInTreeScope());
2610     ASSERT(oldId != newId);
2611
2612     if (!oldId.isEmpty())
2613         scope->removeElementById(oldId, this);
2614     if (!newId.isEmpty())
2615         scope->addElementById(newId, this);
2616
2617     if (shouldRegisterAsExtraNamedItem())
2618         updateExtraNamedItemRegistration(oldId, newId);
2619 }
2620
2621 void Element::updateLabel(TreeScope* scope, const AtomicString& oldForAttributeValue, const AtomicString& newForAttributeValue)
2622 {
2623     ASSERT(hasTagName(labelTag));
2624
2625     if (!inDocument())
2626         return;
2627
2628     if (oldForAttributeValue == newForAttributeValue)
2629         return;
2630
2631     if (!oldForAttributeValue.isEmpty())
2632         scope->removeLabel(oldForAttributeValue, static_cast<HTMLLabelElement*>(this));
2633     if (!newForAttributeValue.isEmpty())
2634         scope->addLabel(newForAttributeValue, static_cast<HTMLLabelElement*>(this));
2635 }
2636
2637 void Element::willModifyAttribute(const QualifiedName& name, const AtomicString& oldValue, const AtomicString& newValue)
2638 {
2639     if (isIdAttributeName(name))
2640         updateId(oldValue, newValue);
2641     else if (name == HTMLNames::nameAttr)
2642         updateName(oldValue, newValue);
2643     else if (name == HTMLNames::forAttr && hasTagName(labelTag)) {
2644         TreeScope* scope = treeScope();
2645         if (scope->shouldCacheLabelsByForAttribute())
2646             updateLabel(scope, oldValue, newValue);
2647     }
2648
2649     if (OwnPtr<MutationObserverInterestGroup> recipients = MutationObserverInterestGroup::createForAttributesMutation(this, name))
2650         recipients->enqueueMutationRecord(MutationRecord::createAttributes(this, name, oldValue));
2651
2652 #if ENABLE(INSPECTOR)
2653     InspectorInstrumentation::willModifyDOMAttr(document(), this, oldValue, newValue);
2654 #endif
2655 }
2656
2657 void Element::didAddAttribute(const QualifiedName& name, const AtomicString& value)
2658 {
2659     attributeChanged(name, value);
2660     InspectorInstrumentation::didModifyDOMAttr(document(), this, name.localName(), value);
2661     dispatchSubtreeModifiedEvent();
2662 }
2663
2664 void Element::didModifyAttribute(const QualifiedName& name, const AtomicString& value)
2665 {
2666     attributeChanged(name, value);
2667     InspectorInstrumentation::didModifyDOMAttr(document(), this, name.localName(), value);
2668     // Do not dispatch a DOMSubtreeModified event here; see bug 81141.
2669 }
2670
2671 void Element::didRemoveAttribute(const QualifiedName& name)
2672 {
2673     attributeChanged(name, nullAtom);
2674     InspectorInstrumentation::didRemoveDOMAttr(document(), this, name.localName());
2675     dispatchSubtreeModifiedEvent();
2676 }
2677
2678
2679 void Element::updateNamedItemRegistration(const AtomicString& oldName, const AtomicString& newName)
2680 {
2681     if (!document()->isHTMLDocument())
2682         return;
2683
2684     if (!oldName.isEmpty())
2685         static_cast<HTMLDocument*>(document())->removeNamedItem(oldName);
2686
2687     if (!newName.isEmpty())
2688         static_cast<HTMLDocument*>(document())->addNamedItem(newName);
2689 }
2690
2691 void Element::updateExtraNamedItemRegistration(const AtomicString& oldId, const AtomicString& newId)
2692 {
2693     if (!document()->isHTMLDocument())
2694         return;
2695
2696     if (!oldId.isEmpty())
2697         static_cast<HTMLDocument*>(document())->removeExtraNamedItem(oldId);
2698
2699     if (!newId.isEmpty())
2700         static_cast<HTMLDocument*>(document())->addExtraNamedItem(newId);
2701 }
2702
2703 PassRefPtr<HTMLCollection> Element::ensureCachedHTMLCollection(CollectionType type)
2704 {
2705     if (HTMLCollection* collection = cachedHTMLCollection(type))
2706         return collection;
2707
2708     RefPtr<HTMLCollection> collection;
2709     if (type == TableRows) {
2710         ASSERT(hasTagName(tableTag));
2711         return ensureRareData()->ensureNodeLists()->addCacheWithAtomicName<HTMLTableRowsCollection>(this, type);
2712     } else if (type == SelectOptions) {
2713         ASSERT(hasTagName(selectTag));
2714         return ensureRareData()->ensureNodeLists()->addCacheWithAtomicName<HTMLOptionsCollection>(this, type);
2715     } else if (type == FormControls) {
2716         ASSERT(hasTagName(formTag) || hasTagName(fieldsetTag));
2717         return ensureRareData()->ensureNodeLists()->addCacheWithAtomicName<HTMLFormControlsCollection>(this, type);
2718 #if ENABLE(MICRODATA)
2719     } else if (type == ItemProperties) {
2720         return ensureRareData()->ensureNodeLists()->addCacheWithAtomicName<HTMLPropertiesCollection>(this, type);
2721 #endif
2722     }
2723     return ensureRareData()->ensureNodeLists()->addCacheWithAtomicName<HTMLCollection>(this, type);
2724 }
2725
2726 HTMLCollection* Element::cachedHTMLCollection(CollectionType type)
2727 {
2728     return hasRareData() && rareData()->nodeLists() ? rareData()->nodeLists()->cacheWithAtomicName<HTMLCollection>(type) : 0;
2729 }
2730
2731 IntSize Element::savedLayerScrollOffset() const
2732 {
2733     return hasRareData() ? elementRareData()->savedLayerScrollOffset() : IntSize();
2734 }
2735
2736 void Element::setSavedLayerScrollOffset(const IntSize& size)
2737 {
2738     if (size.isZero() && !hasRareData())
2739         return;
2740     ensureElementRareData()->setSavedLayerScrollOffset(size);
2741 }
2742
2743 PassRefPtr<Attr> Element::attrIfExists(const QualifiedName& name)
2744 {
2745     if (AttrNodeList* attrNodeList = attrNodeListForElement(this))
2746         return findAttrNodeInList(attrNodeList, name);
2747     return 0;
2748 }
2749
2750 PassRefPtr<Attr> Element::ensureAttr(const QualifiedName& name)
2751 {
2752     AttrNodeList* attrNodeList = ensureAttrNodeListForElement(this);
2753     RefPtr<Attr> attrNode = findAttrNodeInList(attrNodeList, name);
2754     if (!attrNode) {
2755         attrNode = Attr::create(this, name);
2756         treeScope()->adoptIfNeeded(attrNode.get());
2757         attrNodeList->append(attrNode);
2758     }
2759     return attrNode.release();
2760 }
2761
2762 void Element::detachAttrNodeFromElementWithValue(Attr* attrNode, const AtomicString& value)
2763 {
2764     ASSERT(hasSyntheticAttrChildNodes());
2765     attrNode->detachFromElementWithValue(value);
2766
2767     AttrNodeList* attrNodeList = attrNodeListForElement(this);
2768     for (unsigned i = 0; i < attrNodeList->size(); ++i) {
2769         if (attrNodeList->at(i)->qualifiedName() == attrNode->qualifiedName()) {
2770             attrNodeList->remove(i);
2771             if (attrNodeList->isEmpty())
2772                 removeAttrNodeListForElement(this);
2773             return;
2774         }
2775     }
2776     ASSERT_NOT_REACHED();
2777 }
2778
2779 void Element::detachAllAttrNodesFromElement()
2780 {
2781     AttrNodeList* attrNodeList = attrNodeListForElement(this);
2782     ASSERT(attrNodeList);
2783
2784     for (unsigned i = 0; i < attributeCount(); ++i) {
2785         const Attribute* attribute = attributeItem(i);
2786         if (RefPtr<Attr> attrNode = findAttrNodeInList(attrNodeList, attribute->name()))
2787             attrNode->detachFromElementWithValue(attribute->value());
2788     }
2789
2790     removeAttrNodeListForElement(this);
2791 }
2792
2793 bool Element::willRecalcStyle(StyleChange)
2794 {
2795     ASSERT(hasCustomStyleCallbacks());
2796     return true;
2797 }
2798
2799 void Element::didRecalcStyle(StyleChange)
2800 {
2801     ASSERT(hasCustomStyleCallbacks());
2802 }
2803
2804
2805 PassRefPtr<RenderStyle> Element::customStyleForRenderer()
2806 {
2807     ASSERT(hasCustomStyleCallbacks());
2808     return 0;
2809 }
2810
2811 void Element::cloneAttributesFromElement(const Element& other)
2812 {
2813     if (hasSyntheticAttrChildNodes())
2814         detachAllAttrNodesFromElement();
2815
2816     other.synchronizeAllAttributes();
2817     if (!other.m_elementData) {
2818         m_elementData.clear();
2819         return;
2820     }
2821
2822     const AtomicString& oldID = getIdAttribute();
2823     const AtomicString& newID = other.getIdAttribute();
2824
2825     if (!oldID.isNull() || !newID.isNull())
2826         updateId(oldID, newID);
2827
2828     const AtomicString& oldName = getNameAttribute();
2829     const AtomicString& newName = other.getNameAttribute();
2830
2831     if (!oldName.isNull() || !newName.isNull())
2832         updateName(oldName, newName);
2833
2834     // If 'other' has a mutable ElementData, convert it to an immutable one so we can share it between both elements.
2835     // We can only do this if there is no CSSOM wrapper for other's inline style, and there are no presentation attributes.
2836     if (other.m_elementData->isUnique()
2837         && !other.m_elementData->presentationAttributeStyle()
2838         && (!other.m_elementData->inlineStyle() || !other.m_elementData->inlineStyle()->hasCSSOMWrapper()))
2839         const_cast<Element&>(other).m_elementData = static_cast<const UniqueElementData*>(other.m_elementData.get())->makeShareableCopy();
2840
2841     if (!other.m_elementData->isUnique())
2842         m_elementData = other.m_elementData;
2843     else
2844         m_elementData = other.m_elementData->makeUniqueCopy();
2845
2846     for (unsigned i = 0; i < m_elementData->length(); ++i) {
2847         const Attribute* attribute = const_cast<const ElementData*>(m_elementData.get())->attributeItem(i);
2848         attributeChanged(attribute->name(), attribute->value());
2849     }
2850 }
2851
2852 void Element::cloneDataFromElement(const Element& other)
2853 {
2854     cloneAttributesFromElement(other);
2855     copyNonAttributePropertiesFromElement(other);
2856 }
2857
2858 void Element::createUniqueElementData()
2859 {
2860     if (!m_elementData)
2861         m_elementData = UniqueElementData::create();
2862     else {
2863         ASSERT(!m_elementData->isUnique());
2864         m_elementData = static_cast<ShareableElementData*>(m_elementData.get())->makeUniqueCopy();
2865     }
2866 }
2867
2868 void Element::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
2869 {
2870     MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::DOM);
2871     ContainerNode::reportMemoryUsage(memoryObjectInfo);
2872     info.addMember(m_tagName, "tagName");
2873     info.addMember(m_elementData, "elementData");
2874 }
2875
2876 #if ENABLE(SVG)
2877 bool Element::hasPendingResources() const
2878 {
2879     return hasRareData() && elementRareData()->hasPendingResources();
2880 }
2881
2882 void Element::setHasPendingResources()
2883 {
2884     ensureElementRareData()->setHasPendingResources(true);
2885 }
2886
2887 void Element::clearHasPendingResources()
2888 {
2889     ensureElementRareData()->setHasPendingResources(false);
2890 }
2891 #endif
2892
2893 void ElementData::deref()
2894 {
2895     if (!derefBase())
2896         return;
2897
2898     if (m_isUnique)
2899         delete static_cast<UniqueElementData*>(this);
2900     else
2901         delete static_cast<ShareableElementData*>(this);
2902 }
2903
2904 ElementData::ElementData()
2905     : m_isUnique(true)
2906     , m_arraySize(0)
2907     , m_presentationAttributeStyleIsDirty(false)
2908     , m_styleAttributeIsDirty(false)
2909 #if ENABLE(SVG)
2910     , m_animatedSVGAttributesAreDirty(false)
2911 #endif
2912 {
2913 }
2914
2915 ElementData::ElementData(unsigned arraySize)
2916     : m_isUnique(false)
2917     , m_arraySize(arraySize)
2918     , m_presentationAttributeStyleIsDirty(false)
2919     , m_styleAttributeIsDirty(false)
2920 #if ENABLE(SVG)
2921     , m_animatedSVGAttributesAreDirty(false)
2922 #endif
2923 {
2924 }
2925
2926 struct SameSizeAsElementData : public RefCounted<SameSizeAsElementData> {
2927     unsigned bitfield;
2928     void* refPtrs[3];
2929 };
2930
2931 COMPILE_ASSERT(sizeof(ElementData) == sizeof(SameSizeAsElementData), element_attribute_data_should_stay_small);
2932
2933 static size_t sizeForShareableElementDataWithAttributeCount(unsigned count)
2934 {
2935     return sizeof(ShareableElementData) + sizeof(Attribute) * count;
2936 }
2937
2938 PassRefPtr<ShareableElementData> ShareableElementData::createWithAttributes(const Vector<Attribute>& attributes)
2939 {
2940     void* slot = WTF::fastMalloc(sizeForShareableElementDataWithAttributeCount(attributes.size()));
2941     return adoptRef(new (slot) ShareableElementData(attributes));
2942 }
2943
2944 PassRefPtr<UniqueElementData> UniqueElementData::create()
2945 {
2946     return adoptRef(new UniqueElementData);
2947 }
2948
2949 ShareableElementData::ShareableElementData(const Vector<Attribute>& attributes)
2950     : ElementData(attributes.size())
2951 {
2952     for (unsigned i = 0; i < m_arraySize; ++i)
2953         new (&m_attributeArray[i]) Attribute(attributes[i]);
2954 }
2955
2956 ShareableElementData::~ShareableElementData()
2957 {
2958     for (unsigned i = 0; i < m_arraySize; ++i)
2959         m_attributeArray[i].~Attribute();
2960 }
2961
2962 ShareableElementData::ShareableElementData(const UniqueElementData& other)
2963     : ElementData(other, false)
2964 {
2965     ASSERT(!other.m_presentationAttributeStyle);
2966
2967     if (other.m_inlineStyle) {
2968         ASSERT(!other.m_inlineStyle->hasCSSOMWrapper());
2969         m_inlineStyle = other.m_inlineStyle->immutableCopyIfNeeded();
2970     }
2971
2972     for (unsigned i = 0; i < m_arraySize; ++i)
2973         new (&m_attributeArray[i]) Attribute(other.m_attributeVector.at(i));
2974 }
2975
2976 ElementData::ElementData(const ElementData& other, bool isUnique)
2977     : m_isUnique(isUnique)
2978     , m_arraySize(isUnique ? 0 : other.length())
2979     , m_presentationAttributeStyleIsDirty(other.m_presentationAttributeStyleIsDirty)
2980     , m_styleAttributeIsDirty(other.m_styleAttributeIsDirty)
2981 #if ENABLE(SVG)
2982     , m_animatedSVGAttributesAreDirty(other.m_animatedSVGAttributesAreDirty)
2983 #endif
2984     , m_classNames(other.m_classNames)
2985     , m_idForStyleResolution(other.m_idForStyleResolution)
2986 {
2987     // NOTE: The inline style is copied by the subclass copy constructor since we don't know what to do with it here.
2988 }
2989
2990 UniqueElementData::UniqueElementData()
2991 {
2992 }
2993
2994 UniqueElementData::UniqueElementData(const UniqueElementData& other)
2995     : ElementData(other, true)
2996     , m_presentationAttributeStyle(other.m_presentationAttributeStyle)
2997     , m_attributeVector(other.m_attributeVector)
2998 {
2999     m_inlineStyle = other.m_inlineStyle ? other.m_inlineStyle->copy() : 0;
3000 }
3001
3002 UniqueElementData::UniqueElementData(const ShareableElementData& other)
3003     : ElementData(other, true)
3004 {
3005     // An ShareableElementData should never have a mutable inline StylePropertySet attached.
3006     ASSERT(!other.m_inlineStyle || !other.m_inlineStyle->isMutable());
3007     m_inlineStyle = other.m_inlineStyle;
3008
3009     m_attributeVector.reserveCapacity(other.length());
3010     for (unsigned i = 0; i < other.length(); ++i)
3011         m_attributeVector.uncheckedAppend(other.m_attributeArray[i]);
3012 }
3013
3014 PassRefPtr<UniqueElementData> ElementData::makeUniqueCopy() const
3015 {
3016     if (isUnique())
3017         return adoptRef(new UniqueElementData(static_cast<const UniqueElementData&>(*this)));
3018     return adoptRef(new UniqueElementData(static_cast<const ShareableElementData&>(*this)));
3019 }
3020
3021 PassRefPtr<ShareableElementData> UniqueElementData::makeShareableCopy() const
3022 {
3023     void* slot = WTF::fastMalloc(sizeForShareableElementDataWithAttributeCount(m_attributeVector.size()));
3024     return adoptRef(new (slot) ShareableElementData(*this));
3025 }
3026
3027 void UniqueElementData::addAttribute(const QualifiedName& attributeName, const AtomicString& value)
3028 {
3029     m_attributeVector.append(Attribute(attributeName, value));
3030 }
3031
3032 void UniqueElementData::removeAttribute(size_t index)
3033 {
3034     ASSERT_WITH_SECURITY_IMPLICATION(index < length());
3035     m_attributeVector.remove(index);
3036 }
3037
3038 bool ElementData::isEquivalent(const ElementData* other) const
3039 {
3040     if (!other)
3041         return isEmpty();
3042
3043     unsigned len = length();
3044     if (len != other->length())
3045         return false;
3046
3047     for (unsigned i = 0; i < len; i++) {
3048         const Attribute* attribute = attributeItem(i);
3049         const Attribute* otherAttr = other->getAttributeItem(attribute->name());
3050         if (!otherAttr || attribute->value() != otherAttr->value())
3051             return false;
3052     }
3053
3054     return true;
3055 }
3056
3057 void ElementData::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
3058 {
3059     size_t actualSize = m_isUnique ? sizeof(ElementData) : sizeForShareableElementDataWithAttributeCount(m_arraySize);
3060     MemoryClassInfo info(memoryObjectInfo, this, WebCoreMemoryTypes::DOM, actualSize);
3061     info.addMember(m_inlineStyle, "inlineStyle");
3062     info.addMember(m_classNames, "classNames");
3063     info.addMember(m_idForStyleResolution, "idForStyleResolution");
3064     if (m_isUnique) {
3065         const UniqueElementData* uniqueThis = static_cast<const UniqueElementData*>(this);
3066         info.addMember(uniqueThis->m_presentationAttributeStyle, "presentationAttributeStyle");
3067         info.addMember(uniqueThis->m_attributeVector, "attributeVector");
3068     }
3069     for (unsigned i = 0, len = length(); i < len; i++)
3070         info.addMember(*attributeItem(i), "*attributeItem");
3071 }
3072
3073 size_t ElementData::getAttributeItemIndexSlowCase(const AtomicString& name, bool shouldIgnoreAttributeCase) const
3074 {
3075     // Continue to checking case-insensitively and/or full namespaced names if necessary:
3076     for (unsigned i = 0; i < length(); ++i) {
3077         const Attribute* attribute = attributeItem(i);
3078         if (!attribute->name().hasPrefix()) {
3079             if (shouldIgnoreAttributeCase && equalIgnoringCase(name, attribute->localName()))
3080                 return i;
3081         } else {
3082             // FIXME: Would be faster to do this comparison without calling toString, which
3083             // generates a temporary string by concatenation. But this branch is only reached
3084             // if the attribute name has a prefix, which is rare in HTML.
3085             if (equalPossiblyIgnoringCase(name, attribute->name().toString(), shouldIgnoreAttributeCase))
3086                 return i;
3087         }
3088     }
3089     return notFound;
3090 }
3091
3092 Attribute* UniqueElementData::getAttributeItem(const QualifiedName& name)
3093 {
3094     for (unsigned i = 0; i < length(); ++i) {
3095         if (m_attributeVector.at(i).name().matches(name))
3096             return &m_attributeVector.at(i);
3097     }
3098     return 0;
3099 }
3100
3101 Attribute* UniqueElementData::attributeItem(unsigned index)
3102 {
3103     ASSERT_WITH_SECURITY_IMPLICATION(index < length());
3104     return &m_attributeVector.at(index);
3105 }
3106
3107 } // namespace WebCore