A whole lotta nits in core/dom/Node.cpp

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 11 matching lines @@
  * Boston, MA 02110-1301, USA.
  */
 
 #include "config.h"
 #include "core/dom/Node.h"
 
 #include "bindings/core/v8/DOMDataStore.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/V8DOMWrapper.h"
 #include "core/HTMLNames.h"
-#include "core/XMLNames.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/AXObjectCache.h"
 #include "core/dom/Attr.h"
 #include "core/dom/Attribute.h"
 #include "core/dom/ChildListMutationScope.h"
 #include "core/dom/ChildNodeList.h"
-#include "core/dom/DOMImplementation.h"
 #include "core/dom/DOMNodeIds.h"
 #include "core/dom/Document.h"
 #include "core/dom/DocumentFragment.h"
 #include "core/dom/DocumentMarkerController.h"
 #include "core/dom/DocumentType.h"
 #include "core/dom/Element.h"
 #include "core/dom/ElementRareData.h"
 #include "core/dom/ElementTraversal.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/LayoutTreeBuilderTraversal.h"
-#include "core/dom/LiveNodeList.h"
 #include "core/dom/NodeRareData.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/dom/ProcessingInstruction.h"
 #include "core/dom/Range.h"
 #include "core/dom/StaticNodeList.h"
 #include "core/dom/StyleEngine.h"
 #include "core/dom/TemplateContentDocumentFragment.h"
 #include "core/dom/Text.h"
 #include "core/dom/TreeScopeAdopter.h"
 #include "core/dom/UserActionElementSet.h"
 #include "core/dom/shadow/ComposedTreeTraversal.h"
 #include "core/dom/shadow/ElementShadow.h"
 #include "core/dom/shadow/InsertionPoint.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/editing/htmlediting.h"
-#include "core/editing/markup.h"
 #include "core/events/Event.h"
 #include "core/events/EventDispatchMediator.h"
 #include "core/events/EventDispatcher.h"
 #include "core/events/EventListener.h"
 #include "core/events/GestureEvent.h"
 #include "core/events/KeyboardEvent.h"
 #include "core/events/MouseEvent.h"
 #include "core/events/MutationEvent.h"
 #include "core/events/TextEvent.h"
 #include "core/events/TouchEvent.h"
 #include "core/events/UIEvent.h"
 #include "core/events/WheelEvent.h"
 #include "core/frame/EventHandlerRegistry.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
-#include "core/html/HTMLAnchorElement.h"
 #include "core/html/HTMLDialogElement.h"
 #include "core/html/HTMLFrameOwnerElement.h"
-#include "core/html/HTMLStyleElement.h"
 #include "core/input/EventHandler.h"
 #include "core/layout/LayoutBox.h"
 #include "core/page/ContextMenuController.h"
 #include "core/page/Page.h"
 #include "core/svg/graphics/SVGImage.h"
 #include "platform/EventDispatchForbiddenScope.h"
 #include "platform/TraceEvent.h"
 #include "platform/TracedValue.h"
 #include "wtf/HashSet.h"
 #include "wtf/Partitions.h"
@@ skipping 64 matching lines @@
         if (node->hasRareData()) {
             ++nodesWithRareData;
             if (node->isElementNode()) {
                 ++elementsWithRareData;
                 if (toElement(node)->hasNamedNodeMap())
                     ++elementsWithNamedNodeMap;
             }
         }
 
         switch (node->nodeType()) {
-            case ELEMENT_NODE: {
-                ++elementNodes;
+        case ELEMENT_NODE: {
+            ++elementNodes;
 
-                // Tag stats
-                Element* element = toElement(node);
-                HashMap<String, size_t>::AddResult result = perTagCount.add(element->tagName(), 1);
-                if (!result.isNewEntry)
-                    result.storedValue->value++;
+            // Tag stats
+            Element* element = toElement(node);
+            HashMap<String, size_t>::AddResult result = perTagCount.add(element->tagName(), 1);
+            if (!result.isNewEntry)
+                result.storedValue->value++;
 
-                if (const ElementData* elementData = element->elementData()) {
-                    attributes += elementData->attributes().size();
-                    ++elementsWithAttributeStorage;
-                }
-                break;
+            if (const ElementData* elementData = element->elementData()) {
+                attributes += elementData->attributes().size();
+                ++elementsWithAttributeStorage;
             }
-            case ATTRIBUTE_NODE: {
-                ++attrNodes;
-                break;
-            }
-            case TEXT_NODE: {
-                ++textNodes;
-                break;
-            }
-            case CDATA_SECTION_NODE: {
-                ++cdataNodes;
-                break;
-            }
-            case COMMENT_NODE: {
-                ++commentNodes;
-                break;
-            }
-            case PROCESSING_INSTRUCTION_NODE: {
-                ++piNodes;
-                break;
-            }
-            case DOCUMENT_NODE: {
-                ++documentNodes;
-                break;
-            }
-            case DOCUMENT_TYPE_NODE: {
-                ++docTypeNodes;
-                break;
-            }
-            case DOCUMENT_FRAGMENT_NODE: {
-                if (node->isShadowRoot())
-                    ++shadowRootNodes;
-                else
-                    ++fragmentNodes;
-                break;
-            }
+            break;
+        }
+        case ATTRIBUTE_NODE: {
+            ++attrNodes;
+            break;
+        }
+        case TEXT_NODE: {
+            ++textNodes;
+            break;
+        }
+        case CDATA_SECTION_NODE: {
+            ++cdataNodes;
+            break;
+        }
+        case COMMENT_NODE: {
+            ++commentNodes;
+            break;
+        }
+        case PROCESSING_INSTRUCTION_NODE: {
+            ++piNodes;
+            break;
+        }
+        case DOCUMENT_NODE: {
+            ++documentNodes;
+            break;
+        }
+        case DOCUMENT_TYPE_NODE: {
+            ++docTypeNodes;
+            break;
+        }
+        case DOCUMENT_FRAGMENT_NODE: {
+            if (node->isShadowRoot())
+                ++shadowRootNodes;
+            else
+                ++fragmentNodes;
+            break;
+        }
         }
     }
 
     printf("Number of Nodes: %d\n\n", liveNodeSet().size());
     printf("Number of Nodes with RareData: %zu\n\n", nodesWithRareData);
 
     printf("NodeType distribution:\n");
     printf("  Number of Element nodes: %zu\n", elementNodes);
     printf("  Number of Attribute nodes: %zu\n", attrNodes);
     printf("  Number of Text nodes: %zu\n", textNodes);
@@ skipping 392 matching lines @@
     LayoutBoxModelObject* box = layoutBoxModelObject();
     if (!box)
         return false;
     if (!box->borderBoundingBox().isEmpty())
         return true;
 
     Vector<IntRect> rects;
     FloatPoint absPos = layoutObject()->localToAbsolute();
     layoutObject()->absoluteRects(rects, flooredLayoutPoint(absPos));
     size_t n = rects.size();
-    for (size_t i = 0; i < n; ++i)
-        if (!rects[i].isEmpty())
+    for (size_t i = 0; i < n; ++i) {
+        if (!rects[i].isEmpty()) {
             return true;
+        }
+    }
 
     return false;
 }
 
 #ifndef NDEBUG
 inline static ShadowRoot* oldestShadowRootFor(const Node* node)
 {
     if (!node->isElementNode())
         return nullptr;
     if (ElementShadow* shadow = toElement(node)->shadow())
@@ skipping 140 matching lines @@
 bool Node::isInert() const
 {
     const HTMLDialogElement* dialog = document().activeModalDialog();
     if (dialog && this != document() && (!canParticipateInComposedTree() || !ComposedTreeTraversal::containsIncludingPseudoElement(*dialog, *this)))
         return true;
     return document().ownerElement() && document().ownerElement()->isInert();
 }
 
 unsigned Node::nodeIndex() const
 {
-    Node *_tempNode = previousSibling();
+    Node* tempNode = previousSibling();
     unsigned count = 0;
-    for (count = 0; _tempNode; count++)
-        _tempNode = _tempNode->previousSibling();
+    for (count = 0; tempNode; count++)
+        tempNode = tempNode->previousSibling();
     return count;
 }
 
 NodeListsNodeData* Node::nodeLists()
 {
     return hasRareData() ? rareData()->nodeLists() : nullptr;
 }
 
 void Node::clearNodeLists()
 {
@@ skipping 193 matching lines @@
 
 // FIXME: This code is used by editing.  Seems like it could move over there and not pollute Node.
 Node* Node::previousNodeConsideringAtomicNodes() const
 {
     if (previousSibling()) {
         Node* n = previousSibling();
         while (!isAtomicNode(n) && n->lastChild())
             n = n->lastChild();
         return n;
     }
-    else if (parentNode()) {
+    if (parentNode()) {
         return parentNode();
     }
-    else {
-        return nullptr;
-    }
+    return nullptr;
 }
 
 Node* Node::nextNodeConsideringAtomicNodes() const
 {
     if (!isAtomicNode(this) && hasChildren())
         return firstChild();
     if (nextSibling())
         return nextSibling();
     const Node* n = this;
     while (n && !n->nextSibling())
@@ skipping 205 matching lines @@
     }
 
     return true;
 }
 
 bool Node::isDefaultNamespace(const AtomicString& namespaceURIMaybeEmpty) const
 {
     const AtomicString& namespaceURI = namespaceURIMaybeEmpty.isEmpty() ? nullAtom : namespaceURIMaybeEmpty;
 
     switch (nodeType()) {
-        case ELEMENT_NODE: {
-            const Element& element = toElement(*this);
+    case ELEMENT_NODE: {
+        const Element& element = toElement(*this);
 
-            if (element.prefix().isNull())
-                return element.namespaceURI() == namespaceURI;
+        if (element.prefix().isNull())
+            return element.namespaceURI() == namespaceURI;
 
-            AttributeCollection attributes = element.attributes();
-            for (const Attribute& attr : attributes) {
-                if (attr.localName() == xmlnsAtom)
-                    return attr.value() == namespaceURI;
-            }
+        AttributeCollection attributes = element.attributes();
+        for (const Attribute& attr : attributes) {
+            if (attr.localName() == xmlnsAtom)
+                return attr.value() == namespaceURI;
+        }
 
-            if (Element* parent = parentElement())
-                return parent->isDefaultNamespace(namespaceURI);
+        if (Element* parent = parentElement())
+            return parent->isDefaultNamespace(namespaceURI);
 
-            return false;
-        }
-        case DOCUMENT_NODE:
-            if (Element* de = toDocument(this)->documentElement())
-                return de->isDefaultNamespace(namespaceURI);
-            return false;
-        case DOCUMENT_TYPE_NODE:
-        case DOCUMENT_FRAGMENT_NODE:
-            return false;
-        case ATTRIBUTE_NODE: {
-            const Attr* attr = toAttr(this);
-            if (attr->ownerElement())
-                return attr->ownerElement()->isDefaultNamespace(namespaceURI);
-            return false;
-        }
-        default:
-            if (Element* parent = parentElement())
-                return parent->isDefaultNamespace(namespaceURI);
-            return false;
+        return false;
+    }
+    case DOCUMENT_NODE:
+        if (Element* de = toDocument(this)->documentElement())
+            return de->isDefaultNamespace(namespaceURI);
+        return false;
+    case DOCUMENT_TYPE_NODE:
+    case DOCUMENT_FRAGMENT_NODE:
+        return false;
+    case ATTRIBUTE_NODE: {
+        const Attr* attr = toAttr(this);
+        if (attr->ownerElement())
+            return attr->ownerElement()->isDefaultNamespace(namespaceURI);
+        return false;
+    }
+    default:
+        if (Element* parent = parentElement())
+            return parent->isDefaultNamespace(namespaceURI);
+        return false;
     }
 }
 
 const AtomicString& Node::lookupPrefix(const AtomicString& namespaceURI) const
 {
     // Implemented according to
     // http://dom.spec.whatwg.org/#dom-node-lookupprefix
 
     if (namespaceURI.isEmpty() || namespaceURI.isNull())
         return nullAtom;
 
     const Element* context;
 
     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 = nullptr;
-            break;
-        // FIXME: Remove this when Attr no longer extends Node (CR305105)
-        case ATTRIBUTE_NODE:
-            context = toAttr(this)->ownerElement();
-            break;
-        default:
-            context = parentElement();
-            break;
+    case ELEMENT_NODE:
+        context = toElement(this);
+        break;
+    case DOCUMENT_NODE:
+        context = toDocument(this)->documentElement();
+        break;
+    case DOCUMENT_FRAGMENT_NODE:
+    case DOCUMENT_TYPE_NODE:
+        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;
     }
 
     if (!context)
         return nullAtom;
 
     return context->locateNamespacePrefix(namespaceURI);
 }
 
 const AtomicString& Node::lookupNamespaceURI(const String& prefix) const
 {
     // Implemented according to
     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#lookupNamespaceURIAlgo
 
     if (!prefix.isNull() && prefix.isEmpty())
         return nullAtom;
 
     switch (nodeType()) {
-        case ELEMENT_NODE: {
-            const Element& element = toElement(*this);
+    case ELEMENT_NODE: {
+        const Element& element = toElement(*this);
 
-            if (!element.namespaceURI().isNull() && element.prefix() == prefix)
-                return element.namespaceURI();
+        if (!element.namespaceURI().isNull() && element.prefix() == prefix)
+            return element.namespaceURI();
 
-            AttributeCollection attributes = element.attributes();
-            for (const Attribute& attr : attributes) {
-                if (attr.prefix() == xmlnsAtom && attr.localName() == prefix) {
-                    if (!attr.value().isEmpty())
-                        return attr.value();
-                    return nullAtom;
-                }
-                if (attr.localName() == xmlnsAtom && prefix.isNull()) {
-                    if (!attr.value().isEmpty())
-                        return attr.value();
-                    return nullAtom;
-                }
+        AttributeCollection attributes = element.attributes();
+        for (const Attribute& attr : attributes) {
+            if (attr.prefix() == xmlnsAtom && attr.localName() == prefix) {
+                if (!attr.value().isEmpty())
+                    return attr.value();
+                return nullAtom;
             }
+            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())
-                return de->lookupNamespaceURI(prefix);
-            return nullAtom;
-        case DOCUMENT_TYPE_NODE:
-        case DOCUMENT_FRAGMENT_NODE:
-            return nullAtom;
-        case ATTRIBUTE_NODE: {
-            const Attr *attr = toAttr(this);
-            if (attr->ownerElement())
-                return attr->ownerElement()->lookupNamespaceURI(prefix);
-            else
-                return nullAtom;
-        }
-        default:
-            if (Element* parent = parentElement())
-                return parent->lookupNamespaceURI(prefix);
-            return nullAtom;
+        if (Element* parent = parentElement())
+            return parent->lookupNamespaceURI(prefix);
+        return nullAtom;
+    }
+    case DOCUMENT_NODE:
+        if (Element* de = toDocument(this)->documentElement())
+            return de->lookupNamespaceURI(prefix);
+        return nullAtom;
+    case DOCUMENT_TYPE_NODE:
+    case DOCUMENT_FRAGMENT_NODE:
+        return nullAtom;
+    case ATTRIBUTE_NODE: {
+        const Attr *attr = toAttr(this);
+        if (attr->ownerElement())
+            return attr->ownerElement()->lookupNamespaceURI(prefix);
+        return nullAtom;
+    }
+    default:
+        if (Element* parent = parentElement())
+            return parent->lookupNamespaceURI(prefix);
+        return nullAtom;
     }
 }
 
 String Node::textContent(bool convertBRsToNewlines) const
 {
     // This covers ProcessingInstruction and Comment that should return their
     // value when .textContent is accessed on them, but should be ignored when
     // iterated over as a descendant of a ContainerNode.
     if (isCharacterDataNode())
         return toCharacterData(this)->data();
@@ skipping 10 matching lines @@
         } else if (node.isTextNode()) {
             content.append(toText(node).data());
         }
     }
     return content.toString();
 }
 
 void Node::setTextContent(const String& text)
 {
     switch (nodeType()) {
-        case TEXT_NODE:
-        case CDATA_SECTION_NODE:
-        case COMMENT_NODE:
-        case PROCESSING_INSTRUCTION_NODE:
-            setNodeValue(text);
+    case TEXT_NODE:
+    case CDATA_SECTION_NODE:
+    case COMMENT_NODE:
+    case PROCESSING_INSTRUCTION_NODE:
+        setNodeValue(text);
+        return;
+    case ELEMENT_NODE:
+    case DOCUMENT_FRAGMENT_NODE: {
+        // FIXME: Merge this logic into replaceChildrenWithText.
+        RefPtrWillBeRawPtr<ContainerNode> container = toContainerNode(this);
+
+        // Note: This is an intentional optimization.
+        // See crbug.com/352836 also.
+        // No need to do anything if the text is identical.
+        if (container->hasOneTextChild() && toText(container->firstChild())->data() == text)
             return;
-        case ELEMENT_NODE:
-        case DOCUMENT_FRAGMENT_NODE: {
-            // FIXME: Merge this logic into replaceChildrenWithText.
-            RefPtrWillBeRawPtr<ContainerNode> container = toContainerNode(this);
 
-            // Note: This is an intentional optimization.
-            // See crbug.com/352836 also.
-            // No need to do anything if the text is identical.
-            if (container->hasOneTextChild() && toText(container->firstChild())->data() == text)
-                return;
-
-            ChildListMutationScope mutation(*this);
-            // Note: This API will not insert empty text nodes:
-            // http://dom.spec.whatwg.org/#dom-node-textcontent
-            if (text.isEmpty()) {
-                container->removeChildren(DispatchSubtreeModifiedEvent);
-            } else {
-                container->removeChildren(OmitSubtreeModifiedEvent);
-                container->appendChild(document().createTextNode(text), ASSERT_NO_EXCEPTION);
-            }
-            return;
+        ChildListMutationScope mutation(*this);
+        // Note: This API will not insert empty text nodes:
+        // http://dom.spec.whatwg.org/#dom-node-textcontent
+        if (text.isEmpty()) {
+            container->removeChildren(DispatchSubtreeModifiedEvent);
+        } else {
+            container->removeChildren(OmitSubtreeModifiedEvent);
+            container->appendChild(document().createTextNode(text), ASSERT_NO_EXCEPTION);
         }
-        case ATTRIBUTE_NODE:
-        case DOCUMENT_NODE:
-        case DOCUMENT_TYPE_NODE:
-            // Do nothing.
-            return;
+        return;
+    }
+    case ATTRIBUTE_NODE:
+    case DOCUMENT_NODE:
+    case DOCUMENT_TYPE_NODE:
+        // Do nothing.
+        return;
     }
     ASSERT_NOT_REACHED();
 }
 
 bool Node::offsetInCharacters() const
 {
     return isCharacterDataNode();
 }
 
 unsigned short Node::compareDocumentPosition(const Node* otherNode, ShadowTreesTreatment treatment) const
@@ skipping 78 matching lines @@
             if (child2->nodeType() == ATTRIBUTE_NODE)
                 return DOCUMENT_POSITION_PRECEDING | connection;
 
             // If one of the children is a shadow root,
             if (child1->isShadowRoot() || child2->isShadowRoot()) {
                 if (!child2->isShadowRoot())
                     return Node::DOCUMENT_POSITION_FOLLOWING | connection;
                 if (!child1->isShadowRoot())
                     return Node::DOCUMENT_POSITION_PRECEDING | connection;
 
-                for (ShadowRoot* child = toShadowRoot(child2)->olderShadowRoot(); child; child = child->olderShadowRoot())
-                    if (child == child1)
+                for (ShadowRoot* child = toShadowRoot(child2)->olderShadowRoot(); child; child = child->olderShadowRoot()) {
+                    if (child == child1) {
                         return Node::DOCUMENT_POSITION_FOLLOWING | connection;
+                    }
+                }
 
                 return Node::DOCUMENT_POSITION_PRECEDING | connection;
             }
 
             if (!child2->nextSibling())
                 return DOCUMENT_POSITION_FOLLOWING | connection;
             if (!child1->nextSibling())
                 return DOCUMENT_POSITION_PRECEDING | connection;
 
             // Otherwise we need to see which node occurs first.  Crawl backwards from child2 looking for child1.
             for (Node* child = child2->previousSibling(); child; child = child->previousSibling()) {
                 if (child == child1)
                     return DOCUMENT_POSITION_FOLLOWING | connection;
             }
             return DOCUMENT_POSITION_PRECEDING | connection;
         }
     }
 
     // There was no difference between the two parent chains, i.e., one was a subset of the other.  The shorter
     // chain is the ancestor.
     return index1 < index2 ?
-               DOCUMENT_POSITION_FOLLOWING | DOCUMENT_POSITION_CONTAINED_BY | connection :
-               DOCUMENT_POSITION_PRECEDING | DOCUMENT_POSITION_CONTAINS | connection;
+        DOCUMENT_POSITION_FOLLOWING | DOCUMENT_POSITION_CONTAINED_BY | connection :
+        DOCUMENT_POSITION_PRECEDING | DOCUMENT_POSITION_CONTAINS | connection;
 }
 
 String Node::debugName() const
 {
     StringBuilder name;
     name.append(nodeName());
 
     if (isElementNode()) {
         const Element& thisElement = toElement(*this);
         if (thisElement.hasID()) {
@@ skipping 81 matching lines @@
 
         switch (node->nodeType()) {
         case ELEMENT_NODE: {
             WTFLogAlways("/%s", node->nodeName().utf8().data());
 
             const Element* element = toElement(node);
             const AtomicString& idattr = element->getIdAttribute();
             bool hasIdAttr = !idattr.isNull() && !idattr.isEmpty();
             if (node->previousSibling() || node->nextSibling()) {
                 int count = 0;
-                for (Node* previous = node->previousSibling(); previous; previous = previous->previousSibling())
-                    if (previous->nodeName() == node->nodeName())
+                for (Node* previous = node->previousSibling(); previous; previous = previous->previousSibling()) {
+                    if (previous->nodeName() == node->nodeName()) {
                         ++count;
+                    }
+                }
                 if (hasIdAttr)
                     WTFLogAlways("[@id=\"%s\" and position()=%d]", idattr.utf8().data(), count);
                 else
                     WTFLogAlways("[%d]", count);
             } else if (hasIdAttr) {
                 WTFLogAlways("[@id=\"%s\"]", idattr.utf8().data());
             }
             break;
         }
         case TEXT_NODE:
@@ skipping 31 matching lines @@
                 traverseTreeAndMark(indent.toString(), pseudo, markedNode1, markedLabel1, markedNode2, markedLabel2);
             if (Element* pseudo = element.pseudoElement(FIRST_LETTER))
                 traverseTreeAndMark(indent.toString(), pseudo, markedNode1, markedLabel1, markedNode2, markedLabel2);
             if (Element* pseudo = element.pseudoElement(BACKDROP))
                 traverseTreeAndMark(indent.toString(), pseudo, markedNode1, markedLabel1, markedNode2, markedLabel2);
         }
 
         if (node.isShadowRoot()) {
             if (ShadowRoot* youngerShadowRoot = toShadowRoot(node).youngerShadowRoot())
                 traverseTreeAndMark(indent.toString(), youngerShadowRoot, markedNode1, markedLabel1, markedNode2, markedLabel2);
-        } else if (ShadowRoot* oldestShadowRoot = oldestShadowRootFor(&node))
+        } else if (ShadowRoot* oldestShadowRoot = oldestShadowRootFor(&node)) {
             traverseTreeAndMark(indent.toString(), oldestShadowRoot, markedNode1, markedLabel1, markedNode2, markedLabel2);
+        }
     }
 }
 
 static void traverseTreeAndMarkInComposedTree(const String& baseIndent, const Node* rootNode, const Node* markedNode1, const char* markedLabel1, const Node* markedNode2, const char* markedLabel2)
 {
     for (const Node* node = rootNode; node; node = ComposedTreeTraversal::nextSibling(*node)) {
         StringBuilder indent;
         if (node == markedNode1)
             indent.append(markedLabel1);
         if (node == markedNode2)
@@ skipping 779 matching lines @@
 
 void showNodePath(const blink::Node* node)
 {
     if (node)
         node->showNodePathForThis();
     else
         fprintf(stderr, "Cannot showNodePath for (nil)\n");
 }
 
 #endif