Move parts of core/dom to C++11

Source/core/dom/Node.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 106 matching lines @@
 }
 
 void Node::operator delete(void* ptr)
 {
     ASSERT(isMainThread());
     partitionFree(ptr);
 }
 #endif
 
 #if DUMP_NODE_STATISTICS
-typedef WillBeHeapHashSet<RawPtrWillBeWeakMember<Node> > WeakNodeSet;
+using WeakNodeSet = WillBeHeapHashSet<RawPtrWillBeWeakMember<Node>>;
 static WeakNodeSet& liveNodeSet()
 {
     DEFINE_STATIC_LOCAL(OwnPtrWillBePersistent<WeakNodeSet>, set, (adoptPtrWillBeNoop(new WeakNodeSet())));
     return *set;
 }
 #endif
 
 void Node::dumpStatistics()
 {
 #if DUMP_NODE_STATISTICS
@@ skipping 10 matching lines @@
     size_t fragmentNodes = 0;
     size_t shadowRootNodes = 0;
 
     HashMap<String, size_t> perTagCount;
 
     size_t attributes = 0;
     size_t elementsWithAttributeStorage = 0;
     size_t elementsWithRareData = 0;
     size_t elementsWithNamedNodeMap = 0;
 
-    for (WeakNodeSet::iterator it = liveNodeSet().begin(); it != liveNodeSet().end(); ++it) {
-        Node* node = *it;
-
+    for (Node* node : liveNodeSet()) {
         if (node->hasRareData()) {
             ++nodesWithRareData;
             if (node->isElementNode()) {
                 ++elementsWithRareData;
                 if (toElement(node)->hasNamedNodeMap())
                     ++elementsWithNamedNodeMap;
             }
         }
 
         switch (node->nodeType()) {
@@ skipping 59 matching lines @@
     printf("  Number of Text nodes: %zu\n", textNodes);
     printf("  Number of CDATASection nodes: %zu\n", cdataNodes);
     printf("  Number of Comment nodes: %zu\n", commentNodes);
     printf("  Number of ProcessingInstruction nodes: %zu\n", piNodes);
     printf("  Number of Document nodes: %zu\n", documentNodes);
     printf("  Number of DocumentType nodes: %zu\n", docTypeNodes);
     printf("  Number of DocumentFragment nodes: %zu\n", fragmentNodes);
     printf("  Number of ShadowRoot nodes: %zu\n", shadowRootNodes);
 
     printf("Element tag name distibution:\n");
-    for (HashMap<String, size_t>::iterator it = perTagCount.begin(); it != perTagCount.end(); ++it)
-        printf("  Number of <%s> tags: %zu\n", it->key.utf8().data(), it->value);
+    for (const auto& entry : perTagCount)
+        printf("  Number of <%s> tags: %zu\n", entry.key.utf8().data(), entry.value);
 
     printf("Attributes:\n");
     printf("  Number of Attributes (non-Node and Node): %zu [%zu]\n", attributes, sizeof(Attribute));
     printf("  Number of Elements with attribute storage: %zu [%zu]\n", elementsWithAttributeStorage, sizeof(ElementData));
     printf("  Number of Elements with RareData: %zu\n", elementsWithRareData);
     printf("  Number of Elements with NamedNodeMap: %zu [%zu]\n", elementsWithNamedNodeMap, sizeof(NamedNodeMap));
 #endif
 }
 
 DEFINE_DEBUG_ONLY_GLOBAL(WTF::RefCountedLeakCounter, nodeCounter, ("WebCoreNode"));
@@ skipping 41 matching lines @@
 
     if (hasRareData())
         clearRareData();
 
     RELEASE_ASSERT(!renderer());
 
     if (!isContainerNode())
         willBeDeletedFromDocument();
 
     if (m_previous)
-        m_previous->setNextSibling(0);
+        m_previous->setNextSibling(nullptr);
     if (m_next)
-        m_next->setPreviousSibling(0);
+        m_next->setPreviousSibling(nullptr);
 
     if (m_treeScope)
         m_treeScope->guardDeref();
 
     if (getFlag(HasWeakReferencesFlag))
         WeakNodeMap::notifyNodeDestroyed(this);
 #else
     // With Oilpan, the rare data finalizer also asserts for
     // this condition (we cannot directly access it here.)
     RELEASE_ASSERT(hasRareData() || !renderer());
@@ skipping 278 matching lines @@
 
     if (AXObjectCache* cache = document().existingAXObjectCache())
         return cache->rootAXEditableElement(this);
 
     return false;
 }
 
 RenderBox* Node::renderBox() const
 {
     RenderObject* renderer = this->renderer();
-    return renderer && renderer->isBox() ? toRenderBox(renderer) : 0;
+    return renderer && renderer->isBox() ? toRenderBox(renderer) : nullptr;
 }
 
 RenderBoxModelObject* Node::renderBoxModelObject() const
 {
     RenderObject* renderer = this->renderer();
-    return renderer && renderer->isBoxModelObject() ? toRenderBoxModelObject(renderer) : 0;
+    return renderer && renderer->isBoxModelObject() ? toRenderBoxModelObject(renderer) : nullptr;
 }
 
 LayoutRect Node::boundingBox() const
 {
     if (renderer())
         return renderer()->absoluteBoundingBoxRect();
     return LayoutRect();
 }
 
 bool Node::hasNonEmptyBoundingBox() const
@@ skipping 14 matching lines @@
         if (!rects[i].isEmpty())
             return true;
 
     return false;
 }
 
 #ifndef NDEBUG
 inline static ShadowRoot* oldestShadowRootFor(const Node* node)
 {
     if (!node->isElementNode())
-        return 0;
+        return nullptr;
     if (ElementShadow* shadow = toElement(node)->shadow())
         return shadow->oldestShadowRoot();
-    return 0;
+    return nullptr;
 }
 #endif
 
 void Node::recalcDistribution()
 {
     if (isElementNode()) {
         if (ElementShadow* shadow = toElement(this)->shadow())
             shadow->distributeIfNeeded();
     }
 
@@ skipping 100 matching lines @@
 {
     const HTMLDialogElement* dialog = document().activeModalDialog();
     if (dialog && this != document() && !NodeRenderingTraversal::contains(dialog, this))
         return true;
     return document().ownerElement() && document().ownerElement()->isInert();
 }
 
 unsigned Node::nodeIndex() const
 {
     Node *_tempNode = previousSibling();
-    unsigned count=0;
-    for ( count=0; _tempNode; count++ )
+    unsigned count = 0;
+    for (count = 0; _tempNode; count++)
         _tempNode = _tempNode->previousSibling();
     return count;
 }
 
 NodeListsNodeData* Node::nodeLists()
 {
-    return hasRareData() ? rareData()->nodeLists() : 0;
+    return hasRareData() ? rareData()->nodeLists() : nullptr;
 }
 
 void Node::clearNodeLists()
 {
     rareData()->clearNodeLists();
 }
 
 bool Node::isDescendantOf(const Node *other) const
 {
     // Return true if other is an ancestor of this, otherwise false
@@ skipping 56 matching lines @@
             current = current->parentOrShadowHostNode();
     } while (current);
     return false;
 }
 
 Node* Node::commonAncestor(const Node& other, Node* (*parent)(const Node&))
 {
     if (this == other)
         return this;
     if (document() != other.document())
-        return 0;
+        return nullptr;
     int thisDepth = 0;
     for (Node* node = this; node; node = parent(*node)) {
         if (node == &other)
             return node;
         thisDepth++;
     }
     int otherDepth = 0;
     for (const Node* node = &other; node; node = parent(*node)) {
         if (node == this)
             return this;
         otherDepth++;
     }
     Node* thisIterator = this;
     const Node* otherIterator = &other;
     if (thisDepth > otherDepth) {
         for (int i = thisDepth; i > otherDepth; --i)
             thisIterator = parent(*thisIterator);
     } else if (otherDepth > thisDepth) {
         for (int i = otherDepth; i > thisDepth; --i)
             otherIterator = parent(*otherIterator);
     }
     while (thisIterator) {
         if (thisIterator == otherIterator)
             return thisIterator;
         thisIterator = parent(*thisIterator);
         otherIterator = parent(*otherIterator);
     }
     ASSERT(!otherIterator);
-    return 0;
+    return nullptr;
 }
 
 void Node::reattach(const AttachContext& context)
 {
     AttachContext reattachContext(context);
     reattachContext.performingReattach = true;
 
     // We only need to detach if the node has already been through attach().
     if (styleChangeType() < NeedsReattachStyleChange)
         detach(reattachContext);
@@ skipping 26 matching lines @@
     ASSERT(document().lifecycle().stateAllowsDetach());
     DocumentLifecycle::DetachScope willDetach(document().lifecycle());
 
 #if ENABLE(ASSERT)
     ASSERT(!detachingNode);
     detachingNode = this;
 #endif
 
     if (renderer())
         renderer()->destroyAndCleanupAnonymousWrappers();
-    setRenderer(0);
+    setRenderer(nullptr);
 
     // Do not remove the element's hovered and active status
     // if performing a reattach.
     if (!context.performingReattach) {
         Document& doc = document();
         if (isUserActionElement()) {
             if (hovered())
                 doc.hoveredNodeDetached(this);
             if (inActiveChain())
                 doc.activeChainNodeDetached(this);
             doc.userActionElements().didDetach(this);
         }
     }
 
     setStyleChange(NeedsReattachStyleChange);
     setChildNeedsStyleRecalc();
 
     if (StyleResolver* resolver = document().styleResolver())
         resolver->ruleFeatureSet().styleInvalidator().clearInvalidation(*this);
     clearChildNeedsStyleInvalidation();
     clearNeedsStyleInvalidation();
 
 #if ENABLE(ASSERT)
-    detachingNode = 0;
+    detachingNode = nullptr;
 #endif
 }
 
 void Node::reattachWhitespaceSiblings(Text* start)
 {
     for (Node* sibling = start; sibling; sibling = sibling->nextSibling()) {
         if (sibling->isTextNode() && toText(sibling)->containsOnlyWhitespace()) {
             bool hadRenderer = !!sibling->renderer();
             sibling->reattach();
             // If the reattach didn't toggle the visibility of the whitespace we don't
             // need to continue reattaching siblings since they won't toggle visibility
             // either.
             if (hadRenderer == !!sibling->renderer())
                 return;
         } else if (sibling->renderer()) {
             return;
         }
     }
 }
 
 // FIXME: This code is used by editing.  Seems like it could move over there and not pollute Node.
-Node *Node::previousNodeConsideringAtomicNodes() const
+Node* Node::previousNodeConsideringAtomicNodes() const
 {
     if (previousSibling()) {
-        Node *n = previousSibling();
+        Node* n = previousSibling();
         while (!isAtomicNode(n) && n->lastChild())
             n = n->lastChild();
         return n;
     }
     else if (parentNode()) {
         return parentNode();
     }
     else {
-        return 0;
+        return nullptr;
     }
 }
 
-Node *Node::nextNodeConsideringAtomicNodes() const
+Node* Node::nextNodeConsideringAtomicNodes() const
 {
     if (!isAtomicNode(this) && hasChildren())
         return firstChild();
     if (nextSibling())
         return nextSibling();
-    const Node *n = this;
+    const Node* n = this;
     while (n && !n->nextSibling())
         n = n->parentNode();
     if (n)
         return n->nextSibling();
-    return 0;
+    return nullptr;
 }
 
-Node *Node::previousLeafNode() const
+Node* Node::previousLeafNode() const
 {
-    Node *node = previousNodeConsideringAtomicNodes();
+    Node* node = previousNodeConsideringAtomicNodes();
     while (node) {
         if (isAtomicNode(node))
             return node;
         node = node->previousNodeConsideringAtomicNodes();
     }
-    return 0;
+    return nullptr;
 }
 
-Node *Node::nextLeafNode() const
+Node* Node::nextLeafNode() const
 {
-    Node *node = nextNodeConsideringAtomicNodes();
+    Node* node = nextNodeConsideringAtomicNodes();
     while (node) {
         if (isAtomicNode(node))
             return node;
         node = node->nextNodeConsideringAtomicNodes();
     }
-    return 0;
+    return nullptr;
 }
 
 RenderStyle* Node::virtualComputedStyle(PseudoId pseudoElementSpecifier)
 {
-    return parentOrShadowHostNode() ? parentOrShadowHostNode()->computedStyle(pseudoElementSpecifier) : 0;
+    return parentOrShadowHostNode() ? parentOrShadowHostNode()->computedStyle(pseudoElementSpecifier) : nullptr;
 }
 
 int Node::maxCharacterOffset() const
 {
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 // FIXME: Shouldn't these functions be in the editing code?  Code that asks questions about HTML in the core DOM class
 // is obviously misplaced.
 bool Node::canStartSelection() const
 {
     if (hasEditableStyle())
         return true;
 
     if (renderer()) {
         RenderStyle* style = renderer()->style();
         // We allow selections to begin within an element that has -webkit-user-select: none set,
         // but if the element is draggable then dragging should take priority over selection.
         if (style->userDrag() == DRAG_ELEMENT && style->userSelect() == SELECT_NONE)
             return false;
     }
     return parentOrShadowHostNode() ? parentOrShadowHostNode()->canStartSelection() : true;
 }
 
 Element* Node::shadowHost() const
 {
     if (ShadowRoot* root = containingShadowRoot())
         return root->host();
-    return 0;
+    return nullptr;
 }
 
 ShadowRoot* Node::containingShadowRoot() const
 {
     Node& root = treeScope().rootNode();
-    return root.isShadowRoot() ? toShadowRoot(&root) : 0;
+    return root.isShadowRoot() ? toShadowRoot(&root) : nullptr;
 }
 
 Node* Node::nonBoundaryShadowTreeRootNode()
 {
     ASSERT(!isShadowRoot());
     Node* root = this;
     while (root) {
         if (root->isShadowRoot())
             return root;
         Node* parent = root->parentOrShadowHostNode();
         if (parent && parent->isShadowRoot())
             return root;
         root = parent;
     }
-    return 0;
+    return nullptr;
 }
 
 ContainerNode* Node::nonShadowBoundaryParentNode() const
 {
     ContainerNode* parent = parentNode();
-    return parent && !parent->isShadowRoot() ? parent : 0;
+    return parent && !parent->isShadowRoot() ? parent : nullptr;
 }
 
 Element* Node::parentOrShadowHostElement() const
 {
     ContainerNode* parent = parentOrShadowHostNode();
     if (!parent)
-        return 0;
+        return nullptr;
 
     if (parent->isShadowRoot())
         return toShadowRoot(parent)->host();
 
     if (!parent->isElementNode())
-        return 0;
+        return nullptr;
 
     return toElement(parent);
 }
 
 ContainerNode* Node::parentOrShadowHostOrTemplateHostNode() const
 {
     if (isDocumentFragment() && toDocumentFragment(this)->isTemplateContent())
         return static_cast<const TemplateContentDocumentFragment*>(this)->host();
     return parentOrShadowHostNode();
 }
 
 bool Node::isRootEditableElement() const
 {
     return hasEditableStyle() && isElementNode() && (!parentNode() || !parentNode()->hasEditableStyle()
         || !parentNode()->isElementNode() || isHTMLBodyElement((*this)));
 }
 
 Element* Node::rootEditableElement(EditableType editableType) const
 {
     if (editableType == HasEditableAXRole) {
         if (AXObjectCache* cache = document().existingAXObjectCache())
             return const_cast<Element*>(cache->rootAXEditableElement(this));
     }
 
     return rootEditableElement();
 }
 
 Element* Node::rootEditableElement() const
 {
-    Element* result = 0;
+    Element* result = nullptr;
     for (Node* n = const_cast<Node*>(this); n && n->hasEditableStyle(); n = n->parentNode()) {
         if (n->isElementNode())
             result = toElement(n);
         if (isHTMLBodyElement(*n))
             break;
     }
     return result;
 }
 
 // FIXME: End of obviously misplaced HTML editing functions.  Try to move these out of Node.
 
 Document* Node::ownerDocument() const
 {
     Document* doc = &document();
-    return doc == this ? 0 : doc;
+    return doc == this ? nullptr : doc;
 }
 
 KURL Node::baseURI() const
 {
     return parentNode() ? parentNode()->baseURI() : KURL();
 }
 
 bool Node::isEqualNode(Node* other) const
 {
     if (!other)
@@ skipping 51 matching lines @@
     const AtomicString& namespaceURI = namespaceURIMaybeEmpty.isEmpty() ? nullAtom : namespaceURIMaybeEmpty;
 
     switch (nodeType()) {
         case ELEMENT_NODE: {
             const Element& element = toElement(*this);
 
             if (element.prefix().isNull())
                 return element.namespaceURI() == namespaceURI;
 
             AttributeCollection attributes = element.attributes();
-            AttributeCollection::iterator end = attributes.end();
-            for (AttributeCollection::iterator it = attributes.begin(); it != end; ++it) {
-                if (it->localName() == xmlnsAtom)
-                    return it->value() == namespaceURI;
+            for (const Attribute& attr : attributes) {
+                if (attr.localName() == xmlnsAtom)
+                    return attr.value() == namespaceURI;
             }
 
             if (Element* parent = parentElement())
                 return parent->isDefaultNamespace(namespaceURI);
 
             return false;
         }
         case DOCUMENT_NODE:
             if (Element* de = toDocument(this)->documentElement())
                 return de->isDefaultNamespace(namespaceURI);
@@ skipping 26 matching lines @@
 
     switch (nodeType()) {
         case ELEMENT_NODE:
             context = toElement(this);
             break;
         case DOCUMENT_NODE:
             context = toDocument(this)->documentElement();
             break;
         case DOCUMENT_FRAGMENT_NODE:
         case DOCUMENT_TYPE_NODE:
-            context = 0;
+            context = nullptr;
             break;
         // FIXME: Remove this when Attr no longer extends Node (CR305105)
         case ATTRIBUTE_NODE:
             context = toAttr(this)->ownerElement();
             break;
         default:
             context = parentElement();
             break;
     }
 
@@ skipping 12 matching lines @@
         return nullAtom;
 
     switch (nodeType()) {
         case ELEMENT_NODE: {
             const Element& element = toElement(*this);
 
             if (!element.namespaceURI().isNull() && element.prefix() == prefix)
                 return element.namespaceURI();
 
             AttributeCollection attributes = element.attributes();
-            AttributeCollection::iterator end = attributes.end();
-            for (AttributeCollection::iterator it = attributes.begin(); it != end; ++it) {
-                if (it->prefix() == xmlnsAtom && it->localName() == prefix) {
-                    if (!it->value().isEmpty())
-                        return it->value();
+            for (const Attribute& attr : attributes) {
+                if (attr.prefix() == xmlnsAtom && attr.localName() == prefix) {
+                    if (!attr.value().isEmpty())
+                        return attr.value();
                     return nullAtom;
                 }
-                if (it->localName() == xmlnsAtom && prefix.isNull()) {
-                    if (!it->value().isEmpty())
-                        return it->value();
+                if (attr.localName() == xmlnsAtom && prefix.isNull()) {
+                    if (!attr.value().isEmpty())
+                        return attr.value();
                     return nullAtom;
                 }
             }
 
             if (Element* parent = parentElement())
                 return parent->lookupNamespaceURI(prefix);
             return nullAtom;
         }
         case DOCUMENT_NODE:
             if (Element* de = toDocument(this)->documentElement())
@@ skipping 100 matching lines @@
     ASSERT_NOT_REACHED();
 }
 
 bool Node::offsetInCharacters() const
 {
     return false;
 }
 
 unsigned short Node::compareDocumentPosition(const Node* otherNode, ShadowTreesTreatment treatment) const
 {
-    // It is not clear what should be done if |otherNode| is 0.
+    // It is not clear what should be done if |otherNode| is nullptr.
     if (!otherNode)
         return DOCUMENT_POSITION_DISCONNECTED;
 
     if (otherNode == this)
         return DOCUMENT_POSITION_EQUIVALENT;
 
-    const Attr* attr1 = nodeType() == ATTRIBUTE_NODE ? toAttr(this) : 0;
-    const Attr* attr2 = otherNode->nodeType() == ATTRIBUTE_NODE ? toAttr(otherNode) : 0;
+    const Attr* attr1 = nodeType() == ATTRIBUTE_NODE ? toAttr(this) : nullptr;
+    const Attr* attr2 = otherNode->nodeType() == ATTRIBUTE_NODE ? toAttr(otherNode) : nullptr;
 
     const Node* start1 = attr1 ? attr1->ownerElement() : this;
     const Node* start2 = attr2 ? attr2->ownerElement() : otherNode;
 
     // If either of start1 or start2 is null, then we are disconnected, since one of the nodes is
     // an orphaned attribute node.
     if (!start1 || !start2) {
         unsigned short direction = (this > otherNode) ? DOCUMENT_POSITION_PRECEDING : DOCUMENT_POSITION_FOLLOWING;
         return DOCUMENT_POSITION_DISCONNECTED | DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | direction;
     }
 
     Vector<const Node*, 16> chain1;
     Vector<const Node*, 16> chain2;
     if (attr1)
         chain1.append(attr1);
     if (attr2)
         chain2.append(attr2);
 
     if (attr1 && attr2 && start1 == start2 && start1) {
         // We are comparing two attributes on the same node. Crawl our attribute map and see which one we hit first.
         const Element* owner1 = attr1->ownerElement();
         AttributeCollection attributes = owner1->attributes();
-        AttributeCollection::iterator end = attributes.end();
-        for (AttributeCollection::iterator it = attributes.begin(); it != end; ++it) {
+        for (const Attribute& attr : attributes) {
             // If neither of the two determining nodes is a child node and nodeType is the same for both determining nodes, then an
             // implementation-dependent order between the determining nodes is returned. This order is stable as long as no nodes of
             // the same nodeType are inserted into or removed from the direct container. This would be the case, for example,
             // when comparing two attributes of the same element, and inserting or removing additional attributes might change
             // the order between existing attributes.
-            if (attr1->qualifiedName() == it->name())
+            if (attr1->qualifiedName() == attr.name())
                 return DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | DOCUMENT_POSITION_FOLLOWING;
-            if (attr2->qualifiedName() == it->name())
+            if (attr2->qualifiedName() == attr.name())
                 return DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | DOCUMENT_POSITION_PRECEDING;
         }
 
         ASSERT_NOT_REACHED();
         return DOCUMENT_POSITION_DISCONNECTED;
     }
 
     // If one node is in the document and the other is not, we must be disconnected.
     // If the nodes have different owning documents, they must be disconnected.  Note that we avoid
     // comparing Attr nodes here, since they return false from inDocument() all the time (which seems like a bug).
@@ skipping 290 matching lines @@
         // For imagemaps, the enclosing link node is the associated area element not the image itself.
         // So we don't let images be the enclosingLinkNode, even though isLink sometimes returns true
         // for them.
         if (node->isLink() && !isHTMLImageElement(*node)) {
             // Casting to Element is safe because only HTMLAnchorElement, HTMLImageElement and
             // SVGAElement can return true for isLink().
             return toElement(node);
         }
     }
 
-    return 0;
+    return nullptr;
 }
 
 const AtomicString& Node::interfaceName() const
 {
     return EventTargetNames::Node;
 }
 
 ExecutionContext* Node::executionContext() const
 {
     return document().contextDocument().get();
@@ skipping 20 matching lines @@
 
     oldDocument.markers().removeMarkers(this);
     oldDocument.updateRangesAfterNodeMovedToAnotherDocument(*this);
     if (oldDocument.frameHost() && !document().frameHost())
         oldDocument.frameHost()->eventHandlerRegistry().didMoveOutOfFrameHost(*this);
     else if (document().frameHost() && !oldDocument.frameHost())
         document().frameHost()->eventHandlerRegistry().didMoveIntoFrameHost(*this);
     else if (oldDocument.frameHost() != document().frameHost())
         EventHandlerRegistry::didMoveBetweenFrameHosts(*this, oldDocument.frameHost(), document().frameHost());
 
-    if (WillBeHeapVector<OwnPtrWillBeMember<MutationObserverRegistration> >* registry = mutationObserverRegistry()) {
+    if (WillBeHeapVector<OwnPtrWillBeMember<MutationObserverRegistration>>* registry = mutationObserverRegistry()) {
         for (size_t i = 0; i < registry->size(); ++i) {
             document().addMutationObserverTypes(registry->at(i)->mutationTypes());
         }
     }
 
-    if (WillBeHeapHashSet<RawPtrWillBeMember<MutationObserverRegistration> >* transientRegistry = transientMutationObserverRegistry()) {
-        for (WillBeHeapHashSet<RawPtrWillBeMember<MutationObserverRegistration> >::iterator iter = transientRegistry->begin(); iter != transientRegistry->end(); ++iter) {
-            document().addMutationObserverTypes((*iter)->mutationTypes());
-        }
+    if (transientMutationObserverRegistry()) {
+        for (MutationObserverRegistration* registration : *transientMutationObserverRegistry())
+            document().addMutationObserverTypes(registration->mutationTypes());
     }
 }
 
 static inline bool tryAddEventListener(Node* targetNode, const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
 {
     if (!targetNode->EventTarget::addEventListener(eventType, listener, useCapture))
         return false;
 
     Document& document = targetNode->document();
     document.addListenerTypeIfNeeded(eventType);
@@ skipping 36 matching lines @@
 
 void Node::removeAllEventListenersRecursively()
 {
     for (Node& node : NodeTraversal::from(this)) {
         node.removeAllEventListeners();
         for (ShadowRoot* root = node.youngestShadowRoot(); root; root = root->olderShadowRoot())
             root->removeAllEventListenersRecursively();
     }
 }
 
-typedef WillBeHeapHashMap<RawPtrWillBeWeakMember<Node>, OwnPtr<EventTargetData> > EventTargetDataMap;
-
+using EventTargetDataMap = WillBeHeapHashMap<RawPtrWillBeWeakMember<Node>, OwnPtr<EventTargetData>>;
 static EventTargetDataMap& eventTargetDataMap()
 {
     DEFINE_STATIC_LOCAL(OwnPtrWillBePersistent<EventTargetDataMap>, map, (adoptPtrWillBeNoop(new EventTargetDataMap())));
     return *map;
 }
 
 EventTargetData* Node::eventTargetData()
 {
-    return hasEventTargetData() ? eventTargetDataMap().get(this) : 0;
+    return hasEventTargetData() ? eventTargetDataMap().get(this) : nullptr;
 }
 
 EventTargetData& Node::ensureEventTargetData()
 {
     if (hasEventTargetData())
         return *eventTargetDataMap().get(this);
     setHasEventTargetData(true);
     EventTargetData* data = new EventTargetData;
     eventTargetDataMap().set(this, adoptPtr(data));
     return *data;
 }
 
 #if !ENABLE(OILPAN)
 void Node::clearEventTargetData()
 {
     eventTargetDataMap().remove(this);
 }
 #endif
 
-WillBeHeapVector<OwnPtrWillBeMember<MutationObserverRegistration> >* Node::mutationObserverRegistry()
+WillBeHeapVector<OwnPtrWillBeMember<MutationObserverRegistration>>* Node::mutationObserverRegistry()
 {
     if (!hasRareData())
-        return 0;
+        return nullptr;
     NodeMutationObserverData* data = rareData()->mutationObserverData();
     if (!data)
-        return 0;
+        return nullptr;
     return &data->registry;
 }
 
-WillBeHeapHashSet<RawPtrWillBeMember<MutationObserverRegistration> >* Node::transientMutationObserverRegistry()
+WillBeHeapHashSet<RawPtrWillBeMember<MutationObserverRegistration>>* Node::transientMutationObserverRegistry()
 {
     if (!hasRareData())
-        return 0;
+        return nullptr;
     NodeMutationObserverData* data = rareData()->mutationObserverData();
     if (!data)
-        return 0;
+        return nullptr;
     return &data->transientRegistry;
 }
 
 template<typename Registry>
 static inline void collectMatchingObserversForMutation(WillBeHeapHashMap<RawPtrWillBeMember<MutationObserver>, MutationRecordDeliveryOptions>& observers, Registry* registry, Node& target, MutationObserver::MutationType type, const QualifiedName* attributeName)
 {
     if (!registry)
         return;
-    for (typename Registry::iterator iter = registry->begin(); iter != registry->end(); ++iter) {
-        const MutationObserverRegistration& registration = **iter;
-        if (registration.shouldReceiveMutationFrom(target, type, attributeName)) {
-            MutationRecordDeliveryOptions deliveryOptions = registration.deliveryOptions();
-            WillBeHeapHashMap<RawPtrWillBeMember<MutationObserver>, MutationRecordDeliveryOptions>::AddResult result = observers.add(&registration.observer(), deliveryOptions);
+
+    for (const auto& registration : *registry) {
+        if (registration->shouldReceiveMutationFrom(target, type, attributeName)) {
+            MutationRecordDeliveryOptions deliveryOptions = registration->deliveryOptions();
+            WillBeHeapHashMap<RawPtrWillBeMember<MutationObserver>, MutationRecordDeliveryOptions>::AddResult result = observers.add(&registration->observer(), deliveryOptions);
             if (!result.isNewEntry)
                 result.storedValue->value |= deliveryOptions;
         }
     }
 }
 
 void Node::getRegisteredMutationObserversOfType(WillBeHeapHashMap<RawPtrWillBeMember<MutationObserver>, MutationRecordDeliveryOptions>& observers, MutationObserver::MutationType type, const QualifiedName* attributeName)
 {
     ASSERT((type == MutationObserver::Attributes && attributeName) || !attributeName);
     collectMatchingObserversForMutation(observers, mutationObserverRegistry(), *this, type, attributeName);
     collectMatchingObserversForMutation(observers, transientMutationObserverRegistry(), *this, type, attributeName);
     for (Node* node = parentNode(); node; node = node->parentNode()) {
         collectMatchingObserversForMutation(observers, node->mutationObserverRegistry(), *this, type, attributeName);
         collectMatchingObserversForMutation(observers, node->transientMutationObserverRegistry(), *this, type, attributeName);
     }
 }
 
 void Node::registerMutationObserver(MutationObserver& observer, MutationObserverOptions options, const HashSet<AtomicString>& attributeFilter)
 {
-    MutationObserverRegistration* registration = 0;
-    WillBeHeapVector<OwnPtrWillBeMember<MutationObserverRegistration> >& registry = ensureRareData().ensureMutationObserverData().registry;
+    MutationObserverRegistration* registration = nullptr;
+    WillBeHeapVector<OwnPtrWillBeMember<MutationObserverRegistration>>& registry = ensureRareData().ensureMutationObserverData().registry;
     for (size_t i = 0; i < registry.size(); ++i) {
         if (&registry[i]->observer() == &observer) {
             registration = registry[i].get();
             registration->resetObservation(options, attributeFilter);
         }
     }
 
     if (!registration) {
         registry.append(MutationObserverRegistration::create(observer, this, options, attributeFilter));
         registration = registry.last().get();
     }
 
     document().addMutationObserverTypes(registration->mutationTypes());
 }
 
 void Node::unregisterMutationObserver(MutationObserverRegistration* registration)
 {
-    WillBeHeapVector<OwnPtrWillBeMember<MutationObserverRegistration> >* registry = mutationObserverRegistry();
+    WillBeHeapVector<OwnPtrWillBeMember<MutationObserverRegistration>>* registry = mutationObserverRegistry();
     ASSERT(registry);
     if (!registry)
         return;
 
     size_t index = registry->find(registration);
     ASSERT(index != kNotFound);
     if (index == kNotFound)
         return;
 
     // Deleting the registration may cause this node to be derefed, so we must make sure the Vector operation completes
     // before that, in case |this| is destroyed (see MutationObserverRegistration::m_registrationNodeKeepAlive).
     // FIXME: Simplify the registration/transient registration logic to make this understandable by humans.
     RefPtrWillBeRawPtr<Node> protect(this);
 #if ENABLE(OILPAN)
     // The explicit dispose() is needed to have the registration
     // object unregister itself promptly.
     registration->dispose();
 #endif
     registry->remove(index);
 }
 
 void Node::registerTransientMutationObserver(MutationObserverRegistration* registration)
 {
     ensureRareData().ensureMutationObserverData().transientRegistry.add(registration);
 }
 
 void Node::unregisterTransientMutationObserver(MutationObserverRegistration* registration)
 {
-    WillBeHeapHashSet<RawPtrWillBeMember<MutationObserverRegistration> >* transientRegistry = transientMutationObserverRegistry();
+    WillBeHeapHashSet<RawPtrWillBeMember<MutationObserverRegistration>>* transientRegistry = transientMutationObserverRegistry();
     ASSERT(transientRegistry);
     if (!transientRegistry)
         return;
 
     ASSERT(transientRegistry->contains(registration));
     transientRegistry->remove(registration);
 }
 
 void Node::notifyMutationObserversNodeWillDetach()
 {
     if (!document().hasMutationObservers())
         return;
 
     for (Node* node = parentNode(); node; node = node->parentNode()) {
-        if (WillBeHeapVector<OwnPtrWillBeMember<MutationObserverRegistration> >* registry = node->mutationObserverRegistry()) {
+        if (WillBeHeapVector<OwnPtrWillBeMember<MutationObserverRegistration>>* registry = node->mutationObserverRegistry()) {
             const size_t size = registry->size();
             for (size_t i = 0; i < size; ++i)
                 registry->at(i)->observedSubtreeNodeWillDetach(*this);
         }
 
-        if (WillBeHeapHashSet<RawPtrWillBeMember<MutationObserverRegistration> >* transientRegistry = node->transientMutationObserverRegistry()) {
-            for (WillBeHeapHashSet<RawPtrWillBeMember<MutationObserverRegistration> >::iterator iter = transientRegistry->begin(); iter != transientRegistry->end(); ++iter)
+        if (WillBeHeapHashSet<RawPtrWillBeMember<MutationObserverRegistration>>* transientRegistry = node->transientMutationObserverRegistry()) {
+            for (WillBeHeapHashSet<RawPtrWillBeMember<MutationObserverRegistration>>::iterator iter = transientRegistry->begin(); iter != transientRegistry->end(); ++iter)
                 (*iter)->observedSubtreeNodeWillDetach(*this);
         }
     }
 }
 
 void Node::handleLocalEvents(Event* event)
 {
     if (!hasEventTargetData())
         return;
 
@@ skipping 254 matching lines @@
 
     for (Node* node = parentOrShadowHostNode(); node; node = node->parentOrShadowHostNode())
         node->incrementConnectedSubframeCount(count);
 }
 
 PassRefPtrWillBeRawPtr<StaticNodeList> Node::getDestinationInsertionPoints()
 {
     document().updateDistributionForNodeIfNeeded(this);
     WillBeHeapVector<RawPtrWillBeMember<InsertionPoint>, 8> insertionPoints;
     collectDestinationInsertionPoints(*this, insertionPoints);
-    WillBeHeapVector<RefPtrWillBeMember<Node> > filteredInsertionPoints;
+    WillBeHeapVector<RefPtrWillBeMember<Node>> filteredInsertionPoints;
     for (size_t i = 0; i < insertionPoints.size(); ++i) {
         InsertionPoint* insertionPoint = insertionPoints[i];
         ASSERT(insertionPoint->containingShadowRoot());
         if (insertionPoint->containingShadowRoot()->type() != ShadowRoot::UserAgentShadowRoot)
             filteredInsertionPoints.append(insertionPoint);
     }
     return StaticNodeList::adopt(filteredInsertionPoints);
 }
 
 void Node::setFocus(bool flag)
@@ skipping 140 matching lines @@
         node->showTreeForThis();
 }
 
 void showNodePath(const blink::Node* node)
 {
     if (node)
         node->showNodePathForThis();
 }
 
 #endif