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

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

 /*
- * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 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
  *    documentation and/or other materials provided with the distribution.
  *
@@ skipping 396 matching lines @@
     : m_rootInlineBox(0) {}
 
 const InlineTextBox* CachedLogicallyOrderedLeafBoxes::previousTextBox(
     const RootInlineBox* root,
     const InlineTextBox* box) {
   if (!root)
     return 0;
 
   collectBoxes(root);
 
-  // If box is null, root is box's previous RootInlineBox, and previousBox is the last logical box in root.
+  // If box is null, root is box's previous RootInlineBox, and previousBox is
+  // the last logical box in root.
   int boxIndex = m_leafBoxes.size() - 1;
   if (box)
     boxIndex = boxIndexInLeaves(box) - 1;
 
   for (int i = boxIndex; i >= 0; --i) {
     if (m_leafBoxes[i]->isInlineTextBox())
       return toInlineTextBox(m_leafBoxes[i]);
   }
 
   return 0;
 }
 
 const InlineTextBox* CachedLogicallyOrderedLeafBoxes::nextTextBox(
     const RootInlineBox* root,
     const InlineTextBox* box) {
   if (!root)
     return 0;
 
   collectBoxes(root);
 
-  // If box is null, root is box's next RootInlineBox, and nextBox is the first logical box in root.
-  // Otherwise, root is box's RootInlineBox, and nextBox is the next logical box in the same line.
+  // If box is null, root is box's next RootInlineBox, and nextBox is the first
+  // logical box in root. Otherwise, root is box's RootInlineBox, and nextBox is
+  // the next logical box in the same line.
   size_t nextBoxIndex = 0;
   if (box)
     nextBoxIndex = boxIndexInLeaves(box) + 1;
 
   for (size_t i = nextBoxIndex; i < m_leafBoxes.size(); ++i) {
     if (m_leafBoxes[i]->isInlineTextBox())
       return toInlineTextBox(m_leafBoxes[i]);
   }
 
   return 0;
@@ skipping 165 matching lines @@
 }
 
 static bool isLogicalStartOfWord(TextBreakIterator* iter,
                                  int position,
                                  bool hardLineBreak) {
   bool boundary = hardLineBreak ? true : iter->isBoundary(position);
   if (!boundary)
     return false;
 
   iter->following(position);
-  // isWordTextBreak returns true after moving across a word and false after moving across a punctuation/space.
+  // isWordTextBreak returns true after moving across a word and false after
+  // moving across a punctuation/space.
   return isWordTextBreak(iter);
 }
 
 static bool islogicalEndOfWord(TextBreakIterator* iter,
                                int position,
                                bool hardLineBreak) {
   bool boundary = iter->isBoundary(position);
   return (hardLineBreak || boundary) && isWordTextBreak(iter);
 }
 
@@ skipping 539 matching lines @@
     return PositionWithAffinityTemplate<Strategy>();
   }
 
   Node* startNode;
   InlineBox* startBox;
   if (mode == UseLogicalOrdering) {
     startNode = rootBox->getLogicalStartBoxWithNode(startBox);
     if (!startNode)
       return PositionWithAffinityTemplate<Strategy>();
   } else {
-    // Generated content (e.g. list markers and CSS :before and :after pseudoelements) have no corresponding DOM element,
-    // and so cannot be represented by a VisiblePosition. Use whatever follows instead.
+    // Generated content (e.g. list markers and CSS :before and :after
+    // pseudoelements) have no corresponding DOM element, and so cannot be
+    // represented by a VisiblePosition. Use whatever follows instead.
     startBox = rootBox->firstLeafChild();
     while (true) {
       if (!startBox)
         return PositionWithAffinityTemplate<Strategy>();
 
       startNode = startBox->getLineLayoutItem().nonPseudoNode();
       if (startNode)
         break;
 
       startBox = startBox->nextLeafChild();
@@ skipping 368 matching lines @@
         absoluteLineDirectionPointToLocalPointInBlock(root, lineDirectionPoint);
     LineLayoutItem lineLayoutItem =
         root->closestLeafChildForPoint(pointInLine, isEditablePosition(p))
             ->getLineLayoutItem();
     Node* node = lineLayoutItem.node();
     if (node && editingIgnoresContent(node))
       return VisiblePosition::inParentBeforeNode(*node);
     return createVisiblePosition(lineLayoutItem.positionForPoint(pointInLine));
   }
 
-  // Could not find a previous line. This means we must already be on the first line.
-  // Move to the start of the content in this block, which effectively moves us
-  // to the start of the line we're on.
+  // Could not find a previous line. This means we must already be on the first
+  // line. Move to the start of the content in this block, which effectively
+  // moves us to the start of the line we're on.
   Element* rootElement = hasEditableStyle(*node, editableType)
                              ? rootEditableElement(*node, editableType)
                              : node->document().documentElement();
   if (!rootElement)
     return VisiblePosition();
   return VisiblePosition::firstPositionInNode(rootElement);
 }
 
 VisiblePosition nextLinePosition(const VisiblePosition& visiblePosition,
                                  LayoutUnit lineDirectionPoint,
@@ skipping 110 matching lines @@
 VisiblePositionInFlatTree endOfSentence(const VisiblePositionInFlatTree& c) {
   return endOfSentenceAlgorithm<EditingInFlatTreeStrategy>(c);
 }
 
 static unsigned previousSentencePositionBoundary(
     const UChar* characters,
     unsigned length,
     unsigned,
     BoundarySearchContextAvailability,
     bool&) {
-  // FIXME: This is identical to startSentenceBoundary. I'm pretty sure that's not right.
+  // FIXME: This is identical to startSentenceBoundary. I'm pretty sure that's
+  // not right.
   TextBreakIterator* iterator = sentenceBreakIterator(characters, length);
   // FIXME: The following function can return -1; we don't handle that.
   return iterator->preceding(length);
 }
 
 VisiblePosition previousSentencePosition(const VisiblePosition& c) {
   DCHECK(c.isValid()) << c;
   VisiblePosition prev = previousBoundary(c, previousSentencePositionBoundary);
   return honorEditingBoundaryAtOrBefore(prev, c.deepEquivalent());
 }
 
 static unsigned nextSentencePositionBoundary(const UChar* characters,
                                              unsigned length,
                                              unsigned,
                                              BoundarySearchContextAvailability,
                                              bool&) {
-  // FIXME: This is identical to endSentenceBoundary. This isn't right, it needs to
-  // move to the equivlant position in the following sentence.
+  // FIXME: This is identical to endSentenceBoundary. This isn't right, it needs
+  // to move to the equivlant position in the following sentence.
   TextBreakIterator* iterator = sentenceBreakIterator(characters, length);
   return iterator->following(0);
 }
 
 VisiblePosition nextSentencePosition(const VisiblePosition& c) {
   DCHECK(c.isValid()) << c;
   VisiblePosition next = nextBoundary(c, nextSentencePositionBoundary);
   return honorEditingBoundaryAtOrAfter(next, c.deepEquivalent());
 }
 
@@ skipping 179 matching lines @@
     }
     const ComputedStyle& style = layoutObject->styleRef();
     if (style.visibility() != EVisibility::Visible) {
       nextNodeItreator = Strategy::next(*nextNodeItreator, startBlock);
       continue;
     }
 
     if (layoutObject->isBR() || isEnclosingBlock(nextNodeItreator))
       break;
 
-    // FIXME: We avoid returning a position where the layoutObject can't accept the caret.
+    // FIXME: We avoid returning a position where the layoutObject can't accept
+    // the caret.
     if (layoutObject->isText() &&
         toLayoutText(layoutObject)->resolvedTextLength()) {
       SECURITY_DCHECK(nextNodeItreator->isTextNode());
       LayoutText* const text = toLayoutText(layoutObject);
       if (style.preserveNewline()) {
         const int length = toLayoutText(layoutObject)->textLength();
         for (int i = (nextNodeItreator == startNode ? candidateOffset : 0);
              i < length; ++i) {
           if ((*text)[i] == '\n')
             return PositionTemplate<Strategy>(toText(nextNodeItreator),
@@ skipping 964 matching lines @@
           ? PositionTemplate<Strategy>::editingPositionOf(
                 position.anchorNode(),
                 Strategy::caretMaxOffset(*position.anchorNode()))
           : position);
   PositionIteratorAlgorithm<Strategy> currentPos = lastVisible;
   bool startEditable = hasEditableStyle(*startNode);
   Node* lastNode = startNode;
   bool boundaryCrossed = false;
   for (; !currentPos.atStart(); currentPos.decrement()) {
     Node* currentNode = currentPos.node();
-    // Don't check for an editability change if we haven't moved to a different node,
-    // to avoid the expense of computing hasEditableStyle().
+    // Don't check for an editability change if we haven't moved to a different
+    // node, to avoid the expense of computing hasEditableStyle().
     if (currentNode != lastNode) {
       // Don't change editability.
       bool currentEditable = hasEditableStyle(*currentNode);
       if (startEditable != currentEditable) {
         if (rule == CannotCrossEditingBoundary)
           break;
         boundaryCrossed = true;
       }
       lastNode = currentNode;
     }
 
-    // If we've moved to a position that is visually distinct, return the last saved position. There
-    // is code below that terminates early if we're *about* to move to a visually distinct position.
+    // If we've moved to a position that is visually distinct, return the last
+    // saved position. There is code below that terminates early if we're
+    // *about* to move to a visually distinct position.
     if (endsOfNodeAreVisuallyDistinctPositions(currentNode) &&
         currentNode != boundary)
       return lastVisible.deprecatedComputePosition();
 
     // skip position in non-laid out or invisible node
     LayoutObject* layoutObject =
         associatedLayoutObjectOf(*currentNode, currentPos.offsetInLeafNode());
     if (!layoutObject ||
         layoutObject->style()->visibility() != EVisibility::Visible)
       continue;
 
     if (rule == CanCrossEditingBoundary && boundaryCrossed) {
       lastVisible = currentPos;
       break;
     }
 
     // track last visible streamer position
     if (isStreamer<Strategy>(currentPos))
       lastVisible = currentPos;
 
-    // Don't move past a position that is visually distinct.  We could rely on code above to terminate and
-    // return lastVisible on the next iteration, but we terminate early to avoid doing a nodeIndex() call.
+    // Don't move past a position that is visually distinct.  We could rely on
+    // code above to terminate and return lastVisible on the next iteration, but
+    // we terminate early to avoid doing a nodeIndex() call.
     if (endsOfNodeAreVisuallyDistinctPositions(currentNode) &&
         currentPos.atStartOfNode())
       return lastVisible.deprecatedComputePosition();
 
-    // Return position after tables and nodes which have content that can be ignored.
+    // Return position after tables and nodes which have content that can be
+    // ignored.
     if (Strategy::editingIgnoresContent(currentNode) ||
         isDisplayInsideTable(currentNode)) {
       if (currentPos.atEndOfNode())
         return PositionTemplate<Strategy>::afterNode(currentNode);
       continue;
     }
 
     // return current position if it is in laid out text
     if (layoutObject->isText() && toLayoutText(layoutObject)->firstTextBox()) {
       LayoutText* const textLayoutObject = toLayoutText(layoutObject);
       const unsigned textStartOffset = textLayoutObject->textStartOffset();
       if (currentNode != startNode) {
-        // This assertion fires in layout tests in the case-transform.html test because
-        // of a mix-up between offsets in the text in the DOM tree with text in the
-        // layout tree which can have a different length due to case transformation.
+        // This assertion fires in layout tests in the case-transform.html test
+        // because of a mix-up between offsets in the text in the DOM tree with
+        // text in the layout tree which can have a different length due to case
+        // transformation.
         // Until we resolve that, disable this so we can run the layout tests!
         // DCHECK_GE(currentOffset, layoutObject->caretMaxOffset());
         return PositionTemplate<Strategy>(
             currentNode, layoutObject->caretMaxOffset() + textStartOffset);
       }
 
       // Map offset in DOM node to offset in InlineBox.
       DCHECK_GE(currentPos.offsetInLeafNode(),
                 static_cast<int>(textStartOffset));
       const unsigned textOffset =
@@ skipping 21 matching lines @@
         }
         if (textOffset <= box->start() + box->len()) {
           if (textOffset > box->start())
             return currentPos.computePosition();
           continue;
         }
 
         if (box == lastTextBox || textOffset != box->start() + box->len() + 1)
           continue;
 
-        // The text continues on the next line only if the last text box is not on this line and
-        // none of the boxes on this line have a larger start offset.
+        // The text continues on the next line only if the last text box is not
+        // on this line and none of the boxes on this line have a larger start
+        // offset.
 
         bool continuesOnNextLine = true;
         InlineBox* otherBox = box;
         while (continuesOnNextLine) {
           otherBox = otherBox->nextLeafChild();
           if (!otherBox)
             break;
           if (otherBox == lastTextBox ||
               (LineLayoutAPIShim::layoutObjectFrom(
                    otherBox->getLineLayoutItem()) == textLayoutObject &&
@@ skipping 49 matching lines @@
           ? PositionTemplate<Strategy>::editingPositionOf(
                 position.anchorNode(),
                 Strategy::caretMaxOffset(*position.anchorNode()))
           : position);
   PositionIteratorAlgorithm<Strategy> currentPos = lastVisible;
   bool startEditable = hasEditableStyle(*startNode);
   Node* lastNode = startNode;
   bool boundaryCrossed = false;
   for (; !currentPos.atEnd(); currentPos.increment()) {
     Node* currentNode = currentPos.node();
-    // Don't check for an editability change if we haven't moved to a different node,
-    // to avoid the expense of computing hasEditableStyle().
+    // Don't check for an editability change if we haven't moved to a different
+    // node, to avoid the expense of computing hasEditableStyle().
     if (currentNode != lastNode) {
       // Don't change editability.
       bool currentEditable = hasEditableStyle(*currentNode);
       if (startEditable != currentEditable) {
         if (rule == CannotCrossEditingBoundary)
           break;
         boundaryCrossed = true;
       }
 
       lastNode = currentNode;
     }
 
     // stop before going above the body, up into the head
     // return the last visible streamer position
     if (isHTMLBodyElement(*currentNode) && currentPos.atEndOfNode())
       break;
 
     // Do not move to a visually distinct position.
     if (endsOfNodeAreVisuallyDistinctPositions(currentNode) &&
         currentNode != boundary)
       return lastVisible.deprecatedComputePosition();
     // Do not move past a visually disinct position.
-    // Note: The first position after the last in a node whose ends are visually distinct
-    // positions will be [boundary->parentNode(), originalBlock->nodeIndex() + 1].
+    // Note: The first position after the last in a node whose ends are visually
+    // distinct positions will be [boundary->parentNode(),
+    // originalBlock->nodeIndex() + 1].
     if (boundary && Strategy::parent(*boundary) == currentNode)
       return lastVisible.deprecatedComputePosition();
 
     // skip position in non-laid out or invisible node
     LayoutObject* layoutObject =
         associatedLayoutObjectOf(*currentNode, currentPos.offsetInLeafNode());
     if (!layoutObject ||
         layoutObject->style()->visibility() != EVisibility::Visible)
       continue;
 
     if (rule == CanCrossEditingBoundary && boundaryCrossed) {
       lastVisible = currentPos;
       break;
     }
 
     // track last visible streamer position
     if (isStreamer<Strategy>(currentPos))
       lastVisible = currentPos;
 
-    // Return position before tables and nodes which have content that can be ignored.
+    // Return position before tables and nodes which have content that can be
+    // ignored.
     if (Strategy::editingIgnoresContent(currentNode) ||
         isDisplayInsideTable(currentNode)) {
       if (currentPos.offsetInLeafNode() <= layoutObject->caretMinOffset())
         return PositionTemplate<Strategy>::editingPositionOf(
             currentNode, layoutObject->caretMinOffset());
       continue;
     }
 
     // return current position if it is in laid out text
     if (layoutObject->isText() && toLayoutText(layoutObject)->firstTextBox()) {
@@ skipping 15 matching lines @@
            box = box->nextTextBox()) {
         if (textOffset <= box->end()) {
           if (textOffset >= box->start())
             return currentPos.computePosition();
           continue;
         }
 
         if (box == lastTextBox || textOffset != box->start() + box->len())
           continue;
 
-        // The text continues on the next line only if the last text box is not on this line and
-        // none of the boxes on this line have a larger start offset.
+        // The text continues on the next line only if the last text box is not
+        // on this line and none of the boxes on this line have a larger start
+        // offset.
 
         bool continuesOnNextLine = true;
         InlineBox* otherBox = box;
         while (continuesOnNextLine) {
           otherBox = otherBox->nextLeafChild();
           if (!otherBox)
             break;
           if (otherBox == lastTextBox ||
               (LineLayoutAPIShim::layoutObjectFrom(
                    otherBox->getLineLayoutItem()) == textLayoutObject &&
@@ skipping 591 matching lines @@
 
         if (box->bidiLevel() > level) {
           do {
             nextBox = nextBox->nextLeafChild();
           } while (nextBox && nextBox->bidiLevel() > level);
 
           if (!nextBox || nextBox->bidiLevel() < level)
             continue;
         }
       } else {
-        // Trailing edge of a secondary run. Set to the leading edge of the entire run.
+        // Trailing edge of a secondary run. Set to the leading edge of the
+        // entire run.
         while (true) {
           while (InlineBox* prevBox = box->prevLeafChild()) {
             if (prevBox->bidiLevel() < level)
               break;
             box = prevBox;
           }
           if (box->bidiLevel() == level)
             break;
           level = box->bidiLevel();
           while (InlineBox* nextBox = box->nextLeafChild()) {
@@ skipping 207 matching lines @@
   if (visiblePosition.isNull())
     return VisiblePositionInFlatTree();
   visiblePosition.deepEquivalent()
       .document()
       ->updateStyleAndLayoutIgnorePendingStylesheets();
   return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(
       visiblePosition.deepEquivalent(), rule);
 }
 
 }  // namespace blink