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

third_party/WebKit/Source/core/editing/EditingUtilities.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007 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 86 matching lines @@
 }
 
 bool needsLayoutTreeUpdate(const Position& position) {
   return needsLayoutTreeUpdateAlgorithm<Position>(position);
 }
 
 bool needsLayoutTreeUpdate(const PositionInFlatTree& position) {
   return needsLayoutTreeUpdateAlgorithm<PositionInFlatTree>(position);
 }
 
-// Atomic means that the node has no children, or has children which are ignored for the
-// purposes of editing.
+// Atomic means that the node has no children, or has children which are ignored
+// for the purposes of editing.
 bool isAtomicNode(const Node* node) {
   return node && (!node->hasChildren() || editingIgnoresContent(node));
 }
 
 template <typename Traversal>
 static int comparePositions(Node* containerA,
                             int offsetA,
                             Node* containerB,
                             int offsetB,
                             bool* disconnected) {
@@ skipping 468 matching lines @@
                            ? PositionTemplate<Strategy>::inParentAfterNode(
                                  *editablePosition.anchorNode())
                            : nextVisuallyDistinctCandidate(editablePosition);
   }
 
   if (editablePosition.anchorNode() &&
       editablePosition.anchorNode() != &highestRoot &&
       !editablePosition.anchorNode()->isDescendantOf(&highestRoot))
     return PositionTemplate<Strategy>();
 
-  // If |editablePosition| has the non-editable child skipped, get the next sibling position.
-  // If not, we can't get the next paragraph in InsertListCommand::doApply's while loop.
-  // See http://crbug.com/571420
+  // If |editablePosition| has the non-editable child skipped, get the next
+  // sibling position. If not, we can't get the next paragraph in
+  // InsertListCommand::doApply's while loop. See http://crbug.com/571420
   if (nonEditableNode &&
       nonEditableNode->isDescendantOf(editablePosition.anchorNode()))
     editablePosition = nextVisuallyDistinctCandidate(editablePosition);
   return editablePosition;
 }
 
 Position firstEditablePositionAfterPositionInRoot(const Position& position,
                                                   Node& highestRoot) {
   return firstEditablePositionAfterPositionInRootAlgorithm<EditingStrategy>(
       position, highestRoot);
@@ skipping 643 matching lines @@
                                           EditingBoundaryCrossingRule rule) {
   // TODO(yosin) support CanSkipCrossEditingBoundary
   DCHECK(rule == CanCrossEditingBoundary || rule == CannotCrossEditingBoundary)
       << rule;
   if (p.isNull())
     return nullptr;
 
   ContainerNode* const root =
       rule == CannotCrossEditingBoundary ? highestEditableRoot(p) : nullptr;
   for (Node* n = p.anchorNode(); n; n = Strategy::parent(*n)) {
-    // Don't return a non-editable node if the input position was editable, since
-    // the callers from editing will no doubt want to perform editing inside the returned node.
+    // Don't return a non-editable node if the input position was editable,
+    // since the callers from editing will no doubt want to perform editing
+    // inside the returned node.
     if (root && !hasEditableStyle(*n))
       continue;
     if (nodeIsOfType(n))
       return n;
     if (n == root)
       return nullptr;
   }
 
   return nullptr;
 }
@@ skipping 88 matching lines @@
     if (runner == root)
       return 0;
   }
 
   return 0;
 }
 
 Node* enclosingListChild(Node* node) {
   if (!node)
     return 0;
-  // Check for a list item element, or for a node whose parent is a list element. Such a node
-  // will appear visually as a list item (but without a list marker)
+  // Check for a list item element, or for a node whose parent is a list
+  // element. Such a node will appear visually as a list item (but without a
+  // list marker)
   ContainerNode* root = highestEditableRoot(firstPositionInOrBeforeNode(node));
 
-  // FIXME: This function is inappropriately named if it starts with node instead of node->parentNode()
+  // FIXME: This function is inappropriately named if it starts with node
+  // instead of node->parentNode()
   for (Node* n = node; n && n->parentNode(); n = n->parentNode()) {
     if (isHTMLLIElement(*n) ||
         (isHTMLListElement(n->parentNode()) && n != root))
       return n;
     if (n == root || isTableCell(n))
       return 0;
   }
 
   return 0;
 }
 
-// FIXME: This method should not need to call isStartOfParagraph/isEndOfParagraph
+// FIXME: This method should not need to call
+// isStartOfParagraph/isEndOfParagraph
 Node* enclosingEmptyListItem(const VisiblePosition& visiblePos) {
   DCHECK(visiblePos.isValid());
 
   // Check that position is on a line by itself inside a list item
   Node* listChildNode =
       enclosingListChild(visiblePos.deepEquivalent().anchorNode());
   if (!listChildNode || !isStartOfParagraph(visiblePos) ||
       !isEndOfParagraph(visiblePos))
     return 0;
 
@@ skipping 16 matching lines @@
 
   while (HTMLElement* nextList = enclosingList(list)) {
     if (nextList == rootList)
       break;
     list = nextList;
   }
 
   return list;
 }
 
-// Determines whether two positions are visibly next to each other (first then second)
-// while ignoring whitespaces and unrendered nodes
+// Determines whether two positions are visibly next to each other (first then
+// second) while ignoring whitespaces and unrendered nodes
 static bool isVisiblyAdjacent(const Position& first, const Position& second) {
   return createVisiblePositionDeprecated(first).deepEquivalent() ==
          createVisiblePositionDeprecated(mostBackwardCaretPosition(second))
              .deepEquivalent();
 }
 
 bool canMergeLists(Element* firstList, Element* secondList) {
   if (!firstList || !secondList || !firstList->isHTMLElement() ||
       !secondList->isHTMLElement())
     return false;
@@ skipping 21 matching lines @@
 
 bool isTableCell(const Node* node) {
   DCHECK(node);
   LayoutObject* r = node->layoutObject();
   return r ? r->isTableCell() : isHTMLTableCellElement(*node);
 }
 
 bool isEmptyTableCell(const Node* node) {
   // Returns true IFF the passed in node is one of:
   //   .) a table cell with no children,
-  //   .) a table cell with a single BR child, and which has no other child layoutObject, including :before and :after layoutObject
+  //   .) a table cell with a single BR child, and which has no other child
+  //      layoutObject, including :before and :after layoutObject
   //   .) the BR child of such a table cell
 
   // Find rendered node
   while (node && !node->layoutObject())
     node = node->parentNode();
   if (!node)
     return false;
 
   // Make sure the rendered node is a table cell or <br>.
   // If it's a <br>, then the parent node has to be a table cell.
   LayoutObject* layoutObject = node->layoutObject();
   if (layoutObject->isBR()) {
     layoutObject = layoutObject->parent();
     if (!layoutObject)
       return false;
   }
   if (!layoutObject->isTableCell())
     return false;
 
-  // Check that the table cell contains no child layoutObjects except for perhaps a single <br>.
+  // Check that the table cell contains no child layoutObjects except for
+  // perhaps a single <br>.
   LayoutObject* childLayoutObject =
       toLayoutTableCell(layoutObject)->firstChild();
   if (!childLayoutObject)
     return true;
   if (!childLayoutObject->isBR())
     return false;
   return !childLayoutObject->nextSibling();
 }
 
 HTMLElement* createDefaultParagraphElement(Document& document) {
@@ skipping 58 matching lines @@
 }
 
 bool isNodeRendered(const Node& node) {
   LayoutObject* layoutObject = node.layoutObject();
   if (!layoutObject)
     return false;
 
   return layoutObject->style()->visibility() == EVisibility::Visible;
 }
 
-// return first preceding DOM position rendered at a different location, or "this"
+// return first preceding DOM position rendered at a different location, or
+// "this"
 static Position previousCharacterPosition(const Position& position,
                                           TextAffinity affinity) {
   if (position.isNull())
     return Position();
 
   Element* fromRootEditableElement =
       rootEditableElement(*position.anchorNode());
 
   bool atStartOfLine =
       isStartOfLine(createVisiblePositionDeprecated(position, affinity));
@@ skipping 181 matching lines @@
 
 // Modifies selections that have an end point at the edge of a table
 // that contains the other endpoint so that they don't confuse
 // code that iterates over selected paragraphs.
 VisibleSelection selectionForParagraphIteration(
     const VisibleSelection& original) {
   VisibleSelection newSelection(original);
   VisiblePosition startOfSelection(newSelection.visibleStart());
   VisiblePosition endOfSelection(newSelection.visibleEnd());
 
-  // If the end of the selection to modify is just after a table, and
-  // if the start of the selection is inside that table, then the last paragraph
-  // that we'll want modify is the last one inside the table, not the table itself
-  // (a table is itself a paragraph).
+  // If the end of the selection to modify is just after a table, and if the
+  // start of the selection is inside that table, then the last paragraph that
+  // we'll want modify is the last one inside the table, not the table itself (a
+  // table is itself a paragraph).
   if (Element* table = tableElementJustBefore(endOfSelection)) {
     if (startOfSelection.deepEquivalent().anchorNode()->isDescendantOf(table))
       newSelection = createVisibleSelection(
           startOfSelection,
           previousPositionOf(endOfSelection, CannotCrossEditingBoundary));
   }
 
-  // If the start of the selection to modify is just before a table,
-  // and if the end of the selection is inside that table, then the first paragraph
-  // we'll want to modify is the first one inside the table, not the paragraph
+  // If the start of the selection to modify is just before a table, and if the
+  // end of the selection is inside that table, then the first paragraph we'll
+  // want to modify is the first one inside the table, not the paragraph
   // containing the table itself.
   if (Element* table = tableElementJustAfter(startOfSelection)) {
     if (endOfSelection.deepEquivalent().anchorNode()->isDescendantOf(table))
       newSelection = createVisibleSelection(
           nextPositionOf(startOfSelection, CannotCrossEditingBoundary),
           endOfSelection);
   }
 
   return newSelection;
 }
 
-// FIXME: indexForVisiblePosition and visiblePositionForIndex use TextIterators to convert between
-// VisiblePositions and indices. But TextIterator iteration using TextIteratorEmitsCharactersBetweenAllVisiblePositions
-// does not exactly match VisiblePosition iteration, so using them to preserve a selection during an editing
-// opertion is unreliable. TextIterator's TextIteratorEmitsCharactersBetweenAllVisiblePositions mode needs to be fixed,
-// or these functions need to be changed to iterate using actual VisiblePositions.
-// FIXME: Deploy these functions everywhere that TextIterators are used to convert between VisiblePositions and indices.
+// FIXME: indexForVisiblePosition and visiblePositionForIndex use TextIterators
+// to convert between VisiblePositions and indices. But TextIterator iteration
+// using TextIteratorEmitsCharactersBetweenAllVisiblePositions does not exactly
+// match VisiblePosition iteration, so using them to preserve a selection during
+// an editing opertion is unreliable. TextIterator's
+// TextIteratorEmitsCharactersBetweenAllVisiblePositions mode needs to be fixed,
+// or these functions need to be changed to iterate using actual
+// VisiblePositions.
+// FIXME: Deploy these functions everywhere that TextIterators are used to
+// convert between VisiblePositions and indices.
 int indexForVisiblePosition(const VisiblePosition& visiblePosition,
                             ContainerNode*& scope) {
   if (visiblePosition.isNull())
     return 0;
 
   Position p(visiblePosition.deepEquivalent());
   Document& document = *p.document();
   DCHECK(!document.needsLayoutTreeUpdate());
 
   ShadowRoot* shadowRoot = p.anchorNode()->containingShadowRoot();
@@ skipping 61 matching lines @@
 
   EphemeralRange range = PlainTextRange(index).createRangeForSelection(*scope);
   // Check for an invalid index. Certain editing operations invalidate indices
   // because of problems with
   // TextIteratorEmitsCharactersBetweenAllVisiblePositions.
   if (range.isNull())
     return VisiblePosition();
   return createVisiblePosition(range.startPosition());
 }
 
-// Determines whether a node is inside a range or visibly starts and ends at the boundaries of the range.
-// Call this function to determine whether a node is visibly fit inside selectedRange
+// Determines whether a node is inside a range or visibly starts and ends at the
+// boundaries of the range. Call this function to determine whether a node is
+// visibly fit inside selectedRange
 bool isNodeVisiblyContainedWithin(Node& node, const Range& selectedRange) {
   if (selectedRange.isNodeFullyContained(node))
     return true;
 
   bool startIsVisuallySame =
       visiblePositionBeforeNode(node).deepEquivalent() ==
       createVisiblePositionDeprecated(selectedRange.startPosition())
           .deepEquivalent();
   if (startIsVisuallySame &&
       comparePositions(Position::inParentAfterNode(node),
@@ skipping 52 matching lines @@
 
 bool isBlockFlowElement(const Node& node) {
   LayoutObject* layoutObject = node.layoutObject();
   return node.isElementNode() && layoutObject &&
          layoutObject->isLayoutBlockFlow();
 }
 
 Position adjustedSelectionStartForStyleComputation(
     const VisibleSelection& selection) {
   // This function is used by range style computations to avoid bugs like:
-  // <rdar://problem/4017641> REGRESSION (Mail): you can only bold/unbold a selection starting from end of line once
-  // It is important to skip certain irrelevant content at the start of the selection, so we do not wind up
-  // with a spurious "mixed" style.
+  // <rdar://problem/4017641> REGRESSION (Mail): you can only bold/unbold a
+  // selection starting from end of line once
+  // It is important to skip certain irrelevant content at the start of the
+  // selection, so we do not wind up with a spurious "mixed" style.
 
   VisiblePosition visiblePosition = createVisiblePosition(selection.start());
   if (visiblePosition.isNull())
     return Position();
 
   // if the selection is a caret, just return the position, since the style
   // behind us is relevant
   if (selection.isCaret())
     return visiblePosition.deepEquivalent();
 
@@ skipping 89 matching lines @@
         return InputType::DeleteWordBackward;
       if (granularity == LineBoundary)
         return InputType::DeleteLineBackward;
       return InputType::DeleteContentBackward;
     default:
       return InputType::None;
   }
 }
 
 }  // namespace blink