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

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

 /*
  * Copyright (C) 2005, 2006, 2007, 2008 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 92 matching lines @@
 bool EditCommandComposition::belongsTo(const LocalFrame& frame) const {
   DCHECK(m_document);
   return m_document->frame() == &frame;
 }
 
 void EditCommandComposition::unapply() {
   DCHECK(m_document);
   LocalFrame* frame = m_document->frame();
   DCHECK(frame);
 
-  // Changes to the document may have been made since the last editing operation that require a layout, as in <rdar://problem/5658603>.
-  // Low level operations, like RemoveNodeCommand, don't require a layout because the high level operations that use them perform one
-  // if one is necessary (like for the creation of VisiblePositions).
+  // Changes to the document may have been made since the last editing operation
+  // that require a layout, as in <rdar://problem/5658603>. Low level
+  // operations, like RemoveNodeCommand, don't require a layout because the high
+  // level operations that use them perform one if one is necessary (like for
+  // the creation of VisiblePositions).
   m_document->updateStyleAndLayoutIgnorePendingStylesheets();
 
   {
     size_t size = m_commands.size();
     for (size_t i = size; i; --i)
       m_commands[i - 1]->doUnapply();
   }
 
   frame->editor().unappliedEditing(this);
 }
 
 void EditCommandComposition::reapply() {
   DCHECK(m_document);
   LocalFrame* frame = m_document->frame();
   DCHECK(frame);
 
-  // Changes to the document may have been made since the last editing operation that require a layout, as in <rdar://problem/5658603>.
-  // Low level operations, like RemoveNodeCommand, don't require a layout because the high level operations that use them perform one
-  // if one is necessary (like for the creation of VisiblePositions).
+  // Changes to the document may have been made since the last editing operation
+  // that require a layout, as in <rdar://problem/5658603>. Low level
+  // operations, like RemoveNodeCommand, don't require a layout because the high
+  // level operations that use them perform one if one is necessary (like for
+  // the creation of VisiblePositions).
   m_document->updateStyleAndLayoutIgnorePendingStylesheets();
 
   {
     for (const auto& command : m_commands)
       command->doReapply();
   }
 
   frame->editor().reappliedEditing(this);
 }
 
@@ skipping 60 matching lines @@
       case InputEvent::InputType::SetWritingDirection:
       case InputEvent::InputType::None:
         break;
       default:
         NOTREACHED();
         return false;
     }
   }
   ensureComposition();
 
-  // Changes to the document may have been made since the last editing operation that require a layout, as in <rdar://problem/5658603>.
-  // Low level operations, like RemoveNodeCommand, don't require a layout because the high level operations that use them perform one
-  // if one is necessary (like for the creation of VisiblePositions).
+  // Changes to the document may have been made since the last editing operation
+  // that require a layout, as in <rdar://problem/5658603>. Low level
+  // operations, like RemoveNodeCommand, don't require a layout because the high
+  // level operations that use them perform one if one is necessary (like for
+  // the creation of VisiblePositions).
   document().updateStyleAndLayoutIgnorePendingStylesheets();
 
   LocalFrame* frame = document().frame();
   DCHECK(frame);
   EditingState editingState;
   {
     EventQueueScope eventQueueScope;
     doApply(&editingState);
   }
 
-  // Only need to call appliedEditing for top-level commands,
-  // and TypingCommands do it on their own (see TypingCommand::typingAddedToOpenCommand).
+  // Only need to call appliedEditing for top-level commands, and TypingCommands
+  // do it on their own (see TypingCommand::typingAddedToOpenCommand).
   if (!isTypingCommand())
     frame->editor().appliedEditing(this);
   setShouldRetainAutocorrectionIndicator(false);
   return !editingState.isAborted();
 }
 
 EditCommandComposition* CompositeEditCommand::ensureComposition() {
   CompositeEditCommand* command = this;
   while (command && command->parent())
     command = command->parent();
@@ skipping 19 matching lines @@
   return false;
 }
 
 bool CompositeEditCommand::isReplaceSelectionCommand() const {
   return false;
 }
 
 void CompositeEditCommand::setShouldRetainAutocorrectionIndicator(bool) {}
 
 //
-// sugary-sweet convenience functions to help create and apply edit commands in composite commands
+// sugary-sweet convenience functions to help create and apply edit commands in
+// composite commands
 //
 void CompositeEditCommand::applyCommandToComposite(EditCommand* command,
                                                    EditingState* editingState) {
   command->setParent(this);
   command->doApply(editingState);
   if (editingState->isAborted()) {
     command->setParent(nullptr);
     return;
   }
   if (command->isSimpleEditCommand()) {
@@ skipping 127 matching lines @@
       child = child->nextSibling();
     if (child)
       insertNodeBefore(insertChild, child, editingState);
     else
       appendNode(insertChild, toContainerNode(refChild), editingState);
   } else if (caretMinOffset(refChild) >= offset) {
     insertNodeBefore(insertChild, refChild, editingState);
   } else if (refChild->isTextNode() && caretMaxOffset(refChild) > offset) {
     splitTextNode(toText(refChild), offset);
 
-    // Mutation events (bug 22634) from the text node insertion may have removed the refChild
+    // Mutation events (bug 22634) from the text node insertion may have removed
+    // the refChild
     if (!refChild->isConnected())
       return;
     insertNodeBefore(insertChild, refChild, editingState);
   } else {
     insertNodeAfter(insertChild, refChild, editingState);
   }
 }
 
 void CompositeEditCommand::appendNode(Node* node,
                                       ContainerNode* parent,
@@ skipping 371 matching lines @@
   if (textNode->length() == 0)
     return false;
 
   LayoutText* layoutText = textNode->layoutObject();
   if (layoutText && !layoutText->style()->collapseWhiteSpace())
     return false;
 
   return true;
 }
 
-// FIXME: Doesn't go into text nodes that contribute adjacent text (siblings, cousins, etc).
+// FIXME: Doesn't go into text nodes that contribute adjacent text (siblings,
+// cousins, etc).
 void CompositeEditCommand::rebalanceWhitespaceAt(const Position& position) {
   Node* node = position.computeContainerNode();
   if (!canRebalance(position))
     return;
 
-  // If the rebalance is for the single offset, and neither text[offset] nor text[offset - 1] are some form of whitespace, do nothing.
+  // If the rebalance is for the single offset, and neither text[offset] nor
+  // text[offset - 1] are some form of whitespace, do nothing.
   int offset = position.computeOffsetInContainerNode();
   String text = toText(node)->data();
   if (!isWhitespace(text[offset])) {
     offset--;
     if (offset < 0 || !isWhitespace(text[offset]))
       return;
   }
 
   rebalanceWhitespaceOnTextSubstring(toText(node),
                                      position.offsetInContainerNode(),
                                      position.offsetInContainerNode());
 }
 
 void CompositeEditCommand::rebalanceWhitespaceOnTextSubstring(Text* textNode,
                                                               int startOffset,
                                                               int endOffset) {
   String text = textNode->data();
   DCHECK(!text.isEmpty());
 
-  // Set upstream and downstream to define the extent of the whitespace surrounding text[offset].
+  // Set upstream and downstream to define the extent of the whitespace
+  // surrounding text[offset].
   int upstream = startOffset;
   while (upstream > 0 && isWhitespace(text[upstream - 1]))
     upstream--;
 
   int downstream = endOffset;
   while ((unsigned)downstream < text.length() && isWhitespace(text[downstream]))
     downstream++;
 
   int length = downstream - upstream;
   if (!length)
@@ skipping 203 matching lines @@
 }
 
 HTMLBRElement* CompositeEditCommand::appendBlockPlaceholder(
     Element* container,
     EditingState* editingState) {
   if (!container)
     return nullptr;
 
   document().updateStyleAndLayoutIgnorePendingStylesheets();
 
-  // Should assert isLayoutBlockFlow || isInlineFlow when deletion improves. See 4244964.
+  // Should assert isLayoutBlockFlow || isInlineFlow when deletion improves. See
+  // 4244964.
   DCHECK(container->layoutObject()) << container;
 
   HTMLBRElement* placeholder = HTMLBRElement::create(document());
   appendNode(placeholder, container, editingState);
   if (editingState->isAborted())
     return nullptr;
   return placeholder;
 }
 
 HTMLBRElement* CompositeEditCommand::insertBlockPlaceholder(
     const Position& pos,
     EditingState* editingState) {
   if (pos.isNull())
     return nullptr;
 
-  // Should assert isLayoutBlockFlow || isInlineFlow when deletion improves. See 4244964.
+  // Should assert isLayoutBlockFlow || isInlineFlow when deletion improves. See
+  // 4244964.
   DCHECK(pos.anchorNode()->layoutObject()) << pos;
 
   HTMLBRElement* placeholder = HTMLBRElement::create(document());
   insertNodeAt(placeholder, pos, editingState);
   if (editingState->isAborted())
     return nullptr;
   return placeholder;
 }
 
 HTMLBRElement* CompositeEditCommand::addBlockPlaceholderIfNeeded(
@@ skipping 11 matching lines @@
   // append the placeholder to make sure it follows
   // any unrendered blocks
   LayoutBlockFlow* block = toLayoutBlockFlow(layoutObject);
   if (block->size().height() == 0 ||
       (block->isListItem() && toLayoutListItem(block)->isEmpty()))
     return appendBlockPlaceholder(container, editingState);
 
   return nullptr;
 }
 
-// Assumes that the position is at a placeholder and does the removal without much checking.
+// Assumes that the position is at a placeholder and does the removal without
+// much checking.
 void CompositeEditCommand::removePlaceholderAt(const Position& p) {
   DCHECK(lineBreakExistsAtPosition(p)) << p;
 
-  // We are certain that the position is at a line break, but it may be a br or a preserved newline.
+  // We are certain that the position is at a line break, but it may be a br or
+  // a preserved newline.
   if (isHTMLBRElement(*p.anchorNode())) {
     // Removing a BR element won't dispatch synchronous events.
     removeNode(p.anchorNode(), ASSERT_NO_EDITING_ABORT);
     return;
   }
 
   deleteTextFromNode(toText(p.anchorNode()), p.offsetInContainerNode(), 1);
 }
 
 HTMLElement* CompositeEditCommand::insertNewDefaultParagraphElementAt(
     const Position& position,
     EditingState* editingState) {
   HTMLElement* paragraphElement = createDefaultParagraphElement(document());
   paragraphElement->appendChild(HTMLBRElement::create(document()));
   insertNodeAt(paragraphElement, position, editingState);
   if (editingState->isAborted())
     return nullptr;
   return paragraphElement;
 }
 
-// If the paragraph is not entirely within it's own block, create one and move the paragraph into
-// it, and return that block.  Otherwise return 0.
+// If the paragraph is not entirely within it's own block, create one and move
+// the paragraph into it, and return that block.  Otherwise return 0.
 HTMLElement* CompositeEditCommand::moveParagraphContentsToNewBlockIfNecessary(
     const Position& pos,
     EditingState* editingState) {
   DCHECK(isEditablePosition(pos)) << pos;
 
-  // It's strange that this function is responsible for verifying that pos has not been invalidated
-  // by an earlier call to this function.  The caller, applyBlockStyle, should do this.
+  // It's strange that this function is responsible for verifying that pos has
+  // not been invalidated by an earlier call to this function.  The caller,
+  // applyBlockStyle, should do this.
   VisiblePosition visiblePos =
       createVisiblePositionDeprecated(pos, VP_DEFAULT_AFFINITY);
   VisiblePosition visibleParagraphStart =
       startOfParagraphDeprecated(visiblePos);
   VisiblePosition visibleParagraphEnd = endOfParagraphDeprecated(visiblePos);
   VisiblePosition next = nextPositionOf(visibleParagraphEnd);
   VisiblePosition visibleEnd = next.isNotNull() ? next : visibleParagraphEnd;
 
   Position upstreamStart =
       mostBackwardCaretPosition(visibleParagraphStart.deepEquivalent());
   Position upstreamEnd = mostBackwardCaretPosition(visibleEnd.deepEquivalent());
 
   // If there are no VisiblePositions in the same block as pos then
   // upstreamStart will be outside the paragraph
   if (comparePositions(pos, upstreamStart) < 0)
     return nullptr;
 
   // Perform some checks to see if we need to perform work in this function.
   if (isEnclosingBlock(upstreamStart.anchorNode())) {
-    // If the block is the root editable element, always move content to a new block,
-    // since it is illegal to modify attributes on the root editable element for editing.
+    // If the block is the root editable element, always move content to a new
+    // block, since it is illegal to modify attributes on the root editable
+    // element for editing.
     if (upstreamStart.anchorNode() == rootEditableElementOf(upstreamStart)) {
-      // If the block is the root editable element and it contains no visible content, create a new
-      // block but don't try and move content into it, since there's nothing for moveParagraphs to move.
+      // If the block is the root editable element and it contains no visible
+      // content, create a new block but don't try and move content into it,
+      // since there's nothing for moveParagraphs to move.
       if (!hasRenderedNonAnonymousDescendantsWithHeight(
               upstreamStart.anchorNode()->layoutObject()))
         return insertNewDefaultParagraphElementAt(upstreamStart, editingState);
     } else if (isEnclosingBlock(upstreamEnd.anchorNode())) {
       if (!upstreamEnd.anchorNode()->isDescendantOf(
               upstreamStart.anchorNode())) {
-        // If the paragraph end is a descendant of paragraph start, then we need to run
-        // the rest of this function. If not, we can bail here.
+        // If the paragraph end is a descendant of paragraph start, then we need
+        // to run the rest of this function. If not, we can bail here.
         return nullptr;
       }
     } else if (enclosingBlock(upstreamEnd.anchorNode()) !=
                upstreamStart.anchorNode()) {
       // It should be an ancestor of the paragraph start.
       // We can bail as we have a full block to work with.
       return nullptr;
     } else if (isEndOfEditableOrNonEditableContent(visibleEnd)) {
       // At the end of the editable region. We can bail here as well.
       return nullptr;
@@ skipping 114 matching lines @@
       outerNode = outerNode->parentNode();
     }
 
     if (!outerNode)
       return;
 
     Node* startNode = start.anchorNode();
     for (Node* node =
              NodeTraversal::nextSkippingChildren(*startNode, outerNode);
          node; node = NodeTraversal::nextSkippingChildren(*node, outerNode)) {
-      // Move lastNode up in the tree as much as node was moved up in the
-      // tree by NodeTraversal::nextSkippingChildren, so that the relative depth between
-      // node and the original start node is maintained in the clone.
+      // Move lastNode up in the tree as much as node was moved up in the tree
+      // by NodeTraversal::nextSkippingChildren, so that the relative depth
+      // between node and the original start node is maintained in the clone.
       while (startNode && lastNode &&
              startNode->parentNode() != node->parentNode()) {
         startNode = startNode->parentNode();
         lastNode = lastNode->parentNode();
       }
 
       if (!lastNode || !lastNode->parentNode())
         return;
 
       Node* clonedNode = node->cloneNode(true);
@@ skipping 51 matching lines @@
       Text* textNode = toText(node);
       if (textNode->length() == 1)
         removeNodeAndPruneAncestors(node, editingState, destinationNode);
       else
         deleteTextFromNode(textNode, position.computeOffsetInContainerNode(),
                            1);
     }
   }
 }
 
-// This is a version of moveParagraph that preserves style by keeping the original markup
-// It is currently used only by IndentOutdentCommand but it is meant to be used in the
-// future by several other commands such as InsertList and the align commands.
-// The blockElement parameter is the element to move the paragraph to,
-// outerNode is the top element of the paragraph hierarchy.
+// This is a version of moveParagraph that preserves style by keeping the
+// original markup. It is currently used only by IndentOutdentCommand but it is
+// meant to be used in the future by several other commands such as InsertList
+// and the align commands.
+// The blockElement parameter is the element to move the paragraph to, outerNode
+// is the top element of the paragraph hierarchy.
 
 void CompositeEditCommand::moveParagraphWithClones(
     const VisiblePosition& startOfParagraphToMove,
     const VisiblePosition& endOfParagraphToMove,
     HTMLElement* blockElement,
     Node* outerNode,
     EditingState* editingState) {
   DCHECK(outerNode);
   DCHECK(blockElement);
 
   VisiblePosition beforeParagraph = previousPositionOf(startOfParagraphToMove);
   VisiblePosition afterParagraph = nextPositionOf(endOfParagraphToMove);
 
-  // We upstream() the end and downstream() the start so that we don't include collapsed whitespace in the move.
-  // When we paste a fragment, spaces after the end and before the start are treated as though they were rendered.
+  // We upstream() the end and downstream() the start so that we don't include
+  // collapsed whitespace in the move. When we paste a fragment, spaces after
+  // the end and before the start are treated as though they were rendered.
   Position start =
       mostForwardCaretPosition(startOfParagraphToMove.deepEquivalent());
   Position end =
       startOfParagraphToMove.deepEquivalent() ==
               endOfParagraphToMove.deepEquivalent()
           ? start
           : mostBackwardCaretPosition(endOfParagraphToMove.deepEquivalent());
   if (comparePositions(start, end) > 0)
     end = start;
 
   cloneParagraphUnderNewElement(start, end, outerNode, blockElement,
                                 editingState);
 
   setEndingSelection(createVisibleSelectionDeprecated(start, end));
   deleteSelection(editingState, false, false, false);
   if (editingState->isAborted())
     return;
 
   // There are bugs in deletion when it removes a fully selected table/list.
   // It expands and removes the entire table/list, but will let content
   // before and after the table/list collapse onto one line.
 
   cleanupAfterDeletion(editingState);
   if (editingState->isAborted())
     return;
 
-  // Add a br if pruning an empty block level element caused a collapse.  For example:
+  // Add a br if pruning an empty block level element caused a collapse.  For
+  // example:
   // foo^
   // <div>bar</div>
   // baz
-  // Imagine moving 'bar' to ^.  'bar' will be deleted and its div pruned.  That would
-  // cause 'baz' to collapse onto the line with 'foobar' unless we insert a br.
-  // Must recononicalize these two VisiblePositions after the pruning above.
+  // Imagine moving 'bar' to ^.  'bar' will be deleted and its div pruned.  That
+  // would cause 'baz' to collapse onto the line with 'foobar' unless we insert
+  // a br. Must recononicalize these two VisiblePositions after the pruning
+  // above.
   // TODO(yosin): We should abort when |beforeParagraph| is a orphan when
   // we have a sample.
   beforeParagraph =
       createVisiblePositionDeprecated(beforeParagraph.deepEquivalent());
   if (afterParagraph.isOrphan()) {
     editingState->abort();
     return;
   }
   afterParagraph =
       createVisiblePositionDeprecated(afterParagraph.deepEquivalent());
 
   if (beforeParagraph.isNotNull() &&
       !isDisplayInsideTable(beforeParagraph.deepEquivalent().anchorNode()) &&
       ((!isEndOfParagraphDeprecated(beforeParagraph) &&
         !isStartOfParagraphDeprecated(beforeParagraph)) ||
        beforeParagraph.deepEquivalent() == afterParagraph.deepEquivalent())) {
-    // FIXME: Trim text between beforeParagraph and afterParagraph if they aren't equal.
+    // FIXME: Trim text between beforeParagraph and afterParagraph if they
+    // aren't equal.
     insertNodeAt(HTMLBRElement::create(document()),
                  beforeParagraph.deepEquivalent(), editingState);
   }
 }
 
 void CompositeEditCommand::moveParagraph(
     const VisiblePosition& startOfParagraphToMove,
     const VisiblePosition& endOfParagraphToMove,
     const VisiblePosition& destination,
     EditingState* editingState,
@@ skipping 59 matching lines @@
   }
 
   RelocatablePosition beforeParagraphPosition(
       previousPositionOfDeprecated(startOfParagraphToMove,
                                    CannotCrossEditingBoundary)
           .deepEquivalent());
   RelocatablePosition afterParagraphPosition(
       nextPositionOfDeprecated(endOfParagraphToMove, CannotCrossEditingBoundary)
           .deepEquivalent());
 
-  // We upstream() the end and downstream() the start so that we don't include collapsed whitespace in the move.
-  // When we paste a fragment, spaces after the end and before the start are treated as though they were rendered.
+  // We upstream() the end and downstream() the start so that we don't include
+  // collapsed whitespace in the move. When we paste a fragment, spaces after
+  // the end and before the start are treated as though they were rendered.
   Position start =
       mostForwardCaretPosition(startOfParagraphToMove.deepEquivalent());
   Position end =
       mostBackwardCaretPosition(endOfParagraphToMove.deepEquivalent());
 
-  // FIXME: This is an inefficient way to preserve style on nodes in the paragraph to move. It
-  // shouldn't matter though, since moved paragraphs will usually be quite small.
+  // FIXME: This is an inefficient way to preserve style on nodes in the
+  // paragraph to move. It shouldn't matter though, since moved paragraphs will
+  // usually be quite small.
   DocumentFragment* fragment =
       startOfParagraphToMove.deepEquivalent() !=
               endOfParagraphToMove.deepEquivalent()
           ? createFragmentFromMarkup(
                 document(),
                 createMarkup(start.parentAnchoredEquivalent(),
                              end.parentAnchoredEquivalent(),
                              DoNotAnnotateForInterchange,
                              ConvertBlocksToInlines::Convert, DoNotResolveURLs,
                              constrainingAncestor),
                 "")
           : nullptr;
 
-  // A non-empty paragraph's style is moved when we copy and move it.  We don't move
-  // anything if we're given an empty paragraph, but an empty paragraph can have style
-  // too, <div><b><br></b></div> for example.  Save it so that we can preserve it later.
+  // A non-empty paragraph's style is moved when we copy and move it.  We don't
+  // move anything if we're given an empty paragraph, but an empty paragraph can
+  // have style too, <div><b><br></b></div> for example.  Save it so that we can
+  // preserve it later.
   EditingStyle* styleInEmptyParagraph = nullptr;
   if (startOfParagraphToMove.deepEquivalent() ==
           endOfParagraphToMove.deepEquivalent() &&
       shouldPreserveStyle == PreserveStyle) {
     styleInEmptyParagraph =
         EditingStyle::create(startOfParagraphToMove.deepEquivalent());
     styleInEmptyParagraph->mergeTypingStyle(&document());
     // The moved paragraph should assume the block style of the destination.
     styleInEmptyParagraph->removeBlockProperties();
   }
 
-  // FIXME (5098931): We should add a new insert action "WebViewInsertActionMoved" and call shouldInsertFragment here.
+  // FIXME (5098931): We should add a new insert action
+  // "WebViewInsertActionMoved" and call shouldInsertFragment here.
 
   setEndingSelection(createVisibleSelectionDeprecated(start, end));
   document()
       .frame()
       ->spellChecker()
       .clearMisspellingsAndBadGrammarForMovingParagraphs(endingSelection());
   deleteSelection(editingState, false, false, false);
   if (editingState->isAborted())
     return;
 
   DCHECK(destination.deepEquivalent().isConnected()) << destination;
   cleanupAfterDeletion(editingState, destination);
   if (editingState->isAborted())
     return;
   DCHECK(destination.deepEquivalent().isConnected()) << destination;
 
-  // Add a br if pruning an empty block level element caused a collapse. For example:
+  // Add a br if pruning an empty block level element caused a collapse. For
+  // example:
   // foo^
   // <div>bar</div>
   // baz
-  // Imagine moving 'bar' to ^. 'bar' will be deleted and its div pruned. That would
-  // cause 'baz' to collapse onto the line with 'foobar' unless we insert a br.
-  // Must recononicalize these two VisiblePositions after the pruning above.
+  // Imagine moving 'bar' to ^. 'bar' will be deleted and its div pruned. That
+  // would cause 'baz' to collapse onto the line with 'foobar' unless we insert
+  // a br. Must recononicalize these two VisiblePositions after the pruning
+  // above.
   VisiblePosition beforeParagraph =
       createVisiblePositionDeprecated(beforeParagraphPosition.position());
   VisiblePosition afterParagraph =
       createVisiblePositionDeprecated(afterParagraphPosition.position());
   if (beforeParagraph.isNotNull() &&
       (!isEndOfParagraphDeprecated(beforeParagraph) ||
        beforeParagraph.deepEquivalent() == afterParagraph.deepEquivalent())) {
-    // FIXME: Trim text between beforeParagraph and afterParagraph if they aren't equal.
+    // FIXME: Trim text between beforeParagraph and afterParagraph if they
+    // aren't equal.
     insertNodeAt(HTMLBRElement::create(document()),
                  beforeParagraph.deepEquivalent(), editingState);
     if (editingState->isAborted())
       return;
     // Need an updateLayout here in case inserting the br has split a text node.
     document().updateStyleAndLayoutIgnorePendingStylesheets();
   }
 
   destinationIndex = TextIterator::rangeLength(
       Position::firstPositionInNode(document().documentElement()),
@@ skipping 16 matching lines @@
       ReplaceSelectionCommand::create(document(), fragment, options),
       editingState);
   if (editingState->isAborted())
     return;
 
   document()
       .frame()
       ->spellChecker()
       .markMisspellingsAndBadGrammarForMovingParagraphs(endingSelection());
 
-  // If the selection is in an empty paragraph, restore styles from the old empty paragraph to the new empty paragraph.
+  // If the selection is in an empty paragraph, restore styles from the old
+  // empty paragraph to the new empty paragraph.
   bool selectionIsEmptyParagraph =
       endingSelection().isCaret() &&
       isStartOfParagraphDeprecated(
           endingSelection().visibleStartDeprecated()) &&
       isEndOfParagraphDeprecated(endingSelection().visibleStartDeprecated());
   if (styleInEmptyParagraph && selectionIsEmptyParagraph) {
     applyStyle(styleInEmptyParagraph, editingState);
     if (editingState->isAborted())
       return;
   }
@@ skipping 29 matching lines @@
 bool CompositeEditCommand::breakOutOfEmptyListItem(EditingState* editingState) {
   Node* emptyListItem =
       enclosingEmptyListItem(endingSelection().visibleStartDeprecated());
   if (!emptyListItem)
     return false;
 
   EditingStyle* style = EditingStyle::create(endingSelection().start());
   style->mergeTypingStyle(&document());
 
   ContainerNode* listNode = emptyListItem->parentNode();
-  // FIXME: Can't we do something better when the immediate parent wasn't a list node?
+  // FIXME: Can't we do something better when the immediate parent wasn't a list
+  // node?
   if (!listNode ||
       (!isHTMLUListElement(*listNode) && !isHTMLOListElement(*listNode)) ||
       !hasEditableStyle(*listNode) ||
       listNode == rootEditableElement(*emptyListItem))
     return false;
 
   HTMLElement* newBlock = nullptr;
   if (ContainerNode* blockEnclosingList = listNode->parentNode()) {
     if (isHTMLLIElement(
             *blockEnclosingList)) {  // listNode is inside another list item
       if (visiblePositionAfterNode(*blockEnclosingList).deepEquivalent() ==
           visiblePositionAfterNode(*listNode).deepEquivalent()) {
-        // If listNode appears at the end of the outer list item, then move listNode outside of this list item
-        // e.g. <ul><li>hello <ul><li><br></li></ul> </li></ul> should become <ul><li>hello</li> <ul><li><br></li></ul> </ul> after this section
-        // If listNode does NOT appear at the end, then we should consider it as a regular paragraph.
-        // e.g. <ul><li> <ul><li><br></li></ul> hello</li></ul> should become <ul><li> <div><br></div> hello</li></ul> at the end
+        // If listNode appears at the end of the outer list item, then move
+        // listNode outside of this list item, e.g.
+        //   <ul><li>hello <ul><li><br></li></ul> </li></ul>
+        // should become
+        //   <ul><li>hello</li> <ul><li><br></li></ul> </ul>
+        // after this section.
+        //
+        // If listNode does NOT appear at the end, then we should consider it as
+        // a regular paragraph, e.g.
+        //   <ul><li> <ul><li><br></li></ul> hello</li></ul>
+        // should become
+        //   <ul><li> <div><br></div> hello</li></ul>
+        // at the end
         splitElement(toElement(blockEnclosingList), listNode);
         removeNodePreservingChildren(listNode->parentNode(), editingState);
         if (editingState->isAborted())
           return false;
         newBlock = HTMLLIElement::create(document());
       }
-      // If listNode does NOT appear at the end of the outer list item, then behave as if in a regular paragraph.
+      // If listNode does NOT appear at the end of the outer list item, then
+      // behave as if in a regular paragraph.
     } else if (isHTMLOListElement(*blockEnclosingList) ||
                isHTMLUListElement(*blockEnclosingList)) {
       newBlock = HTMLLIElement::create(document());
     }
   }
   if (!newBlock)
     newBlock = createDefaultParagraphElement(document());
 
   Node* previousListNode =
       emptyListItem->isElementNode()
           ? ElementTraversal::previousSibling(*emptyListItem)
           : emptyListItem->previousSibling();
   Node* nextListNode = emptyListItem->isElementNode()
                            ? ElementTraversal::nextSibling(*emptyListItem)
                            : emptyListItem->nextSibling();
   if (isListItem(nextListNode) || isHTMLListElement(nextListNode)) {
-    // If emptyListItem follows another list item or nested list, split the list node.
+    // If emptyListItem follows another list item or nested list, split the list
+    // node.
     if (isListItem(previousListNode) || isHTMLListElement(previousListNode))
       splitElement(toElement(listNode), emptyListItem);
 
-    // If emptyListItem is followed by other list item or nested list, then insert newBlock before the list node.
-    // Because we have splitted the element, emptyListItem is the first element in the list node.
+    // If emptyListItem is followed by other list item or nested list, then
+    // insert newBlock before the list node. Because we have splitted the
+    // element, emptyListItem is the first element in the list node.
     // i.e. insert newBlock before ul or ol whose first element is emptyListItem
     insertNodeBefore(newBlock, listNode, editingState);
     if (editingState->isAborted())
       return false;
     removeNode(emptyListItem, editingState);
     if (editingState->isAborted())
       return false;
   } else {
-    // When emptyListItem does not follow any list item or nested list, insert newBlock after the enclosing list node.
-    // Remove the enclosing node if emptyListItem is the only child; otherwise just remove emptyListItem.
+    // When emptyListItem does not follow any list item or nested list, insert
+    // newBlock after the enclosing list node. Remove the enclosing node if
+    // emptyListItem is the only child; otherwise just remove emptyListItem.
     insertNodeAfter(newBlock, listNode, editingState);
     if (editingState->isAborted())
       return false;
     removeNode(
         isListItem(previousListNode) || isHTMLListElement(previousListNode)
             ? emptyListItem
             : listNode,
         editingState);
     if (editingState->isAborted())
       return false;
   }
 
   appendBlockPlaceholder(newBlock, editingState);
   if (editingState->isAborted())
     return false;
   setEndingSelection(createVisibleSelectionDeprecated(
       Position::firstPositionInNode(newBlock), TextAffinity::Downstream,
       endingSelection().isDirectional()));
 
   style->prepareToApplyAt(endingSelection().start());
   if (!style->isEmpty()) {
     applyStyle(style, editingState);
     if (editingState->isAborted())
       return false;
   }
 
   return true;
 }
 
-// If the caret is in an empty quoted paragraph, and either there is nothing before that
-// paragraph, or what is before is unquoted, and the user presses delete, unquote that paragraph.
+// If the caret is in an empty quoted paragraph, and either there is nothing
+// before that paragraph, or what is before is unquoted, and the user presses
+// delete, unquote that paragraph.
 bool CompositeEditCommand::breakOutOfEmptyMailBlockquotedParagraph(
     EditingState* editingState) {
   if (!endingSelection().isCaret())
     return false;
 
   VisiblePosition caret = endingSelection().visibleStartDeprecated();
   HTMLQuoteElement* highestBlockquote =
       toHTMLQuoteElement(highestEnclosingNodeOfType(
           caret.deepEquivalent(), &isMailHTMLBlockquoteElement));
   if (!highestBlockquote)
     return false;
 
   if (!isStartOfParagraphDeprecated(caret) ||
       !isEndOfParagraphDeprecated(caret))
     return false;
 
   VisiblePosition previous =
       previousPositionOf(caret, CannotCrossEditingBoundary);
-  // Only move forward if there's nothing before the caret, or if there's unquoted content before it.
+  // Only move forward if there's nothing before the caret, or if there's
+  // unquoted content before it.
   if (enclosingNodeOfType(previous.deepEquivalent(),
                           &isMailHTMLBlockquoteElement))
     return false;
 
   HTMLBRElement* br = HTMLBRElement::create(document());
-  // We want to replace this quoted paragraph with an unquoted one, so insert a br
-  // to hold the caret before the highest blockquote.
+  // We want to replace this quoted paragraph with an unquoted one, so insert a
+  // br to hold the caret before the highest blockquote.
   insertNodeBefore(br, highestBlockquote, editingState);
   if (editingState->isAborted())
     return false;
   VisiblePosition atBR = VisiblePosition::beforeNode(br);
-  // If the br we inserted collapsed, for example foo<br><blockquote>...</blockquote>, insert
-  // a second one.
+  // If the br we inserted collapsed, for example:
+  //   foo<br><blockquote>...</blockquote>
+  // insert a second one.
   if (!isStartOfParagraphDeprecated(atBR)) {
     insertNodeBefore(HTMLBRElement::create(document()), br, editingState);
     if (editingState->isAborted())
       return false;
   }
   setEndingSelection(createVisibleSelectionDeprecated(
       atBR, endingSelection().isDirectional()));
 
   // If this is an empty paragraph there must be a line break here.
   if (!lineBreakExistsAtVisiblePosition(caret))
     return false;
 
   Position caretPos(mostForwardCaretPosition(caret.deepEquivalent()));
   // A line break is either a br or a preserved newline.
   DCHECK(isHTMLBRElement(caretPos.anchorNode()) ||
          (caretPos.anchorNode()->isTextNode() &&
           caretPos.anchorNode()->layoutObject()->style()->preserveNewline()))
       << caretPos;
 
   if (isHTMLBRElement(*caretPos.anchorNode())) {
     removeNodeAndPruneAncestors(caretPos.anchorNode(), editingState);
     if (editingState->isAborted())
       return false;
   } else if (caretPos.anchorNode()->isTextNode()) {
     DCHECK_EQ(caretPos.computeOffsetInContainerNode(), 0);
     Text* textNode = toText(caretPos.anchorNode());
     ContainerNode* parentNode = textNode->parentNode();
-    // The preserved newline must be the first thing in the node, since otherwise the previous
-    // paragraph would be quoted, and we verified that it wasn't above.
+    // The preserved newline must be the first thing in the node, since
+    // otherwise the previous paragraph would be quoted, and we verified that it
+    // wasn't above.
     deleteTextFromNode(textNode, 0, 1);
     prune(parentNode, editingState);
     if (editingState->isAborted())
       return false;
   }
 
   return true;
 }
 
-// Operations use this function to avoid inserting content into an anchor when at the start or the end of
-// that anchor, as in NSTextView.
-// FIXME: This is only an approximation of NSTextViews insertion behavior, which varies depending on how
-// the caret was made.
+// Operations use this function to avoid inserting content into an anchor when
+// at the start or the end of that anchor, as in NSTextView.
+// FIXME: This is only an approximation of NSTextViews insertion behavior, which
+// varies depending on how the caret was made.
 Position CompositeEditCommand::positionAvoidingSpecialElementBoundary(
     const Position& original,
     EditingState* editingState) {
   if (original.isNull())
     return original;
 
   VisiblePosition visiblePos = createVisiblePositionDeprecated(original);
   Element* enclosingAnchor = enclosingAnchorElement(original);
   Position result = original;
 
   if (!enclosingAnchor)
     return result;
 
-  // Don't avoid block level anchors, because that would insert content into the wrong paragraph.
+  // Don't avoid block level anchors, because that would insert content into the
+  // wrong paragraph.
   if (enclosingAnchor && !isEnclosingBlock(enclosingAnchor)) {
     VisiblePosition firstInAnchor =
         VisiblePosition::firstPositionInNode(enclosingAnchor);
     VisiblePosition lastInAnchor =
         VisiblePosition::lastPositionInNode(enclosingAnchor);
-    // If visually just after the anchor, insert *inside* the anchor unless it's the last
-    // VisiblePosition in the document, to match NSTextView.
+    // If visually just after the anchor, insert *inside* the anchor unless it's
+    // the last VisiblePosition in the document, to match NSTextView.
     if (visiblePos.deepEquivalent() == lastInAnchor.deepEquivalent()) {
       // Make sure anchors are pushed down before avoiding them so that we don't
       // also avoid structural elements like lists and blocks (5142012).
       if (original.anchorNode() != enclosingAnchor &&
           original.anchorNode()->parentNode() != enclosingAnchor) {
         pushAnchorElementDown(enclosingAnchor, editingState);
         if (editingState->isAborted())
           return original;
         enclosingAnchor = enclosingAnchorElement(original);
         if (!enclosingAnchor)
           return original;
       }
-      // Don't insert outside an anchor if doing so would skip over a line break.  It would
-      // probably be safe to move the line break so that we could still avoid the anchor here.
+      // Don't insert outside an anchor if doing so would skip over a line
+      // break.  It would probably be safe to move the line break so that we
+      // could still avoid the anchor here.
       Position downstream(
           mostForwardCaretPosition(visiblePos.deepEquivalent()));
       if (lineBreakExistsAtVisiblePosition(visiblePos) &&
           downstream.anchorNode()->isDescendantOf(enclosingAnchor))
         return original;
 
       result = Position::inParentAfterNode(*enclosingAnchor);
     }
-    // If visually just before an anchor, insert *outside* the anchor unless it's the first
-    // VisiblePosition in a paragraph, to match NSTextView.
+    // If visually just before an anchor, insert *outside* the anchor unless
+    // it's the first VisiblePosition in a paragraph, to match NSTextView.
     if (visiblePos.deepEquivalent() == firstInAnchor.deepEquivalent()) {
       // Make sure anchors are pushed down before avoiding them so that we don't
       // also avoid structural elements like lists and blocks (5142012).
       if (original.anchorNode() != enclosingAnchor &&
           original.anchorNode()->parentNode() != enclosingAnchor) {
         pushAnchorElementDown(enclosingAnchor, editingState);
         if (editingState->isAborted())
           return original;
         enclosingAnchor = enclosingAnchorElement(original);
       }
       if (!enclosingAnchor)
         return original;
 
       result = Position::inParentBeforeNode(*enclosingAnchor);
     }
   }
 
   if (result.isNull() || !rootEditableElementOf(result))
     result = original;
 
   return result;
 }
 
-// Splits the tree parent by parent until we reach the specified ancestor. We use VisiblePositions
-// to determine if the split is necessary. Returns the last split node.
+// Splits the tree parent by parent until we reach the specified ancestor. We
+// use VisiblePositions to determine if the split is necessary. Returns the last
+// split node.
 Node* CompositeEditCommand::splitTreeToNode(Node* start,
                                             Node* end,
                                             bool shouldSplitAncestor) {
   DCHECK(start);
   DCHECK(end);
   DCHECK_NE(start, end);
 
   if (shouldSplitAncestor && end->parentNode())
     end = end->parentNode();
   if (!start->isDescendantOf(end))
@@ skipping 17 matching lines @@
   return node;
 }
 
 DEFINE_TRACE(CompositeEditCommand) {
   visitor->trace(m_commands);
   visitor->trace(m_composition);
   EditCommand::trace(visitor);
 }
 
 }  // namespace blink