Reflow comments in //third_party/WebKit/Source/core/editing/commands

third_party/WebKit/Source/core/editing/commands/ApplyStyleCommand.cpp

 /*
  * Copyright (C) 2005, 2006, 2008, 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 248 matching lines @@
     end = swap;
   }
 
   VisiblePosition visibleStart = createVisiblePositionDeprecated(start);
   VisiblePosition visibleEnd = createVisiblePositionDeprecated(end);
 
   if (visibleStart.isNull() || visibleStart.isOrphan() || visibleEnd.isNull() ||
       visibleEnd.isOrphan())
     return;
 
-  // Save and restore the selection endpoints using their indices in the document, since
-  // addBlockStyleIfNeeded may moveParagraphs, which can remove these endpoints.
-  // Calculate start and end indices from the start of the tree that they're in.
+  // Save and restore the selection endpoints using their indices in the
+  // document, since addBlockStyleIfNeeded may moveParagraphs, which can remove
+  // these endpoints. Calculate start and end indices from the start of the tree
+  // that they're in.
   Node& scope = NodeTraversal::highestAncestorOrSelf(
       *visibleStart.deepEquivalent().anchorNode());
   Range* startRange =
       Range::create(document(), Position::firstPositionInNode(&scope),
                     visibleStart.deepEquivalent().parentAnchoredEquivalent());
   Range* endRange =
       Range::create(document(), Position::firstPositionInNode(&scope),
                     visibleEnd.deepEquivalent().parentAnchoredEquivalent());
   int startIndex = TextIterator::rangeLength(startRange->startPosition(),
                                              startRange->endPosition(), true);
@@ skipping 119 matching lines @@
 
   if (isValidCaretPositionInTextNode(end)) {
     splitTextAtEnd(start, end);
     start = startPosition();
     end = endPosition();
   }
 
   DCHECK(start.anchorNode());
   DCHECK(end.anchorNode());
   // Calculate loop end point.
-  // If the end node is before the start node (can only happen if the end node is
-  // an ancestor of the start node), we gather nodes up to the next sibling of the end node
+  // If the end node is before the start node (can only happen if the end node
+  // is an ancestor of the start node), we gather nodes up to the next sibling
+  // of the end node
   const Node* const beyondEnd = end.nodeAsRangePastLastNode();
-  start = mostBackwardCaretPosition(
-      start);  // Move upstream to ensure we do not add redundant spans.
+  // Move upstream to ensure we do not add redundant spans.
+  start = mostBackwardCaretPosition(start);
   Node* startNode = start.anchorNode();
   DCHECK(startNode);
 
-  // Make sure we're not already at the end or the next NodeTraversal::next() will traverse
-  // past it.
+  // Make sure we're not already at the end or the next NodeTraversal::next()
+  // will traverse past it.
   if (startNode == beyondEnd)
     return;
 
   if (startNode->isTextNode() &&
       start.computeOffsetInContainerNode() >= caretMaxOffset(startNode)) {
     // Move out of text node if range does not include its characters.
     startNode = NodeTraversal::next(*startNode);
     if (!startNode)
       return;
   }
 
   // Store away font size before making any changes to the document.
   // This ensures that changes to one node won't effect another.
   HeapHashMap<Member<Node>, float> startingFontSizes;
   for (Node* node = startNode; node != beyondEnd;
        node = NodeTraversal::next(*node)) {
     DCHECK(node);
     startingFontSizes.set(node, computedFontSize(node));
   }
 
-  // These spans were added by us. If empty after font size changes, they can be removed.
+  // These spans were added by us. If empty after font size changes, they can be
+  // removed.
   HeapVector<Member<HTMLElement>> unstyledSpans;
 
   Node* lastStyledNode = nullptr;
   for (Node* node = startNode; node != beyondEnd;
        node = NodeTraversal::next(*node)) {
     DCHECK(node);
     HTMLElement* element = nullptr;
     if (node->isHTMLElement()) {
       // Only work on fully selected nodes.
       if (!elementFullySelected(toHTMLElement(*node), start, end))
         continue;
       element = toHTMLElement(node);
     } else if (node->isTextNode() && node->layoutObject() &&
                node->parentNode() != lastStyledNode) {
-      // Last styled node was not parent node of this text node, but we wish to style this
-      // text node. To make this possible, add a style span to surround this text node.
+      // Last styled node was not parent node of this text node, but we wish to
+      // style this text node. To make this possible, add a style span to
+      // surround this text node.
       HTMLSpanElement* span = HTMLSpanElement::create(document());
       surroundNodeRangeWithElement(node, node, span, editingState);
       if (editingState->isAborted())
         return;
       element = span;
     } else {
       // Only handle HTML elements and text nodes.
       continue;
     }
     lastStyledNode = node;
@@ skipping 57 matching lines @@
       if (editingState->isAborted())
         return;
     }
   }
 }
 
 HTMLElement* ApplyStyleCommand::splitAncestorsWithUnicodeBidi(
     Node* node,
     bool before,
     WritingDirection allowedDirection) {
-  // We are allowed to leave the highest ancestor with unicode-bidi unsplit if it is unicode-bidi: embed and direction: allowedDirection.
-  // In that case, we return the unsplit ancestor. Otherwise, we return 0.
+  // We are allowed to leave the highest ancestor with unicode-bidi unsplit if
+  // it is unicode-bidi: embed and direction: allowedDirection. In that case, we
+  // return the unsplit ancestor. Otherwise, we return 0.
   Element* block = enclosingBlock(node);
   if (!block)
     return 0;
 
   ContainerNode* highestAncestorWithUnicodeBidi = nullptr;
   ContainerNode* nextHighestAncestorWithUnicodeBidi = nullptr;
   int highestAncestorUnicodeBidi = 0;
   for (Node& runner : NodeTraversal::ancestorsOf(*node)) {
     if (runner == block)
       break;
@@ skipping 52 matching lines @@
       break;
     if (!runner.isStyledElement())
       continue;
 
     Element* element = toElement(&runner);
     int unicodeBidi = getIdentifierValue(
         CSSComputedStyleDeclaration::create(element), CSSPropertyUnicodeBidi);
     if (!unicodeBidi || unicodeBidi == CSSValueNormal)
       continue;
 
-    // FIXME: This code should really consider the mapped attribute 'dir', the inline style declaration,
-    // and all matching style rules in order to determine how to best set the unicode-bidi property to 'normal'.
-    // For now, it assumes that if the 'dir' attribute is present, then removing it will suffice, and
-    // otherwise it sets the property in the inline style declaration.
+    // FIXME: This code should really consider the mapped attribute 'dir', the
+    // inline style declaration, and all matching style rules in order to
+    // determine how to best set the unicode-bidi property to 'normal'. For now,
+    // it assumes that if the 'dir' attribute is present, then removing it will
+    // suffice, and otherwise it sets the property in the inline style
+    // declaration.
     if (element->hasAttribute(dirAttr)) {
-      // FIXME: If this is a BDO element, we should probably just remove it if it has no
-      // other attributes, like we (should) do with B and I elements.
+      // FIXME: If this is a BDO element, we should probably just remove it if
+      // it has no other attributes, like we (should) do with B and I elements.
       removeElementAttribute(element, dirAttr);
     } else {
       MutableStylePropertySet* inlineStyle =
           copyStyleOrCreateEmpty(element->inlineStyle());
       inlineStyle->setProperty(CSSPropertyUnicodeBidi, CSSValueNormal);
       inlineStyle->removeProperty(CSSPropertyDirection);
       setNodeAttribute(element, styleAttr, AtomicString(inlineStyle->asText()));
       if (isSpanWithoutAttributesOrUnstyledStyleSpan(element)) {
         removeNodePreservingChildren(element, editingState);
         if (editingState->isAborted())
@@ skipping 32 matching lines @@
 
   if (start.isNull() || end.isNull())
     return;
 
   if (comparePositions(end, start) < 0) {
     Position swap = start;
     start = end;
     end = swap;
   }
 
-  // split the start node and containing element if the selection starts inside of it
+  // split the start node and containing element if the selection starts inside
+  // of it
   bool splitStart = isValidCaretPositionInTextNode(start);
   if (splitStart) {
     if (shouldSplitTextElement(start.anchorNode()->parentElement(), style))
       splitTextElementAtStart(start, end);
     else
       splitTextAtStart(start, end);
     start = startPosition();
     end = endPosition();
     if (start.isNull() || end.isNull())
       return;
     startDummySpanAncestor = dummySpanAncestorForNode(start.anchorNode());
   }
 
-  // split the end node and containing element if the selection ends inside of it
+  // split the end node and containing element if the selection ends inside of
+  // it
   bool splitEnd = isValidCaretPositionInTextNode(end);
   if (splitEnd) {
     if (shouldSplitTextElement(end.anchorNode()->parentElement(), style))
       splitTextElementAtEnd(start, end);
     else
       splitTextAtEnd(start, end);
     start = startPosition();
     end = endPosition();
     if (start.isNull() || end.isNull())
       return;
     endDummySpanAncestor = dummySpanAncestorForNode(end.anchorNode());
   }
 
   // Remove style from the selection.
   // Use the upstream position of the start for removing style.
-  // This will ensure we remove all traces of the relevant styles from the selection
-  // and prevent us from adding redundant ones, as described in:
+  // This will ensure we remove all traces of the relevant styles from the
+  // selection and prevent us from adding redundant ones, as described in:
   // <rdar://problem/3724344> Bolding and unbolding creates extraneous tags
   Position removeStart = mostBackwardCaretPosition(start);
   WritingDirection textDirection = NaturalWritingDirection;
   bool hasTextDirection = style->textDirection(textDirection);
   EditingStyle* styleWithoutEmbedding = nullptr;
   EditingStyle* embeddingStyle = nullptr;
   if (hasTextDirection) {
-    // Leave alone an ancestor that provides the desired single level embedding, if there is one.
+    // Leave alone an ancestor that provides the desired single level embedding,
+    // if there is one.
     HTMLElement* startUnsplitAncestor =
         splitAncestorsWithUnicodeBidi(start.anchorNode(), true, textDirection);
     HTMLElement* endUnsplitAncestor =
         splitAncestorsWithUnicodeBidi(end.anchorNode(), false, textDirection);
     removeEmbeddingUpToEnclosingBlock(start.anchorNode(), startUnsplitAncestor,
                                       editingState);
     if (editingState->isAborted())
       return;
     removeEmbeddingUpToEnclosingBlock(end.anchorNode(), endUnsplitAncestor,
                                       editingState);
     if (editingState->isAborted())
       return;
 
-    // Avoid removing the dir attribute and the unicode-bidi and direction properties from the unsplit ancestors.
+    // Avoid removing the dir attribute and the unicode-bidi and direction
+    // properties from the unsplit ancestors.
     Position embeddingRemoveStart = removeStart;
     if (startUnsplitAncestor &&
         elementFullySelected(*startUnsplitAncestor, removeStart, end))
       embeddingRemoveStart = Position::inParentAfterNode(*startUnsplitAncestor);
 
     Position embeddingRemoveEnd = end;
     if (endUnsplitAncestor &&
         elementFullySelected(*endUnsplitAncestor, removeStart, end))
       embeddingRemoveEnd = mostForwardCaretPosition(
           Position::inParentBeforeNode(*endUnsplitAncestor));
@@ skipping 39 matching lines @@
     end = endPosition();
   }
 
   // update document layout once before running the rest of the function
   // so that we avoid the expense of updating before each and every call
   // to check a computed style
   document().updateStyleAndLayoutIgnorePendingStylesheets();
 
   EditingStyle* styleToApply = style;
   if (hasTextDirection) {
-    // Avoid applying the unicode-bidi and direction properties beneath ancestors that already have them.
+    // Avoid applying the unicode-bidi and direction properties beneath
+    // ancestors that already have them.
     HTMLElement* embeddingStartElement = highestEmbeddingAncestor(
         start.anchorNode(), enclosingBlock(start.anchorNode()));
     HTMLElement* embeddingEndElement = highestEmbeddingAncestor(
         end.anchorNode(), enclosingBlock(end.anchorNode()));
 
     if (embeddingStartElement || embeddingEndElement) {
       Position embeddingApplyStart =
           embeddingStartElement
               ? Position::inParentAfterNode(*embeddingStartElement)
               : start;
@@ skipping 41 matching lines @@
     startNode = NodeTraversal::next(*startNode);
     if (!startNode ||
         comparePositions(end, firstPositionInOrBeforeNode(startNode)) < 0)
       return;
   }
 
   Node* pastEndNode = end.anchorNode();
   if (end.computeEditingOffset() >= caretMaxOffset(end.anchorNode()))
     pastEndNode = NodeTraversal::nextSkippingChildren(*end.anchorNode());
 
-  // FIXME: Callers should perform this operation on a Range that includes the br
-  // if they want style applied to the empty line.
+  // FIXME: Callers should perform this operation on a Range that includes the
+  // br if they want style applied to the empty line.
   if (start == end && isHTMLBRElement(*start.anchorNode()))
     pastEndNode = NodeTraversal::next(*start.anchorNode());
 
-  // Start from the highest fully selected ancestor so that we can modify the fully selected node.
-  // e.g. When applying font-size: large on <font color="blue">hello</font>, we need to include the font element in our run
-  // to generate <font color="blue" size="4">hello</font> instead of <font color="blue"><font size="4">hello</font></font>
+  // Start from the highest fully selected ancestor so that we can modify the
+  // fully selected node. e.g. When applying font-size: large on <font
+  // color="blue">hello</font>, we need to include the font element in our run
+  // to generate <font color="blue" size="4">hello</font> instead of <font
+  // color="blue"><font size="4">hello</font></font>
   Range* range = Range::create(startNode->document(), start, end);
   Element* editableRoot = rootEditableElement(*startNode);
   if (startNode != editableRoot) {
     while (editableRoot && startNode->parentNode() != editableRoot &&
            isNodeVisiblyContainedWithin(*startNode->parentNode(), *range))
       startNode = startNode->parentNode();
   }
 
   applyInlineStyleToNodeRange(style, startNode, pastEndNode, editingState);
 }
@@ skipping 62 matching lines @@
   Node* node = startNode;
   for (Node* next; node && node != pastEndNode; node = next) {
     next = NodeTraversal::next(*node);
 
     if (!node->layoutObject() || !hasEditableStyle(*node))
       continue;
 
     if (!hasRichlyEditableStyle(*node) && node->isHTMLElement()) {
       HTMLElement* element = toHTMLElement(node);
       // This is a plaintext-only region. Only proceed if it's fully selected.
-      // pastEndNode is the node after the last fully selected node, so if it's inside node then
-      // node isn't fully selected.
+      // pastEndNode is the node after the last fully selected node, so if it's
+      // inside node then node isn't fully selected.
       if (pastEndNode && pastEndNode->isDescendantOf(element))
         break;
       // Add to this element's inline style and skip over its contents.
       next = NodeTraversal::nextSkippingChildren(*node);
       if (!style->style())
         continue;
       MutableStylePropertySet* inlineStyle =
           copyStyleOrCreateEmpty(element->inlineStyle());
       inlineStyle->mergeAndOverrideOnConflict(style->style());
       setNodeAttribute(element, styleAttr, AtomicString(inlineStyle->asText()));
@@ skipping 78 matching lines @@
 bool ApplyStyleCommand::shouldApplyInlineStyleToRun(EditingStyle* style,
                                                     Node* runStart,
                                                     Node* pastEndNode) {
   DCHECK(style);
   DCHECK(runStart);
 
   for (Node* node = runStart; node && node != pastEndNode;
        node = NodeTraversal::next(*node)) {
     if (node->hasChildren())
       continue;
-    // We don't consider m_isInlineElementToRemoveFunction here because we never apply style when m_isInlineElementToRemoveFunction is specified
+    // We don't consider m_isInlineElementToRemoveFunction here because we never
+    // apply style when m_isInlineElementToRemoveFunction is specified
     if (!style->styleIsPresentInComputedStyleOfNode(node))
       return true;
     if (m_styledInlineElement &&
         !enclosingElementWithTag(Position::beforeNode(node),
                                  m_styledInlineElement->tagQName()))
       return true;
   }
   return false;
 }
 
@@ skipping 18 matching lines @@
       continue;
 
     HTMLElement& element = toHTMLElement(*node);
     Node* previousSibling = element.previousSibling();
     Node* nextSibling = element.nextSibling();
     ContainerNode* parent = element.parentNode();
     removeInlineStyleFromElement(style, &element, editingState, RemoveAlways);
     if (editingState->isAborted())
       return;
     if (!element.isConnected()) {
-      // FIXME: We might need to update the start and the end of current selection here but need a test.
+      // FIXME: We might need to update the start and the end of current
+      // selection here but need a test.
       if (runStart == element)
         runStart = previousSibling ? previousSibling->nextSibling()
                                    : parent->firstChild();
       if (runEnd == element)
         runEnd =
             nextSibling ? nextSibling->previousSibling() : parent->lastChild();
     }
   }
 }
 
@@ skipping 64 matching lines @@
   if (style->conflictsWithImplicitStyleOfElement(
           element, extractedStyle,
           mode == RemoveAlways ? EditingStyle::ExtractMatchingStyle
                                : EditingStyle::DoNotExtractMatchingStyle)) {
     replaceWithSpanOrRemoveIfWithoutAttributes(element, editingState);
     if (editingState->isAborted())
       return false;
     return true;
   }
 
-  // unicode-bidi and direction are pushed down separately so don't push down with other styles
+  // unicode-bidi and direction are pushed down separately so don't push down
+  // with other styles
   Vector<QualifiedName> attributes;
   if (!style->extractConflictingImplicitStyleOfAttributes(
           element, extractedStyle ? EditingStyle::PreserveWritingDirection
                                   : EditingStyle::DoNotPreserveWritingDirection,
           extractedStyle, attributes,
           mode == RemoveAlways ? EditingStyle::ExtractMatchingStyle
                                : EditingStyle::DoNotExtractMatchingStyle))
     return false;
 
   for (const auto& attribute : attributes)
@@ skipping 18 matching lines @@
   DCHECK(element);
 
   if (mode == RemoveNone)
     return style->conflictsWithInlineStyleOfElement(element);
 
   Vector<CSSPropertyID> properties;
   if (!style->conflictsWithInlineStyleOfElement(element, extractedStyle,
                                                 properties))
     return false;
 
-  // FIXME: We should use a mass-removal function here but we don't have an undoable one yet.
+  // FIXME: We should use a mass-removal function here but we don't have an
+  // undoable one yet.
   for (const auto& property : properties)
     removeCSSProperty(element, property);
 
   if (isSpanWithoutAttributesOrUnstyledStyleSpan(element))
     removeNodePreservingChildren(element, editingState);
 
   return true;
 }
 
 // Finds the enclosing element until which the tree can be split.
 // When a user hits ENTER, they won't expect this element to be split into two.
 // You may pass it as the second argument of splitTreeToNode.
 static Element* unsplittableElementForPosition(const Position& p) {
-  // Since enclosingNodeOfType won't search beyond the highest root editable node,
-  // this code works even if the closest table cell was outside of the root editable node.
+  // Since enclosingNodeOfType won't search beyond the highest root editable
+  // node, this code works even if the closest table cell was outside of the
+  // root editable node.
   Element* enclosingCell = toElement(enclosingNodeOfType(p, &isTableCell));
   if (enclosingCell)
     return enclosingCell;
 
   return rootEditableElementOf(p);
 }
 
 HTMLElement* ApplyStyleCommand::highestAncestorWithConflictingInlineStyle(
     EditingStyle* style,
     Node* node) {
@@ skipping 28 matching lines @@
       isHTMLIFrameElement(*node))
     return;
 
   EditingStyle* newInlineStyle = style;
   if (node->isHTMLElement() && toHTMLElement(node)->inlineStyle()) {
     newInlineStyle = style->copy();
     newInlineStyle->mergeInlineStyleOfElement(toHTMLElement(node),
                                               EditingStyle::OverrideValues);
   }
 
-  // Since addInlineStyleIfNeeded can't add styles to block-flow layout objects, add style attribute instead.
+  // Since addInlineStyleIfNeeded can't add styles to block-flow layout objects,
+  // add style attribute instead.
   // FIXME: applyInlineStyleToRange should be used here instead.
   if ((node->layoutObject()->isLayoutBlockFlow() || node->hasChildren()) &&
       node->isHTMLElement()) {
     setNodeAttribute(toHTMLElement(node), styleAttr,
                      AtomicString(newInlineStyle->style()->asText()));
     return;
   }
 
   if (node->layoutObject()->isText() &&
       toLayoutText(node->layoutObject())->isAllCollapsibleWhitespace())
     return;
 
-  // We can't wrap node with the styled element here because new styled element will never be removed if we did.
-  // If we modified the child pointer in pushDownInlineStyleAroundNode to point to new style element
-  // then we fall into an infinite loop where we keep removing and adding styled element wrapping node.
+  // We can't wrap node with the styled element here because new styled element
+  // will never be removed if we did. If we modified the child pointer in
+  // pushDownInlineStyleAroundNode to point to new style element then we fall
+  // into an infinite loop where we keep removing and adding styled element
+  // wrapping node.
   addInlineStyleIfNeeded(newInlineStyle, node, node, editingState);
 }
 
 void ApplyStyleCommand::pushDownInlineStyleAroundNode(
     EditingStyle* style,
     Node* targetNode,
     EditingState* editingState) {
   HTMLElement* highestAncestor =
       highestAncestorWithConflictingInlineStyle(style, targetNode);
   if (!highestAncestor)
     return;
 
-  // The outer loop is traversing the tree vertically from highestAncestor to targetNode
+  // The outer loop is traversing the tree vertically from highestAncestor to
+  // targetNode
   Node* current = highestAncestor;
-  // Along the way, styled elements that contain targetNode are removed and accumulated into elementsToPushDown.
-  // Each child of the removed element, exclusing ancestors of targetNode, is then wrapped by clones of elements in elementsToPushDown.
+  // Along the way, styled elements that contain targetNode are removed and
+  // accumulated into elementsToPushDown. Each child of the removed element,
+  // exclusing ancestors of targetNode, is then wrapped by clones of elements in
+  // elementsToPushDown.
   HeapVector<Member<Element>> elementsToPushDown;
   while (current && current != targetNode && current->contains(targetNode)) {
     NodeVector currentChildren;
     getChildNodes(toContainerNode(*current), currentChildren);
     Element* styledElement = nullptr;
     if (current->isStyledElement() &&
         isStyledInlineElementToRemove(toElement(current))) {
       styledElement = toElement(current);
       elementsToPushDown.append(styledElement);
     }
 
     EditingStyle* styleToPushDown = EditingStyle::create();
     if (current->isHTMLElement()) {
       removeInlineStyleFromElement(style, toHTMLElement(current), editingState,
                                    RemoveIfNeeded, styleToPushDown);
       if (editingState->isAborted())
         return;
     }
 
     // The inner loop will go through children on each level
-    // FIXME: we should aggregate inline child elements together so that we don't wrap each child separately.
+    // FIXME: we should aggregate inline child elements together so that we
+    // don't wrap each child separately.
     for (const auto& currentChild : currentChildren) {
       Node* child = currentChild;
       if (!child->parentNode())
         continue;
       if (!child->contains(targetNode) && elementsToPushDown.size()) {
         for (const auto& element : elementsToPushDown) {
           Element* wrapper = element->cloneElementWithoutChildren();
           wrapper->removeAttribute(styleAttr);
-          // Delete id attribute from the second element because the same id cannot be used for more than one element
+          // Delete id attribute from the second element because the same id
+          // cannot be used for more than one element
           element->removeAttribute(HTMLNames::idAttr);
           if (isHTMLAnchorElement(element))
             element->removeAttribute(HTMLNames::nameAttr);
           surroundNodeRangeWithElement(child, child, wrapper, editingState);
           if (editingState->isAborted())
             return;
         }
       }
 
-      // Apply style to all nodes containing targetNode and their siblings but NOT to targetNode
-      // But if we've removed styledElement then go ahead and always apply the style.
+      // Apply style to all nodes containing targetNode and their siblings but
+      // NOT to targetNode But if we've removed styledElement then go ahead and
+      // always apply the style.
       if (child != targetNode || styledElement) {
         applyInlineStyleToPushDown(child, styleToPushDown, editingState);
         if (editingState->isAborted())
           return;
       }
 
       // We found the next node for the outer loop (contains targetNode)
-      // When reached targetNode, stop the outer loop upon the completion of the current inner loop
+      // When reached targetNode, stop the outer loop upon the completion of the
+      // current inner loop
       if (child == targetNode || child->contains(targetNode))
         current = child;
     }
   }
 }
 
 void ApplyStyleCommand::removeInlineStyle(EditingStyle* style,
                                           const Position& start,
                                           const Position& end,
                                           EditingState* editingState) {
   DCHECK(start.isNotNull());
   DCHECK(end.isNotNull());
   DCHECK(start.isConnected()) << start;
   DCHECK(end.isConnected()) << end;
   DCHECK(Position::commonAncestorTreeScope(start, end)) << start << " " << end;
   DCHECK_LE(start, end);
-  // FIXME: We should assert that start/end are not in the middle of a text node.
+  // FIXME: We should assert that start/end are not in the middle of a text
+  // node.
 
   Position pushDownStart = mostForwardCaretPosition(start);
-  // If the pushDownStart is at the end of a text node, then this node is not fully selected.
-  // Move it to the next deep quivalent position to avoid removing the style from this node.
-  // e.g. if pushDownStart was at Position("hello", 5) in <b>hello<div>world</div></b>, we want Position("world", 0) instead.
+  // If the pushDownStart is at the end of a text node, then this node is not
+  // fully selected. Move it to the next deep quivalent position to avoid
+  // removing the style from this node. e.g. if pushDownStart was at
+  // Position("hello", 5) in <b>hello<div>world</div></b>, we want
+  // Position("world", 0) instead.
   Node* pushDownStartContainer = pushDownStart.computeContainerNode();
   if (pushDownStartContainer && pushDownStartContainer->isTextNode() &&
       pushDownStart.computeOffsetInContainerNode() ==
           pushDownStartContainer->maxCharacterOffset())
     pushDownStart = nextVisuallyDistinctCandidate(pushDownStart);
   Position pushDownEnd = mostBackwardCaretPosition(end);
-  // If pushDownEnd is at the start of a text node, then this node is not fully selected.
-  // Move it to the previous deep equivalent position to avoid removing the style from this node.
+  // If pushDownEnd is at the start of a text node, then this node is not fully
+  // selected. Move it to the previous deep equivalent position to avoid
+  // removing the style from this node.
   Node* pushDownEndContainer = pushDownEnd.computeContainerNode();
   if (pushDownEndContainer && pushDownEndContainer->isTextNode() &&
       !pushDownEnd.computeOffsetInContainerNode())
     pushDownEnd = previousVisuallyDistinctCandidate(pushDownEnd);
 
   pushDownInlineStyleAroundNode(style, pushDownStart.anchorNode(),
                                 editingState);
   if (editingState->isAborted())
     return;
   pushDownInlineStyleAroundNode(style, pushDownEnd.anchorNode(), editingState);
   if (editingState->isAborted())
     return;
 
-  // The s and e variables store the positions used to set the ending selection after style removal
-  // takes place. This will help callers to recognize when either the start node or the end node
-  // are removed from the document during the work of this function.
-  // If pushDownInlineStyleAroundNode has pruned start.anchorNode() or end.anchorNode(),
-  // use pushDownStart or pushDownEnd instead, which pushDownInlineStyleAroundNode won't prune.
+  // The s and e variables store the positions used to set the ending selection
+  // after style removal takes place. This will help callers to recognize when
+  // either the start node or the end node are removed from the document during
+  // the work of this function.
+  // If pushDownInlineStyleAroundNode has pruned start.anchorNode() or
+  // end.anchorNode(), use pushDownStart or pushDownEnd instead, which
+  // pushDownInlineStyleAroundNode won't prune.
   Position s = start.isNull() || start.isOrphan() ? pushDownStart : start;
   Position e = end.isNull() || end.isOrphan() ? pushDownEnd : end;
 
   // Current ending selection resetting algorithm assumes |start| and |end|
   // are in a same DOM tree even if they are not in document.
   if (!Position::commonAncestorTreeScope(start, end))
     return;
 
   Node* node = start.anchorNode();
   while (node) {
@@ skipping 54 matching lines @@
       break;
     node = next;
   }
 
   updateStartEnd(s, e);
 }
 
 bool ApplyStyleCommand::elementFullySelected(HTMLElement& element,
                                              const Position& start,
                                              const Position& end) const {
-  // The tree may have changed and Position::upstream() relies on an up-to-date layout.
+  // The tree may have changed and Position::upstream() relies on an up-to-date
+  // layout.
   element.document().updateStyleAndLayoutIgnorePendingStylesheets();
 
   return comparePositions(firstPositionInOrBeforeNode(&element), start) >= 0 &&
          comparePositions(
              mostBackwardCaretPosition(lastPositionInOrAfterNode(&element)),
              end) <= 0;
 }
 
 void ApplyStyleCommand::splitTextAtStart(const Position& start,
                                          const Position& end) {
@@ skipping 228 matching lines @@
     if (mergedElement->isElementNode() && hasEditableStyle(*mergedElement) &&
         areIdenticalElements(toElement(*previousSibling),
                              toElement(*mergedElement))) {
       mergeIdenticalElements(toElement(previousSibling),
                              toElement(mergedElement), editingState);
       if (editingState->isAborted())
         return;
     }
   }
 
-  // FIXME: We should probably call updateStartEnd if the start or end was in the node
-  // range so that the endingSelection() is canonicalized.  See the comments at the end of
-  // VisibleSelection::validate().
+  // FIXME: We should probably call updateStartEnd if the start or end was in
+  // the node range so that the endingSelection() is canonicalized.  See the
+  // comments at the end of VisibleSelection::validate().
 }
 
 void ApplyStyleCommand::addBlockStyle(const StyleChange& styleChange,
                                       HTMLElement* block) {
-  // Do not check for legacy styles here. Those styles, like <B> and <I>, only apply for
-  // inline content.
+  // Do not check for legacy styles here. Those styles, like <B> and <I>, only
+  // apply for inline content.
   if (!block)
     return;
 
   String cssStyle = styleChange.cssStyle();
   StringBuilder cssText;
   cssText.append(cssStyle);
   if (const StylePropertySet* decl = block->inlineStyle()) {
     if (!cssStyle.isEmpty())
       cssText.append(' ');
     cssText.append(decl->asText());
@@ skipping 23 matching lines @@
   }
 
   applyInlineStyleChange(start, passedEnd, styleChange, DoNotAddStyledElement,
                          editingState);
 }
 
 Position ApplyStyleCommand::positionToComputeInlineStyleChange(
     Node* startNode,
     Member<HTMLSpanElement>& dummyElement,
     EditingState* editingState) {
-  // It's okay to obtain the style at the startNode because we've removed all relevant styles from the current run.
+  // It's okay to obtain the style at the startNode because we've removed all
+  // relevant styles from the current run.
   if (!startNode->isElementNode()) {
     dummyElement = HTMLSpanElement::create(document());
     insertNodeAt(dummyElement, Position::beforeNode(startNode), editingState);
     if (editingState->isAborted())
       return Position();
     return Position::beforeNode(dummyElement);
   }
 
   return firstPositionInOrBeforeNode(startNode);
 }
@@ skipping 22 matching lines @@
       if (isHTMLSpanElement(*containerElement) ||
           (styleContainerIsNotSpan && containerElement->hasChildren()))
         styleContainer = toHTMLElement(container);
     }
     if (!container->hasChildren())
       break;
     startNode = container->firstChild();
     endNode = container->lastChild();
   }
 
-  // Font tags need to go outside of CSS so that CSS font sizes override leagcy font sizes.
+  // Font tags need to go outside of CSS so that CSS font sizes override leagcy
+  // font sizes.
   if (styleChange.applyFontColor() || styleChange.applyFontFace() ||
       styleChange.applyFontSize()) {
     if (fontContainer) {
       if (styleChange.applyFontColor())
         setNodeAttribute(fontContainer, colorAttr,
                          AtomicString(styleChange.fontColor()));
       if (styleChange.applyFontFace())
         setNodeAttribute(fontContainer, faceAttr,
                          AtomicString(styleChange.fontFace()));
       if (styleChange.applyFontSize())
@@ skipping 156 matching lines @@
 
 DEFINE_TRACE(ApplyStyleCommand) {
   visitor->trace(m_style);
   visitor->trace(m_start);
   visitor->trace(m_end);
   visitor->trace(m_styledInlineElement);
   CompositeEditCommand::trace(visitor);
 }
 
 }  // namespace blink