Reflow comments in core/dom/.

third_party/WebKit/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.
+ * 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
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
@@ skipping 204 matching lines @@
 
 void Element::setTabIndex(int value) {
   setIntegralAttribute(tabindexAttr, value);
 }
 
 short Element::tabIndex() const {
   return hasRareData() ? elementRareData()->tabIndex() : 0;
 }
 
 bool Element::layoutObjectIsFocusable() const {
-  // Elements in canvas fallback content are not rendered, but they are allowed to be
-  // focusable as long as their canvas is displayed and visible.
+  // Elements in canvas fallback content are not rendered, but they are allowed
+  // to be focusable as long as their canvas is displayed and visible.
   if (isInCanvasSubtree()) {
     const HTMLCanvasElement* canvas =
         Traversal<HTMLCanvasElement>::firstAncestorOrSelf(*this);
     DCHECK(canvas);
     return canvas->layoutObject() &&
            canvas->layoutObject()->style()->visibility() ==
                EVisibility::Visible;
   }
 
   // FIXME: Even if we are not visible, we might have a child that is visible.
-  // Hyatt wants to fix that some day with a "has visible content" flag or the like.
+  // Hyatt wants to fix that some day with a "has visible content" flag or the
+  // like.
   return layoutObject() &&
          layoutObject()->style()->visibility() == EVisibility::Visible;
 }
 
 Node* Element::cloneNode(bool deep) {
   return deep ? cloneElementWithChildren() : cloneElementWithoutChildren();
 }
 
 Element* Element::cloneElementWithChildren() {
   Element* clone = cloneElementWithoutChildren();
   cloneChildNodes(clone);
   return clone;
 }
 
 Element* Element::cloneElementWithoutChildren() {
   Element* clone = cloneElementWithoutAttributesAndChildren();
-  // This will catch HTML elements in the wrong namespace that are not correctly copied.
-  // This is a sanity check as HTML overloads some of the DOM methods.
+  // This will catch HTML elements in the wrong namespace that are not correctly
+  // copied.  This is a sanity check as HTML overloads some of the DOM methods.
   DCHECK_EQ(isHTMLElement(), clone->isHTMLElement());
 
   clone->cloneDataFromElement(*this);
   return clone;
 }
 
 Element* Element::cloneElementWithoutAttributesAndChildren() {
   return document().createElement(tagQName(), CreatedByCloneNode);
 }
 
@@ skipping 103 matching lines @@
   }
   if (UNLIKELY(elementData()->m_animatedSVGAttributesAreDirty)) {
     DCHECK(isSVGElement());
     // See comment in the AtomicString version of synchronizeAttribute()
     // also.
     toSVGElement(this)->synchronizeAnimatedSVGAttribute(name);
   }
 }
 
 void Element::synchronizeAttribute(const AtomicString& localName) const {
-  // This version of synchronizeAttribute() is streamlined for the case where you don't have a full QualifiedName,
-  // e.g when called from DOM API.
+  // This version of synchronizeAttribute() is streamlined for the case where
+  // you don't have a full QualifiedName, e.g when called from DOM API.
   if (!elementData())
     return;
   if (elementData()->m_styleAttributeIsDirty &&
       equalPossiblyIgnoringCase(localName, styleAttr.localName(),
                                 shouldIgnoreAttributeCase())) {
     DCHECK(isStyledElement());
     synchronizeStyleAttributeInternal();
     return;
   }
   if (elementData()->m_animatedSVGAttributesAreDirty) {
-    // We're not passing a namespace argument on purpose. SVGNames::*Attr are defined w/o namespaces as well.
+    // We're not passing a namespace argument on purpose. SVGNames::*Attr are
+    // defined w/o namespaces as well.
 
     // FIXME: this code is called regardless of whether name is an
     // animated SVG Attribute. It would seem we should only call this method
     // if SVGElement::isAnimatableAttribute is true, but the list of
     // animatable attributes in isAnimatableAttribute does not suffice to
     // pass all layout tests. Also, m_animatedSVGAttributesAreDirty stays
     // dirty unless synchronizeAnimatedSVGAttribute is called with
     // anyQName(). This means that even if Element::synchronizeAttribute()
     // is called on all attributes, m_animatedSVGAttributesAreDirty remains
     // true.
@@ skipping 142 matching lines @@
   DCHECK(!layoutObject() || layoutObject()->isBox());
 
   if (scrollState.fullyConsumed())
     return;
 
   FloatSize delta(scrollState.deltaX(), scrollState.deltaY());
 
   if (delta.isZero())
     return;
 
-  // TODO(esprehn): This should use updateStyleAndLayoutIgnorePendingStylesheetsForNode.
+  // TODO(esprehn): This should use
+  // updateStyleAndLayoutIgnorePendingStylesheetsForNode.
   document().updateStyleAndLayoutIgnorePendingStylesheets();
 
   LayoutBox* boxToScroll = nullptr;
 
   // We should only ever scroll the effective root scroller this way when the
   // page removes the default applyScroll (ViewportScrollCallback).
   if (document().rootScrollerController()->effectiveRootScroller() == this)
     boxToScroll = document().layoutView();
   else if (layoutObject())
     boxToScroll = toLayoutBox(layoutObject());
@@ skipping 121 matching lines @@
   document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
 
   if (LayoutBox* layoutObject = layoutBox())
     return adjustLayoutUnitForAbsoluteZoom(layoutObject->clientTop(),
                                            layoutObject->styleRef())
         .round();
   return 0;
 }
 
 int Element::clientWidth() {
-  // When in strict mode, clientWidth for the document element should return the width of the containing frame.
-  // When in quirks mode, clientWidth for the body element should return the width of the containing frame.
+  // When in strict mode, clientWidth for the document element should return the
+  // width of the containing frame.
+  // When in quirks mode, clientWidth for the body element should return the
+  // width of the containing frame.
   bool inQuirksMode = document().inQuirksMode();
   if ((!inQuirksMode && document().documentElement() == this) ||
       (inQuirksMode && isHTMLElement() && document().body() == this)) {
     LayoutViewItem layoutView = document().layoutViewItem();
     if (!layoutView.isNull()) {
       if (!RuntimeEnabledFeatures::overlayScrollbarsEnabled() ||
           !document().frame()->isLocalRoot())
         document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
       if (document().page()->settings().forceZeroLayoutHeight())
         return adjustLayoutUnitForAbsoluteZoom(
@@ skipping 11 matching lines @@
 
   if (LayoutBox* layoutObject = layoutBox())
     return adjustLayoutUnitForAbsoluteZoom(
                LayoutUnit(layoutObject->pixelSnappedClientWidth()),
                layoutObject->styleRef())
         .round();
   return 0;
 }
 
 int Element::clientHeight() {
-  // When in strict mode, clientHeight for the document element should return the height of the containing frame.
-  // When in quirks mode, clientHeight for the body element should return the height of the containing frame.
+  // When in strict mode, clientHeight for the document element should return
+  // the height of the containing frame.
+  // When in quirks mode, clientHeight for the body element should return the
+  // height of the containing frame.
   bool inQuirksMode = document().inQuirksMode();
 
   if ((!inQuirksMode && document().documentElement() == this) ||
       (inQuirksMode && isHTMLElement() && document().body() == this)) {
     LayoutViewItem layoutView = document().layoutViewItem();
     if (!layoutView.isNull()) {
       if (!RuntimeEnabledFeatures::overlayScrollbarsEnabled() ||
           !document().frame()->isLocalRoot())
         document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
       if (document().page()->settings().forceZeroLayoutHeight())
@@ skipping 539 matching lines @@
       styleAttributeChanged(newValue, reason);
     } else if (isPresentationAttribute(name)) {
       elementData()->m_presentationAttributeStyleIsDirty = true;
       setNeedsStyleRecalc(LocalStyleChange,
                           StyleChangeReasonForTracing::fromAttribute(name));
     }
   }
 
   invalidateNodeListCachesInAncestors(&name, this);
 
-  // If there is currently no StyleResolver, we can't be sure that this attribute change won't affect style.
+  // If there is currently no StyleResolver, we can't be sure that this
+  // attribute change won't affect style.
   if (!document().styleResolver())
     setNeedsStyleRecalc(SubtreeStyleChange,
                         StyleChangeReasonForTracing::fromAttribute(name));
 
   if (isConnected()) {
     if (AXObjectCache* cache = document().existingAXObjectCache())
       cache->handleAttributeChanged(name, this);
   }
 }
 
@@ skipping 162 matching lines @@
           document()
               .elementDataCache()
               ->cachedShareableElementDataWithAttributes(attributeVector);
     else
       m_elementData =
           ShareableElementData::createWithAttributes(attributeVector);
   }
 
   parserDidSetAttributes();
 
-  // Use attributeVector instead of m_elementData because attributeChanged might modify m_elementData.
+  // Use attributeVector instead of m_elementData because attributeChanged might
+  // modify m_elementData.
   for (const auto& attribute : attributeVector)
     attributeChangedFromParserOrByCloning(attribute.name(), attribute.value(),
                                           ModifiedDirectly);
 }
 
 bool Element::hasEquivalentAttributes(const Element* other) const {
   synchronizeAllAttributes();
   other->synchronizeAllAttributes();
   if (elementData() == other->elementData())
     return true;
@@ skipping 203 matching lines @@
 }
 
 void Element::detachLayoutTree(const AttachContext& context) {
   HTMLFrameOwnerElement::UpdateSuspendScope suspendWidgetHierarchyUpdates;
   cancelFocusAppearanceUpdate();
   removeCallbackSelectors();
   if (hasRareData()) {
     ElementRareData* data = elementRareData();
     data->clearPseudoElements();
 
-    // attachLayoutTree() will clear the computed style for us when inside recalcStyle.
+    // attachLayoutTree() will clear the computed style for us when inside
+    // recalcStyle.
     if (!document().inStyleRecalc())
       data->clearComputedStyle();
 
     if (ElementAnimations* elementAnimations = data->elementAnimations()) {
       if (context.performingReattach) {
-        // FIXME: We call detach from within style recalc, so compositingState is not up to date.
+        // FIXME: We call detach from within style recalc, so compositingState
+        // is not up to date.
         // https://code.google.com/p/chromium/issues/detail?id=339847
         DisableCompositingQueryAsserts disabler;
 
-        // FIXME: restart compositor animations rather than pull back to the main thread
+        // FIXME: restart compositor animations rather than pull back to the
+        // main thread
         elementAnimations->restartAnimationOnCompositor();
       } else {
         elementAnimations->cssAnimations().cancel();
         elementAnimations->setAnimationStyleChange(false);
       }
       elementAnimations->clearBaseComputedStyle();
     }
 
     if (ElementShadow* shadow = data->shadow())
       shadow->detach(context);
@@ skipping 58 matching lines @@
     }
   }
   return false;
 }
 
 PassRefPtr<ComputedStyle> Element::styleForLayoutObject() {
   DCHECK(document().inStyleRecalc());
 
   RefPtr<ComputedStyle> style;
 
-  // FIXME: Instead of clearing updates that may have been added from calls to styleForElement
-  // outside recalcStyle, we should just never set them if we're not inside recalcStyle.
+  // FIXME: Instead of clearing updates that may have been added from calls to
+  // styleForElement outside recalcStyle, we should just never set them if we're
+  // not inside recalcStyle.
   if (ElementAnimations* elementAnimations = this->elementAnimations())
     elementAnimations->cssAnimations().clearPendingUpdate();
 
   if (hasCustomStyleCallbacks())
     style = customStyleForLayoutObject();
   if (!style)
     style = originalStyleForLayoutObject();
   DCHECK(style);
 
   // styleForElement() might add active animations so we need to get it again.
@@ skipping 37 matching lines @@
       if (change >= IndependentInherit) {
         if (ElementAnimations* elementAnimations = data->elementAnimations())
           elementAnimations->setAnimationStyleChange(false);
       }
     }
     if (parentComputedStyle())
       change = recalcOwnStyle(change);
     clearNeedsStyleRecalc();
   }
 
-  // If we reattached we don't need to recalc the style of our descendants anymore.
+  // If we reattached we don't need to recalc the style of our descendants
+  // anymore.
   if ((change >= UpdatePseudoElements && change < Reattach) ||
       childNeedsStyleRecalc()) {
     SelectorFilterParentScope filterScope(*this);
     StyleSharingDepthScope sharingScope(*this);
 
     updatePseudoElement(PseudoIdBefore, change);
 
     if (change > UpdatePseudoElements || childNeedsStyleRecalc()) {
       for (ShadowRoot* root = youngestShadowRoot(); root;
            root = root->olderShadowRoot()) {
@@ skipping 61 matching lines @@
 
   StyleRecalcChange localChange =
       ComputedStyle::stylePropagationDiff(oldStyle.get(), newStyle.get());
   if (localChange == NoChange) {
     INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), stylesUnchanged, 1);
   } else {
     INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), stylesChanged, 1);
   }
 
   if (localChange == Reattach) {
-    // TODO(nainar): Remove the style parameter being passed into buildLayoutTree().
-    // ComputedStyle will now be stored on Node and accessed in buildLayoutTree()
-    // using mutableComputedStyle().
+    // TODO(nainar): Remove the style parameter being passed into
+    // buildLayoutTree().  ComputedStyle will now be stored on Node and accessed
+    // in buildLayoutTree() using mutableComputedStyle().
     return buildLayoutTree(*newStyle);
   }
 
   DCHECK(oldStyle);
 
   if (localChange != NoChange)
     updateCallbackSelectors(oldStyle.get(), newStyle.get());
 
   if (LayoutObject* layoutObject = this->layoutObject()) {
     if (localChange != NoChange ||
         pseudoStyleCacheIsInvalid(oldStyle.get(), newStyle.get()) ||
         svgFilterNeedsLayerUpdate()) {
       layoutObject->setStyle(newStyle.get());
     } else {
-      // Although no change occurred, we use the new style so that the cousin style sharing code won't get
-      // fooled into believing this style is the same.
+      // Although no change occurred, we use the new style so that the cousin
+      // style sharing code won't get fooled into believing this style is the
+      // same.
       // FIXME: We may be able to remove this hack, see discussion in
       // https://codereview.chromium.org/30453002/
       layoutObject->setStyleInternal(newStyle.get());
     }
   }
 
   if (getStyleChangeType() >= SubtreeStyleChange)
     return Force;
 
   if (change > Inherit || localChange > Inherit)
@@ skipping 353 matching lines @@
   if (hasRareData())
     elementRareData()->removeAttrNodeList();
 }
 
 Attr* Element::setAttributeNode(Attr* attrNode,
                                 ExceptionState& exceptionState) {
   Attr* oldAttrNode = attrIfExists(attrNode->getQualifiedName());
   if (oldAttrNode == attrNode)
     return attrNode;  // This Attr is already attached to the element.
 
-  // InUseAttributeError: Raised if node is an Attr that is already an attribute of another Element object.
-  // The DOM user must explicitly clone Attr nodes to re-use them in other elements.
+  // InUseAttributeError: Raised if node is an Attr that is already an attribute
+  // of another Element object.  The DOM user must explicitly clone Attr nodes
+  // to re-use them in other elements.
   if (attrNode->ownerElement()) {
     exceptionState.throwDOMException(
         InUseAttributeError,
         "The node provided is an attribute node that is already an attribute "
         "of another Element; attribute nodes must be explicitly cloned.");
     return nullptr;
   }
 
   if (!isHTMLElement() && attrNode->document().isHTMLDocument() &&
       attrNode->name() != attrNode->name().lower())
@@ skipping 268 matching lines @@
 
 void Element::updateFocusAppearance(
     SelectionBehaviorOnFocus selectionBehavior) {
   if (selectionBehavior == SelectionBehaviorOnFocus::None)
     return;
   if (isRootEditableElement(*this)) {
     LocalFrame* frame = document().frame();
     if (!frame)
       return;
 
-    // When focusing an editable element in an iframe, don't reset the selection if it already contains a selection.
+    // When focusing an editable element in an iframe, don't reset the selection
+    // if it already contains a selection.
     if (this == frame->selection().rootEditableElement())
       return;
 
     // FIXME: We should restore the previous selection if there is one.
     VisibleSelection newSelection = createVisibleSelectionDeprecated(
         firstPositionInOrBeforeNode(this), TextAffinity::Downstream);
-    // Passing DoNotSetFocus as this function is called after FocusController::setFocusedElement()
-    // and we don't want to change the focus to a new Element.
+    // Passing DoNotSetFocus as this function is called after
+    // FocusController::setFocusedElement() and we don't want to change the
+    // focus to a new Element.
     frame->selection().setSelection(newSelection,
                                     FrameSelection::CloseTyping |
                                         FrameSelection::ClearTypingStyle |
                                         FrameSelection::DoNotSetFocus);
 
     // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
     // needs to be audited.  See http://crbug.com/590369 for more details.
     document().updateStyleAndLayoutIgnorePendingStylesheets();
 
     frame->selection().revealSelection();
   } else if (layoutObject() && !layoutObject()->isLayoutPart()) {
     layoutObject()->scrollRectToVisible(boundingBox());
   }
 }
 
 void Element::blur() {
   cancelFocusAppearanceUpdate();
   if (adjustedFocusedElementInTreeScope() == this) {
     Document& doc = document();
     if (doc.page())
       doc.page()->focusController().setFocusedElement(0, doc.frame());
     else
       doc.clearFocusedElement();
   }
 }
 
 bool Element::supportsFocus() const {
   // FIXME: supportsFocus() can be called when layout is not up to date.
-  // Logic that deals with the layoutObject should be moved to layoutObjectIsFocusable().
+  // Logic that deals with the layoutObject should be moved to
+  // layoutObjectIsFocusable().
   // But supportsFocus must return true when the element is editable, or else
   // it won't be focusable. Furthermore, supportsFocus cannot just return true
   // always or else tabIndex() will change for all HTML elements.
   return hasElementFlag(TabIndexWasSetExplicitly) ||
          isRootEditableElement(*this) ||
          (isShadowHost(this) && authorShadowRoot() &&
           authorShadowRoot()->delegatesFocus()) ||
          supportsSpatialNavigationFocus();
 }
 
 bool Element::supportsSpatialNavigationFocus() const {
   // This function checks whether the element satisfies the extended criteria
   // for the element to be focusable, introduced by spatial navigation feature,
   // i.e. checks if click or keyboard event handler is specified.
   // This is the way to make it possible to navigate to (focus) elements
-  // which web designer meant for being active (made them respond to click events).
+  // which web designer meant for being active (made them respond to click
+  // events).
   if (!isSpatialNavigationEnabled(document().frame()) ||
       spatialNavigationIgnoresEventHandlers(document().frame()))
     return false;
   if (hasEventListeners(EventTypeNames::click) ||
       hasEventListeners(EventTypeNames::keydown) ||
       hasEventListeners(EventTypeNames::keypress) ||
       hasEventListeners(EventTypeNames::keyup))
     return true;
   if (!isSVGElement())
     return false;
@@ skipping 273 matching lines @@
          document().frame()->eventHandler().hasPointerCapture(pointerId, this);
 }
 
 bool Element::hasProcessedPointerCapture(int pointerId) const {
   return document().frame() &&
          document().frame()->eventHandler().hasProcessedPointerCapture(
              pointerId, this);
 }
 
 String Element::innerText() {
-  // We need to update layout, since plainText uses line boxes in the layout tree.
+  // We need to update layout, since plainText uses line boxes in the layout
+  // tree.
   document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(this);
 
   if (!layoutObject())
     return textContent(true);
 
   return plainText(EphemeralRange::rangeOfContents(*this),
                    TextIteratorForInnerText);
 }
 
 String Element::outerText() {
@@ skipping 83 matching lines @@
     return;
   ensureElementRareData().setMinimumSizeForResizing(size);
 }
 
 const ComputedStyle* Element::ensureComputedStyle(
     PseudoId pseudoElementSpecifier) {
   if (PseudoElement* element = pseudoElement(pseudoElementSpecifier))
     return element->ensureComputedStyle();
 
   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.
+    // 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 nullptr;
   }
 
-  // FIXME: Find and use the layoutObject from the pseudo element instead of the actual element so that the 'length'
-  // properties, which are only known by the layoutObject because it did the layout, will be correct and so that the
+  // FIXME: Find and use the layoutObject from the pseudo element instead of the
+  // actual element so that the 'length' properties, which are only known by the
+  // layoutObject because it did the layout, will be correct and so that the
   // values returned for the ":selection" pseudo-element will be correct.
   ComputedStyle* elementStyle = mutableComputedStyle();
   if (!elementStyle) {
     ElementRareData& rareData = ensureElementRareData();
     if (!rareData.computedStyle())
       rareData.setComputedStyle(
           document().styleForElementIgnoringPendingStylesheets(this));
     elementStyle = rareData.computedStyle();
   }
 
   if (!pseudoElementSpecifier)
     return elementStyle;
 
   if (ComputedStyle* pseudoElementStyle =
           elementStyle->getCachedPseudoStyle(pseudoElementSpecifier))
     return pseudoElementStyle;
 
   RefPtr<ComputedStyle> result =
       document().ensureStyleResolver().pseudoStyleForElement(
           this, PseudoStyleRequest(pseudoElementSpecifier,
                                    PseudoStyleRequest::ForComputedStyle),
           elementStyle);
   DCHECK(result);
   return elementStyle->addCachedPseudoStyle(result.release());
 }
 
 AtomicString Element::computeInheritedLanguage() const {
   const Node* n = this;
   AtomicString value;
-  // The language property is inherited, so we iterate over the parents to find the first language.
+  // The language property is inherited, so we iterate over the parents to find
+  // the first language.
   do {
     if (n->isElementNode()) {
       if (const ElementData* elementData = toElement(n)->elementData()) {
         AttributeCollection attributes = elementData->attributes();
         // Spec: xml:lang takes precedence -- http://www.w3.org/TR/xhtml1/#C_7
         if (const Attribute* attribute = attributes.find(XMLNames::langAttr))
           value = attribute->value();
         else if (const Attribute* attribute =
                      attributes.find(HTMLNames::langAttr))
           value = attribute->value();
@@ skipping 25 matching lines @@
   if (element && (change == UpdatePseudoElements ||
                   element->shouldCallRecalcStyle(change))) {
     if (pseudoId == PseudoIdFirstLetter && updateFirstLetter(element))
       return;
 
     // Need to clear the cached style if the PseudoElement wants a recalc so it
     // computes a new style.
     if (element->needsStyleRecalc())
       layoutObject()->mutableStyle()->removeCachedPseudoStyle(pseudoId);
 
-    // PseudoElement styles hang off their parent element's style so if we needed
-    // a style recalc we should Force one on the pseudo.
-    // FIXME: We should figure out the right text sibling to pass.
+    // PseudoElement styles hang off their parent element's style so if we
+    // needed a style recalc we should Force one on the pseudo.  FIXME: We
+    // should figure out the right text sibling to pass.
     element->recalcStyle(change == UpdatePseudoElements ? Force : change);
 
-    // Wait until our parent is not displayed or pseudoElementLayoutObjectIsNeeded
-    // is false, otherwise we could continuously create and destroy PseudoElements
-    // when LayoutObject::isChildAllowed on our parent returns false for the
+    // Wait until our parent is not displayed or
+    // pseudoElementLayoutObjectIsNeeded is false, otherwise we could
+    // continuously create and destroy PseudoElements when
+    // LayoutObject::isChildAllowed on our parent returns false for the
     // PseudoElement's layoutObject for each style recalc.
     if (!layoutObject() ||
         !pseudoElementLayoutObjectIsNeeded(
             layoutObject()->getCachedPseudoStyle(pseudoId)))
       elementRareData()->setPseudoElement(pseudoId, nullptr);
   } else if (pseudoId == PseudoIdFirstLetter && element &&
              change >= UpdatePseudoElements &&
              !FirstLetterPseudoElement::firstLetterTextLayoutObject(*element)) {
-    // This can happen if we change to a float, for example. We need to cleanup the
-    // first-letter pseudoElement and then fix the text of the original remaining
-    // text layoutObject.
-    // This can be seen in Test 7 of fast/css/first-letter-removed-added.html
+    // This can happen if we change to a float, for example. We need to cleanup
+    // the first-letter pseudoElement and then fix the text of the original
+    // remaining text layoutObject.  This can be seen in Test 7 of
+    // fast/css/first-letter-removed-added.html
     elementRareData()->setPseudoElement(pseudoId, nullptr);
   } else if (change >= UpdatePseudoElements) {
     createPseudoElementIfNeeded(pseudoId);
   }
 }
 
 // If we're updating first letter, and the current first letter layoutObject
 // is not the same as the one we're currently using we need to re-create
 // the first letter layoutObject.
 bool Element::updateFirstLetter(Element* element) {
@@ skipping 12 matching lines @@
       elementRareData()->setPseudoElement(PseudoIdFirstLetter, nullptr);
     return true;
   }
   return false;
 }
 
 void Element::createPseudoElementIfNeeded(PseudoId pseudoId) {
   if (isPseudoElement())
     return;
 
-  // Document::ensureStyleResolver is not inlined and shows up on profiles, avoid it here.
+  // Document::ensureStyleResolver is not inlined and shows up on profiles,
+  // avoid it here.
   PseudoElement* element =
       document().styleEngine().ensureResolver().createPseudoElementIfNeeded(
           *this, pseudoId);
   if (!element)
     return;
 
   if (pseudoId == PseudoIdBackdrop)
     document().addToTopLayer(element, this);
   element->insertedInto(this);
   element->attachLayoutTree();
@@ skipping 38 matching lines @@
 }
 
 DOMStringMap& Element::dataset() {
   ElementRareData& rareData = ensureElementRareData();
   if (!rareData.dataset())
     rareData.setDataset(DatasetDOMStringMap::create(this));
   return *rareData.dataset();
 }
 
 KURL Element::hrefURL() const {
-  // FIXME: These all have href() or url(), but no common super class. Why doesn't
-  // <link> implement URLUtils?
+  // FIXME: These all have href() or url(), but no common super class. Why
+  // doesn't <link> implement URLUtils?
   if (isHTMLAnchorElement(*this) || isHTMLAreaElement(*this) ||
       isHTMLLinkElement(*this))
     return getURLAttribute(hrefAttr);
   if (isSVGAElement(*this))
     return toSVGAElement(*this).legacyHrefURL(document());
   return KURL();
 }
 
 KURL Element::getURLAttribute(const QualifiedName& name) const {
 #if DCHECK_IS_ON()
@@ skipping 80 matching lines @@
   for (Element* element = nextAncestorElement(this); element;
        element = nextAncestorElement(element))
     element->setContainsFullScreenElement(flag);
 }
 
 void Element::setIsInTopLayer(bool inTopLayer) {
   if (isInTopLayer() == inTopLayer)
     return;
   setElementFlag(IsInTopLayer, inTopLayer);
 
-  // We must ensure a reattach occurs so the layoutObject is inserted in the correct sibling order under LayoutView according to its
-  // top layer position, or in its usual place if not in the top layer.
+  // We must ensure a reattach occurs so the layoutObject is inserted in the
+  // correct sibling order under LayoutView according to its top layer position,
+  // or in its usual place if not in the top layer.
   lazyReattachIfAttached();
 }
 
 void Element::requestPointerLock() {
   if (document().page())
     document().page()->pointerLockController().requestPointerLock(this);
 }
 
 SpellcheckAttributeState Element::spellcheckAttributeState() const {
   const AtomicString& value = fastGetAttribute(spellcheckAttr);
@@ skipping 141 matching lines @@
                                              const Document& oldDocument,
                                              const Document& newDocument) {
   if (oldDocument == newDocument)
     return false;
   if (oldDocument.baseURL() == newDocument.baseURL())
     return false;
   const StylePropertySet* style = element.inlineStyle();
   if (!style)
     return false;
   for (unsigned i = 0; i < style->propertyCount(); ++i) {
-    // FIXME: Should handle all URL-based properties: CSSImageSetValue, CSSCursorImageValue, etc.
+    // FIXME: Should handle all URL-based properties: CSSImageSetValue,
+    // CSSCursorImageValue, etc.
     if (style->propertyAt(i).value().isImageValue())
       return true;
   }
   return false;
 }
 
 static void reResolveURLsInInlineStyle(const Document& document,
                                        MutableStylePropertySet& style) {
   for (unsigned i = 0; i < style.propertyCount(); ++i) {
     StylePropertySet::PropertyReference property = style.propertyAt(i);
-    // FIXME: Should handle all URL-based properties: CSSImageSetValue, CSSCursorImageValue, etc.
+    // FIXME: Should handle all URL-based properties: CSSImageSetValue,
+    // CSSCursorImageValue, etc.
     if (property.value().isImageValue())
       toCSSImageValue(property.value()).reResolveURL(document);
   }
 }
 
 void Element::didMoveToNewDocument(Document& oldDocument) {
   Node::didMoveToNewDocument(oldDocument);
 
   // If the documents differ by quirks mode then they differ by case sensitivity
   // for class and id names so we need to go through the attribute change logic
@@ skipping 125 matching lines @@
 
   if (!oldID.isNull() || !newID.isNull())
     updateId(oldID, newID);
 
   const AtomicString& oldName = getNameAttribute();
   const AtomicString& newName = other.getNameAttribute();
 
   if (!oldName.isNull() || !newName.isNull())
     updateName(oldName, newName);
 
-  // Quirks mode makes class and id not case sensitive. We can't share the ElementData
-  // if the idForStyleResolution and the className need different casing.
+  // Quirks mode makes class and id not case sensitive. We can't share the
+  // ElementData if the idForStyleResolution and the className need different
+  // casing.
   bool ownerDocumentsHaveDifferentCaseSensitivity = false;
   if (other.hasClass() || other.hasID())
     ownerDocumentsHaveDifferentCaseSensitivity =
         other.document().inQuirksMode() != document().inQuirksMode();
 
-  // If 'other' has a mutable ElementData, convert it to an immutable one so we can share it between both elements.
-  // We can only do this if there are no presentation attributes and sharing the data won't result in different case sensitivity of class or id.
+  // If 'other' has a mutable ElementData, convert it to an immutable one so we
+  // can share it between both elements.
+  // We can only do this if there are no presentation attributes and sharing the
+  // data won't result in different case sensitivity of class or id.
   if (other.m_elementData->isUnique() &&
       !ownerDocumentsHaveDifferentCaseSensitivity &&
       !other.m_elementData->presentationAttributeStyle())
     const_cast<Element&>(other).m_elementData =
         toUniqueElementData(other.m_elementData)->makeShareableCopy();
 
   if (!other.m_elementData->isUnique() &&
       !ownerDocumentsHaveDifferentCaseSensitivity &&
       !needsURLResolutionForInlineStyle(other, other.document(), document()))
     m_elementData = other.m_elementData;
@@ skipping 61 matching lines @@
   if (ensureMutableInlineStyle().isEmpty()) {
     ensureUniqueElementData().m_inlineStyle.clear();
   }
 }
 
 inline void Element::setInlineStyleFromString(
     const AtomicString& newStyleString) {
   DCHECK(isStyledElement());
   Member<StylePropertySet>& inlineStyle = elementData()->m_inlineStyle;
 
-  // Avoid redundant work if we're using shared attribute data with already parsed inline style.
+  // Avoid redundant work if we're using shared attribute data with already
+  // parsed inline style.
   if (inlineStyle && !elementData()->isUnique())
     return;
 
-  // We reconstruct the property set instead of mutating if there is no CSSOM wrapper.
-  // This makes wrapperless property sets immutable and so cacheable.
+  // We reconstruct the property set instead of mutating if there is no CSSOM
+  // wrapper.  This makes wrapperless property sets immutable and so cacheable.
   if (inlineStyle && !inlineStyle->isMutable())
     inlineStyle.clear();
 
   if (!inlineStyle) {
     inlineStyle = CSSParser::parseInlineStyleDeclaration(newStyleString, this);
   } else {
     DCHECK(inlineStyle->isMutable());
     static_cast<MutableStylePropertySet*>(inlineStyle.get())
         ->parseDeclarationList(newStyleString,
                                document().elementSheet().contents());
@@ skipping 99 matching lines @@
 void Element::removeAllInlineStyleProperties() {
   DCHECK(isStyledElement());
   if (!inlineStyle())
     return;
   ensureMutableInlineStyle().clear();
   inlineStyleChanged();
 }
 
 void Element::updatePresentationAttributeStyle() {
   synchronizeAllAttributes();
-  // ShareableElementData doesn't store presentation attribute style, so make sure we have a UniqueElementData.
+  // ShareableElementData doesn't store presentation attribute style, so make
+  // sure we have a UniqueElementData.
   UniqueElementData& elementData = ensureUniqueElementData();
   elementData.m_presentationAttributeStyleIsDirty = false;
   elementData.m_presentationAttributeStyle =
       computePresentationAttributeStyle(*this);
 }
 
 void Element::addPropertyToPresentationAttributeStyle(
     MutableStylePropertySet* style,
     CSSPropertyID propertyID,
     CSSValueID identifier) {
@@ skipping 138 matching lines @@
 }
 
 DEFINE_TRACE_WRAPPERS(Element) {
   if (hasRareData()) {
     visitor->traceWrappers(elementRareData());
   }
   ContainerNode::traceWrappers(visitor);
 }
 
 }  // namespace blink