Move parts of core/dom to C++11

Source/core/dom/Element.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Peter Kelly (pmk@post.com)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 Apple Inc. All rights reserved.
  *           (C) 2007 Eric Seidel (eric@webkit.org)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 111 matching lines @@
 
 namespace blink {
 
 using namespace HTMLNames;
 using namespace XMLNames;
 
 typedef WillBeHeapVector<RefPtrWillBeMember<Attr> > AttrNodeList;
 
 static Attr* findAttrNodeInList(const AttrNodeList& attrNodeList, const QualifiedName& name)
 {
-    AttrNodeList::const_iterator end = attrNodeList.end();
-    for (AttrNodeList::const_iterator it = attrNodeList.begin(); it != end; ++it) {
-        if ((*it)->qualifiedName() == name)
-            return it->get();
+    for (const auto& attr : attrNodeList) {
+        if (attr->qualifiedName() == name)
+            return attr.get();
     }
-    return 0;
+    return nullptr;
 }
 
 PassRefPtrWillBeRawPtr<Element> Element::create(const QualifiedName& tagName, Document* document)
 {
     return adoptRefWillBeNoop(new Element(tagName, document, CreateElement));
 }
 
 Element::Element(const QualifiedName& tagName, Document* document, ConstructionType type)
     : ContainerNode(document, type)
     , m_tagName(tagName)
@@ skipping 187 matching lines @@
         return attributeMap;
 
     rareData.setAttributeMap(NamedNodeMap::create(const_cast<Element*>(this)));
     return rareData.attributeMap();
 }
 
 ActiveAnimations* Element::activeAnimations() const
 {
     if (hasRareData())
         return elementRareData()->activeAnimations();
-    return 0;
+    return nullptr;
 }
 
 ActiveAnimations& Element::ensureActiveAnimations()
 {
     ElementRareData& rareData = ensureElementRareData();
     if (!rareData.activeAnimations())
         rareData.setActiveAnimations(adoptPtrWillBeNoop(new ActiveAnimations()));
     return *rareData.activeAnimations();
 }
 
@@ skipping 182 matching lines @@
     if (RenderBoxModelObject* renderer = renderBoxModelObject())
         return adjustLayoutUnitForAbsoluteZoom(renderer->pixelSnappedOffsetHeight(), *renderer).round();
     return 0;
 }
 
 Element* Element::offsetParentForBindings()
 {
     Element* element = offsetParent();
     if (!element || !element->isInShadowTree())
         return element;
-    return element->containingShadowRoot()->shouldExposeToBindings() ? element : 0;
+    return element->containingShadowRoot()->shouldExposeToBindings() ? element : nullptr;
 }
 
 Element* Element::offsetParent()
 {
     document().updateLayoutIgnorePendingStylesheets();
     if (RenderObject* renderer = this->renderer())
         return renderer->offsetParent();
-    return 0;
+    return nullptr;
 }
 
 int Element::clientLeft()
 {
     document().updateLayoutIgnorePendingStylesheets();
 
     if (RenderBox* renderer = renderBox())
         return adjustLayoutUnitForAbsoluteZoom(roundToInt(renderer->clientLeft()), *renderer);
     return 0;
 }
@@ skipping 1032 matching lines @@
     updateCallbackSelectors(0, renderStyle());
 }
 
 void Element::removeCallbackSelectors()
 {
     updateCallbackSelectors(renderStyle(), 0);
 }
 
 ElementShadow* Element::shadow() const
 {
-    return hasRareData() ? elementRareData()->shadow() : 0;
+    return hasRareData() ? elementRareData()->shadow() : nullptr;
 }
 
 ElementShadow& Element::ensureShadow()
 {
     return ensureElementRareData().ensureShadow();
 }
 
 void Element::pseudoStateChanged(CSSSelector::PseudoType pseudo)
 {
     StyleResolver* styleResolver = document().styleResolver();
@@ skipping 39 matching lines @@
     if (!hasRareData() && !definition)
         return;
     ASSERT(!customElementDefinition());
     ensureElementRareData().setCustomElementDefinition(definition);
 }
 
 CustomElementDefinition* Element::customElementDefinition() const
 {
     if (hasRareData())
         return elementRareData()->customElementDefinition();
-    return 0;
+    return nullptr;
 }
 
 PassRefPtrWillBeRawPtr<ShadowRoot> Element::createShadowRoot(ExceptionState& exceptionState)
 {
     if (alwaysCreateUserAgentShadowRoot())
         ensureUserAgentShadowRoot();
 
     // Some elements make assumptions about what kind of renderers they allow
     // as children so we can't allow author shadows on them for now. An override
     // flag is provided for testing how author shadows interact on these elements.
     if (!areAuthorShadowsAllowed() && !RuntimeEnabledFeatures::authorShadowDOMForAnyElementEnabled()) {
         exceptionState.throwDOMException(HierarchyRequestError, "Author-created shadow roots are disabled for this element.");
         return nullptr;
     }
 
     return PassRefPtrWillBeRawPtr<ShadowRoot>(ensureShadow().addShadowRoot(*this, ShadowRoot::AuthorShadowRoot));
 }
 
 ShadowRoot* Element::shadowRoot() const
 {
     ElementShadow* elementShadow = shadow();
     if (!elementShadow)
-        return 0;
+        return nullptr;
     ShadowRoot* shadowRoot = elementShadow->youngestShadowRoot();
     if (shadowRoot->type() == ShadowRoot::AuthorShadowRoot)
         return shadowRoot;
-    return 0;
+    return nullptr;
 }
 
 ShadowRoot* Element::userAgentShadowRoot() const
 {
     if (ElementShadow* elementShadow = shadow()) {
         if (ShadowRoot* shadowRoot = elementShadow->oldestShadowRoot()) {
             ASSERT(shadowRoot->type() == ShadowRoot::UserAgentShadowRoot);
             return shadowRoot;
         }
     }
 
-    return 0;
+    return nullptr;
 }
 
 ShadowRoot& Element::ensureUserAgentShadowRoot()
 {
     if (ShadowRoot* shadowRoot = userAgentShadowRoot())
         return *shadowRoot;
     ShadowRoot& shadowRoot = ensureShadow().addShadowRoot(*this, ShadowRoot::UserAgentShadowRoot);
     didAddUserAgentShadowRoot(shadowRoot);
     return shadowRoot;
 }
@@ skipping 70 matching lines @@
         if (result.length() > 0)
             result.appendLiteral("; ");
         result.appendLiteral("class=");
         result.append(s);
     }
 
     strncpy(buffer, result.toString().utf8().data(), length - 1);
 }
 #endif
 
-WillBeHeapVector<RefPtrWillBeMember<Attr> >* Element::attrNodeList()
+WillBeHeapVector<RefPtrWillBeMember<Attr>>* Element::attrNodeList()
 {
-    return hasRareData() ? elementRareData()->attrNodeList() : 0;
+    return hasRareData() ? elementRareData()->attrNodeList() : nullptr;
 }
 
 WillBeHeapVector<RefPtrWillBeMember<Attr> >& Element::ensureAttrNodeList()
 {
     setHasSyntheticAttrChildNodes(true);
     return ensureElementRareData().ensureAttrNodeList();
 }
 
 void Element::removeAttrNodeList()
 {
@@ skipping 403 matching lines @@
 
     RefPtrWillBeRawPtr<Element> parent = toElement(p);
     RefPtrWillBeRawPtr<Node> prev = previousSibling();
     RefPtrWillBeRawPtr<Node> next = nextSibling();
 
     RefPtrWillBeRawPtr<DocumentFragment> fragment = createFragmentForInnerOuterHTML(html, parent.get(), AllowScriptingContent, "outerHTML", exceptionState);
     if (exceptionState.hadException())
         return;
 
     parent->replaceChild(fragment.release(), this, exceptionState);
-    RefPtrWillBeRawPtr<Node> node = next ? next->previousSibling() : 0;
+    RefPtrWillBeRawPtr<Node> node = next ? next->previousSibling() : nullptr;
     if (!exceptionState.hadException() && node && node->isTextNode())
         mergeWithNextTextNode(toText(node.get()), exceptionState);
 
     if (!exceptionState.hadException() && prev && prev->isTextNode())
         mergeWithNextTextNode(toText(prev.get()), exceptionState);
 }
 
 Node* Element::insertAdjacent(const String& where, Node* newChild, ExceptionState& exceptionState)
 {
     if (equalIgnoringCase(where, "beforeBegin")) {
         if (ContainerNode* parent = this->parentNode()) {
             parent->insertBefore(newChild, this, exceptionState);
             if (!exceptionState.hadException())
                 return newChild;
         }
-        return 0;
+        return nullptr;
     }
 
     if (equalIgnoringCase(where, "afterBegin")) {
         insertBefore(newChild, firstChild(), exceptionState);
-        return exceptionState.hadException() ? 0 : newChild;
+        return exceptionState.hadException() ? nullptr : newChild;
     }
 
     if (equalIgnoringCase(where, "beforeEnd")) {
         appendChild(newChild, exceptionState);
-        return exceptionState.hadException() ? 0 : newChild;
+        return exceptionState.hadException() ? nullptr : newChild;
     }
 
     if (equalIgnoringCase(where, "afterEnd")) {
         if (ContainerNode* parent = this->parentNode()) {
             parent->insertBefore(newChild, nextSibling(), exceptionState);
             if (!exceptionState.hadException())
                 return newChild;
         }
-        return 0;
+        return nullptr;
     }
 
     exceptionState.throwDOMException(SyntaxError, "The value provided ('" + where + "') is not one of 'beforeBegin', 'afterBegin', 'beforeEnd', or 'afterEnd'.");
-    return 0;
+    return nullptr;
 }
 
 // Step 1 of http://domparsing.spec.whatwg.org/#insertadjacenthtml()
 static Element* contextElementForInsertion(const String& where, Element* element, ExceptionState& exceptionState)
 {
     if (equalIgnoringCase(where, "beforeBegin") || equalIgnoringCase(where, "afterEnd")) {
         Element* parent = element->parentElement();
         if (!parent) {
             exceptionState.throwDOMException(NoModificationAllowedError, "The element has no parent.");
-            return 0;
+            return nullptr;
         }
         return parent;
     }
     if (equalIgnoringCase(where, "afterBegin") || equalIgnoringCase(where, "beforeEnd"))
         return element;
     exceptionState.throwDOMException(SyntaxError, "The value provided ('" + where + "') is not one of 'beforeBegin', 'afterBegin', 'beforeEnd', or 'afterEnd'.");
-    return 0;
+    return nullptr;
 }
 
 Element* Element::insertAdjacentElement(const String& where, Element* newChild, ExceptionState& exceptionState)
 {
     if (!newChild) {
         // IE throws COM Exception E_INVALIDARG; this is the best DOM exception alternative.
         exceptionState.throwTypeError("The node provided is null.");
-        return 0;
+        return nullptr;
     }
 
     Node* returnValue = insertAdjacent(where, newChild, exceptionState);
     return toElement(returnValue);
 }
 
 void Element::insertAdjacentText(const String& where, const String& text, ExceptionState& exceptionState)
 {
     insertAdjacent(where, document().createTextNode(text).get(), exceptionState);
 }
@@ skipping 114 matching lines @@
 }
 
 RenderStyle* Element::computedStyle(PseudoId pseudoElementSpecifier)
 {
     if (PseudoElement* element = pseudoElement(pseudoElementSpecifier))
         return element->computedStyle();
 
     if (!inActiveDocument()) {
         // FIXME: Try to do better than this. Ensure that styleForElement() works for elements that are not in the
         // document tree and figure out when to destroy the computed style for such elements.
-        return 0;
+        return nullptr;
     }
 
     // FIXME: Find and use the renderer from the pseudo element instead of the actual element so that the 'length'
     // properties, which are only known by the renderer because it did the layout, will be correct and so that the
     // values returned for the ":selection" pseudo-element will be correct.
     RenderStyle* elementStyle = renderStyle();
     if (!elementStyle) {
         ElementRareData& rareData = ensureElementRareData();
         if (!rareData.computedStyle())
             rareData.setComputedStyle(document().styleForElementIgnoringPendingStylesheets(this));
@@ skipping 136 matching lines @@
     element->insertedInto(this);
     element->attach();
 
     InspectorInstrumentation::pseudoElementCreated(element.get());
 
     ensureElementRareData().setPseudoElement(pseudoId, element.release());
 }
 
 PseudoElement* Element::pseudoElement(PseudoId pseudoId) const
 {
-    return hasRareData() ? elementRareData()->pseudoElement(pseudoId) : 0;
+    return hasRareData() ? elementRareData()->pseudoElement(pseudoId) : nullptr;
 }
 
 RenderObject* Element::pseudoElementRenderer(PseudoId pseudoId) const
 {
     if (PseudoElement* element = pseudoElement(pseudoId))
         return element->renderer();
-    return 0;
+    return nullptr;
 }
 
 bool Element::matches(const String& selectors, ExceptionState& exceptionState)
 {
     SelectorQuery* selectorQuery = document().selectorQueryCache().add(AtomicString(selectors), document(), exceptionState);
     if (!selectorQuery)
         return false;
     return selectorQuery->matches(*this);
 }
 
@@ skipping 479 matching lines @@
     ASSERT(elementData()->m_styleAttributeIsDirty);
     elementData()->m_styleAttributeIsDirty = false;
     const StylePropertySet* inlineStyle = this->inlineStyle();
     const_cast<Element*>(this)->setSynchronizedLazyAttribute(styleAttr,
         inlineStyle ? AtomicString(inlineStyle->asText()) : nullAtom);
 }
 
 CSSStyleDeclaration* Element::style()
 {
     if (!isStyledElement())
-        return 0;
+        return nullptr;
     return &ensureElementRareData().ensureInlineCSSStyleDeclaration(this);
 }
 
 MutableStylePropertySet& Element::ensureMutableInlineStyle()
 {
     ASSERT(isStyledElement());
     RefPtrWillBeMember<StylePropertySet>& inlineStyle = ensureUniqueElementData().m_inlineStyle;
     if (!inlineStyle) {
         CSSParserMode mode = (!isHTMLElement() || document().inQuirksMode()) ? HTMLQuirksMode : HTMLStandardMode;
         inlineStyle = MutableStylePropertySet::create(mode);
@@ skipping 209 matching lines @@
         return wrapper;
 
     CustomElementBinding* binding = perContextData->customElementBinding(customElementDefinition());
 
     wrapper->SetPrototype(binding->prototype());
 
     return V8DOMWrapper::associateObjectWithWrapperNonTemplate(this, wrapperType, wrapper, isolate);
 }
 
 } // namespace blink