ASSERT -> DCHECK in core/editing.

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

 /*
  * 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
@@ skipping 55 matching lines @@
 #include "platform/heap/Handle.h"
 #include "platform/text/TextBoundaries.h"
 
 namespace blink {
 
 template <typename PositionType>
 static PositionType canonicalizeCandidate(const PositionType& candidate)
 {
     if (candidate.isNull())
         return PositionType();
-    ASSERT(isVisuallyEquivalentCandidate(candidate));
+    DCHECK(isVisuallyEquivalentCandidate(candidate));
     PositionType upstream = mostBackwardCaretPosition(candidate);
     if (isVisuallyEquivalentCandidate(upstream))
         return upstream;
     return candidate;
 }
 
 template <typename PositionType>
 static PositionType canonicalPosition(const PositionType& passedPosition)
 {
     // Sometimes updating selection positions can be extremely expensive and
     // occur frequently.  Often calling preventDefault on mousedown events can
     // avoid doing unnecessary text selection work.  http://crbug.com/472258.
     TRACE_EVENT0("input", "VisibleUnits::canonicalPosition");
 
     // The updateLayout call below can do so much that even the position passed
     // in to us might get changed as a side effect. Specifically, there are code
     // paths that pass selection endpoints, and updateLayout can change the
     // selection.
     PositionType position = passedPosition;
 
     // FIXME (9535):  Canonicalizing to the leftmost candidate means that if
     // we're at a line wrap, we will ask layoutObjects to paint downstream
     // carets for other layoutObjects. To fix this, we need to either a) add
     // code to all paintCarets to pass the responsibility off to the appropriate
     // layoutObject for VisiblePosition's like these, or b) canonicalize to the
     // rightmost candidate unless the affinity is upstream.
     if (position.isNull())
         return PositionType();
 
-    ASSERT(position.document());
+    DCHECK(position.document());
     position.document()->updateLayoutIgnorePendingStylesheets();
 
     Node* node = position.computeContainerNode();
 
     PositionType candidate = mostBackwardCaretPosition(position);
     if (isVisuallyEquivalentCandidate(candidate))
         return candidate;
     candidate = mostForwardCaretPosition(position);
     if (isVisuallyEquivalentCandidate(candidate))
         return candidate;
@@ skipping 601 matching lines @@
             next = 0;
         }
         it.advance();
     }
     if (needMoreContext) {
         // The last search returned the beginning of the buffer and asked for
         // more context, but there is no earlier text. Force a search with
         // what's available.
         // TODO(xiaochengh): Do we have to search the whole string?
         next = searchFunction(string.data(), string.size(), string.size() - suffixLength, DontHaveMoreContext, needMoreContext);
-        ASSERT(!needMoreContext);
+        DCHECK(!needMoreContext);
     }
 
     if (!next)
         return createVisiblePosition(it.atEnd() ? it.startPosition() : pos);
 
     Node* node = it.startContainer();
     int boundaryOffset = remainingLength + next;
     if (node->isTextNode() && boundaryOffset <= node->maxCharacterOffset()) {
         // The next variable contains a usable index into a text node
         return createVisiblePosition(PositionTemplate<Strategy>(node, boundaryOffset));
@@ skipping 73 matching lines @@
             next = string.size();
         }
         it.advance();
     }
     if (needMoreContext) {
         // The last search returned the end of the buffer and asked for more
         // context, but there is no further text. Force a search with what's
         // available.
         // TODO(xiaochengh): Do we still have to search the whole string?
         next = searchFunction(string.data(), string.size(), prefixLength, DontHaveMoreContext, needMoreContext);
-        ASSERT(!needMoreContext);
+        DCHECK(!needMoreContext);
     }
 
     if (it.atEnd() && next == string.size()) {
         pos = it.startPositionInCurrentContainer();
     } else if (next != invalidOffset && next != prefixLength) {
         // Use the character iterator to translate the next value into a DOM
         // position.
         CharacterIteratorAlgorithm<Strategy> charIt(searchStart, searchEnd, TextIteratorEmitsCharactersBetweenAllVisiblePositions);
         charIt.advance(next - prefixLength - 1);
         pos = charIt.endPosition();
@@ skipping 12 matching lines @@
 
     // generate VisiblePosition, use TextAffinity::Upstream affinity if possible
     return createVisiblePosition(pos, VP_UPSTREAM_IF_POSSIBLE);
 }
 
 // ---------
 
 static unsigned startWordBoundary(const UChar* characters, unsigned length, unsigned offset, BoundarySearchContextAvailability mayHaveMoreContext, bool& needMoreContext)
 {
     TRACE_EVENT0("blink", "startWordBoundary");
-    ASSERT(offset);
+    DCHECK(offset);
     if (mayHaveMoreContext && !startOfLastWordBoundaryContext(characters, offset)) {
         needMoreContext = true;
         return 0;
     }
     needMoreContext = false;
     int start, end;
     U16_BACK_1(characters, 0, offset);
     findWordBoundary(characters, length, offset, &start, &end);
     return start;
 }
@@ skipping 21 matching lines @@
     return startOfWordAlgorithm<EditingStrategy>(c, side);
 }
 
 VisiblePositionInFlatTree startOfWord(const VisiblePositionInFlatTree& c, EWordSide side)
 {
     return startOfWordAlgorithm<EditingInFlatTreeStrategy>(c, side);
 }
 
 static unsigned endWordBoundary(const UChar* characters, unsigned length, unsigned offset, BoundarySearchContextAvailability mayHaveMoreContext, bool& needMoreContext)
 {
-    ASSERT(offset <= length);
+    DCHECK_LE(offset, length);
     if (mayHaveMoreContext && endOfFirstWordBoundaryContext(characters + offset, length - offset) == static_cast<int>(length - offset)) {
         needMoreContext = true;
         return length;
     }
     needMoreContext = false;
     return findWordEndBoundary(characters, length, offset);
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> endOfWordAlgorithm(const VisiblePositionTemplate<Strategy>& c, EWordSide side)
@@ skipping 367 matching lines @@
     return isLogicalEndOfLineAlgorithm<EditingStrategy>(p);
 }
 
 bool isLogicalEndOfLine(const VisiblePositionInFlatTree& p)
 {
     return isLogicalEndOfLineAlgorithm<EditingInFlatTreeStrategy>(p);
 }
 
 static inline LayoutPoint absoluteLineDirectionPointToLocalPointInBlock(RootInlineBox* root, LayoutUnit lineDirectionPoint)
 {
-    ASSERT(root);
+    DCHECK(root);
     LineLayoutBlockFlow containingBlock = root->block();
     FloatPoint absoluteBlockPoint = containingBlock.localToAbsolute(FloatPoint());
     if (containingBlock.hasOverflowClip())
         absoluteBlockPoint -= FloatSize(containingBlock.scrolledContentOffset());
 
     if (root->block().isHorizontalWritingMode())
         return LayoutPoint(LayoutUnit(lineDirectionPoint - absoluteBlockPoint.x()), root->blockDirectionPointInLine());
 
     return LayoutPoint(root->blockDirectionPointInLine(), LayoutUnit(lineDirectionPoint - absoluteBlockPoint.y()));
 }
@@ skipping 913 matching lines @@
 //  appeared in layout tree.
 //
 //  When |Text| node contains only first-letter characters and whitespaces, e.g.
 //  "B\n", associated |LayoutTextFragment| is first-letter part instead of
 //  remaining part.
 //
 //  Punctuation characters are considered as first-letter. For "(1)ab",
 //  "(1)" are first-letter part and "ab" are remaining part.
 LayoutObject* associatedLayoutObjectOf(const Node& node, int offsetInNode)
 {
-    ASSERT(offsetInNode >= 0);
+    DCHECK_GE(offsetInNode, 0);
     LayoutObject* layoutObject = node.layoutObject();
     if (!node.isTextNode() || !layoutObject || !toLayoutText(layoutObject)->isTextFragment())
         return layoutObject;
     LayoutTextFragment* layoutTextFragment = toLayoutTextFragment(layoutObject);
     if (!layoutTextFragment->isRemainingTextLayoutObject()) {
-        ASSERT(static_cast<unsigned>(offsetInNode) <= layoutTextFragment->start() + layoutTextFragment->fragmentLength());
+        DCHECK_LE(static_cast<unsigned>(offsetInNode), layoutTextFragment->start() + layoutTextFragment->fragmentLength());
         return layoutTextFragment;
     }
     if (layoutTextFragment->fragmentLength() && static_cast<unsigned>(offsetInNode) >= layoutTextFragment->start())
         return layoutObject;
     LayoutObject* firstLetterLayoutObject = layoutTextFragment->firstLetterPseudoElement()->layoutObject();
     // TODO(yosin): We're not sure when |firstLetterLayoutObject| has
     // multiple child layout object.
-    ASSERT(firstLetterLayoutObject->slowFirstChild() == firstLetterLayoutObject->slowLastChild());
+    DCHECK_EQ(firstLetterLayoutObject->slowFirstChild(), firstLetterLayoutObject->slowLastChild());
     return firstLetterLayoutObject->slowFirstChild();
 }
 
 int caretMinOffset(const Node* node)
 {
     LayoutObject* layoutObject = associatedLayoutObjectOf(*node, 0);
     return layoutObject ? layoutObject->caretMinOffset() : 0;
 }
 
 int caretMaxOffset(const Node* n)
@@ skipping 174 matching lines @@
 
         // 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.
                 // Until we resolve that, disable this so we can run the layout tests!
-                // ASSERT(currentOffset >= layoutObject->caretMaxOffset());
+                // DCHECK_GE(currentOffset, layoutObject->caretMaxOffset());
                 return PositionTemplate<Strategy>(currentNode, layoutObject->caretMaxOffset() + textStartOffset);
             }
 
             // Map offset in DOM node to offset in InlineBox.
-            ASSERT(currentPos.offsetInLeafNode() >= static_cast<int>(textStartOffset));
+            DCHECK_GE(currentPos.offsetInLeafNode(), static_cast<int>(textStartOffset));
             const unsigned textOffset = currentPos.offsetInLeafNode() - textStartOffset;
             InlineTextBox* lastTextBox = textLayoutObject->lastTextBox();
             for (InlineTextBox* box = textLayoutObject->firstTextBox(); box; box = box->nextTextBox()) {
                 if (textOffset == box->start()) {
                     if (textLayoutObject->isTextFragment() && toLayoutTextFragment(layoutObject)->isRemainingTextLayoutObject()) {
                         // |currentPos| is at start of remaining text of
                         // |Text| node with :first-letter.
-                        ASSERT(currentPos.offsetInLeafNode() >= 1);
+                        DCHECK_GE(currentPos.offsetInLeafNode(), 1);
                         LayoutObject* firstLetterLayoutObject = toLayoutTextFragment(layoutObject)->firstLetterPseudoElement()->layoutObject();
                         if (firstLetterLayoutObject && firstLetterLayoutObject->style()->visibility() == VISIBLE)
                             return currentPos.computePosition();
                     }
                     continue;
                 }
                 if (textOffset <= box->start() + box->len()) {
                     if (textOffset > box->start())
                         return currentPos.computePosition();
                     continue;
@@ skipping 108 matching lines @@
             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()) {
             LayoutText* const textLayoutObject = toLayoutText(layoutObject);
             const unsigned textStartOffset = textLayoutObject->textStartOffset();
             if (currentNode != startNode) {
-                ASSERT(currentPos.atStartOfNode());
+                DCHECK(currentPos.atStartOfNode());
                 return PositionTemplate<Strategy>(currentNode, layoutObject->caretMinOffset() + textStartOffset);
             }
 
             // Map offset in DOM node to offset in InlineBox.
-            ASSERT(currentPos.offsetInLeafNode() >= static_cast<int>(textStartOffset));
+            DCHECK_GE(currentPos.offsetInLeafNode(), static_cast<int>(textStartOffset));
             const unsigned textOffset = currentPos.offsetInLeafNode() - textStartOffset;
             InlineTextBox* lastTextBox = textLayoutObject->lastTextBox();
             for (InlineTextBox* box = textLayoutObject->firstTextBox(); box; box = box->nextTextBox()) {
                 if (textOffset <= box->end()) {
                     if (textOffset >= box->start())
                         return currentPos.computePosition();
                     continue;
                 }
 
                 if (box == lastTextBox || textOffset != box->start() + box->len())
@@ skipping 172 matching lines @@
     // or both are non-editable.
     if (highestRootOfPos == highestRoot)
         return pos;
 
     // If this is not editable but |pos| has an editable root, skip to the end
     if (!highestRoot && highestRootOfPos)
         return createVisiblePosition(PositionTemplate<Strategy>(highestRootOfPos, PositionAnchorType::AfterAnchor).parentAnchoredEquivalent());
 
     // That must mean that |pos| is not editable. Return the next position after
     // |pos| that is in the same editable region as this position
-    ASSERT(highestRoot);
+    DCHECK(highestRoot);
     return firstEditableVisiblePositionAfterPositionInRoot(pos.deepEquivalent(), *highestRoot);
 }
 
 template <typename Strategy>
 static UChar32 characterAfterAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
     // We canonicalize to the first of two equivalent candidates, but the second
     // of the two candidates is the one that will be inside the text node
     // containing the character after this visible position.
     const PositionTemplate<Strategy> pos = mostForwardCaretPosition(visiblePosition.deepEquivalent());
@@ skipping 95 matching lines @@
                 }
 
                 // Reposition at the other logical position corresponding to our
                 // edge's visual position and go for another round.
                 box = prevBox;
                 lineLayoutItem = box->getLineLayoutItem();
                 offset = prevBox->caretRightmostOffset();
                 continue;
             }
 
-            ASSERT(offset == box->caretLeftmostOffset());
+            DCHECK_EQ(offset, box->caretLeftmostOffset());
 
             unsigned char level = box->bidiLevel();
             InlineBox* prevBox = box->prevLeafChild();
 
             if (box->direction() == primaryDirection) {
                 if (!prevBox) {
                     InlineBox* logicalStart = 0;
                     if (primaryDirection == LTR ? box->root().getLogicalStartBoxWithNode(logicalStart) : box->root().getLogicalEndBoxWithNode(logicalStart)) {
                         box = logicalStart;
                         lineLayoutItem = box->getLineLayoutItem();
@@ skipping 62 matching lines @@
                 offset = primaryDirection == LTR ? box->caretMinOffset() : box->caretMaxOffset();
             }
             break;
         }
 
         p = PositionTemplate<Strategy>::editingPositionOf(lineLayoutItem.node(), offset);
 
         if ((isVisuallyEquivalentCandidate(p) && mostForwardCaretPosition(p) != downstreamStart) || p.atStartOfTree() || p.atEndOfTree())
             return p;
 
-        ASSERT(p != deepPosition);
+        DCHECK_NE(p, deepPosition);
     }
 }
 
 template <typename Strategy>
 VisiblePositionTemplate<Strategy> leftPositionOfAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
     const PositionTemplate<Strategy> pos = leftVisuallyDistinctCandidate(visiblePosition);
     // TODO(yosin) Why can't we move left from the last position in a tree?
     if (pos.atStartOfTree() || pos.atEndOfTree())
         return VisiblePositionTemplate<Strategy>();
 
     const VisiblePositionTemplate<Strategy> left = createVisiblePosition(pos);
-    ASSERT(left.deepEquivalent() != visiblePosition.deepEquivalent());
+    DCHECK_NE(left.deepEquivalent(), visiblePosition.deepEquivalent());
 
     return directionOfEnclosingBlock(left.deepEquivalent()) == LTR ? honorEditingBoundaryAtOrBefore(left, visiblePosition.deepEquivalent()) : honorEditingBoundaryAtOrAfter(left, visiblePosition.deepEquivalent());
 }
 
 VisiblePosition leftPositionOf(const VisiblePosition& visiblePosition)
 {
     return leftPositionOfAlgorithm<EditingStrategy>(visiblePosition);
 }
 
 VisiblePositionInFlatTree leftPositionOf(const VisiblePositionInFlatTree& visiblePosition)
@@ skipping 58 matching lines @@
                 }
 
                 // Reposition at the other logical position corresponding to our
                 // edge's visual position and go for another round.
                 box = nextBox;
                 layoutObject = LineLayoutAPIShim::layoutObjectFrom(box->getLineLayoutItem());
                 offset = nextBox->caretLeftmostOffset();
                 continue;
             }
 
-            ASSERT(offset == box->caretRightmostOffset());
+            DCHECK_EQ(offset, box->caretRightmostOffset());
 
             unsigned char level = box->bidiLevel();
             InlineBox* nextBox = box->nextLeafChild();
 
             if (box->direction() == primaryDirection) {
                 if (!nextBox) {
                     InlineBox* logicalEnd = 0;
                     if (primaryDirection == LTR ? box->root().getLogicalEndBoxWithNode(logicalEnd) : box->root().getLogicalStartBoxWithNode(logicalEnd)) {
                         box = logicalEnd;
                         layoutObject = LineLayoutAPIShim::layoutObjectFrom(box->getLineLayoutItem());
@@ skipping 65 matching lines @@
                 offset = primaryDirection == LTR ? box->caretMaxOffset() : box->caretMinOffset();
             }
             break;
         }
 
         p = PositionTemplate<Strategy>::editingPositionOf(layoutObject->node(), offset);
 
         if ((isVisuallyEquivalentCandidate(p) && mostForwardCaretPosition(p) != downstreamStart) || p.atStartOfTree() || p.atEndOfTree())
             return p;
 
-        ASSERT(p != deepPosition);
+        DCHECK_NE(p, deepPosition);
     }
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> rightPositionOfAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
     const PositionTemplate<Strategy> pos = rightVisuallyDistinctCandidate(visiblePosition);
     // FIXME: Why can't we move left from the last position in a tree?
     if (pos.atStartOfTree() || pos.atEndOfTree())
         return VisiblePositionTemplate<Strategy>();
 
     const VisiblePositionTemplate<Strategy> right = createVisiblePosition(pos);
-    ASSERT(right.deepEquivalent() != visiblePosition.deepEquivalent());
+    DCHECK_NE(right.deepEquivalent(), visiblePosition.deepEquivalent());
 
     return directionOfEnclosingBlock(right.deepEquivalent()) == LTR ? honorEditingBoundaryAtOrAfter(right, visiblePosition.deepEquivalent()) : honorEditingBoundaryAtOrBefore(right, visiblePosition.deepEquivalent());
 }
 
 VisiblePosition rightPositionOf(const VisiblePosition& visiblePosition)
 {
     return rightPositionOfAlgorithm<EditingStrategy>(visiblePosition);
 }
 
 VisiblePositionInFlatTree rightPositionOf(const VisiblePositionInFlatTree& visiblePosition)
@@ skipping 41 matching lines @@
     // both are non-editable.
     if (highestRootOfPos == highestRoot)
         return pos;
 
     // If this is not editable but |pos| has an editable root, skip to the start
     if (!highestRoot && highestRootOfPos)
         return createVisiblePosition(previousVisuallyDistinctCandidate(PositionTemplate<Strategy>(highestRootOfPos, PositionAnchorType::BeforeAnchor).parentAnchoredEquivalent()));
 
     // That must mean that |pos| is not editable. Return the last position
     // before |pos| that is in the same editable region as this position
-    ASSERT(highestRoot);
+    DCHECK(highestRoot);
     return lastEditableVisiblePositionBeforePositionInRoot(pos.deepEquivalent(), *highestRoot);
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> previousPositionOfAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition, EditingBoundaryCrossingRule rule)
 {
     const PositionTemplate<Strategy> pos = previousVisuallyDistinctCandidate(visiblePosition.deepEquivalent());
 
     // return null visible position if there is no previous visible position
     if (pos.atStartOfTree())
         return VisiblePositionTemplate<Strategy>();
 
     // we should always be able to make the affinity |TextAffinity::Downstream|,
     // because going previous from an |TextAffinity::Upstream| position can
     // never yield another |TextAffinity::Upstream position| (unless line wrap
     // length is 0!).
     const VisiblePositionTemplate<Strategy> prev = createVisiblePosition(pos);
-    ASSERT(prev.deepEquivalent() != visiblePosition.deepEquivalent());
+    DCHECK_NE(prev.deepEquivalent(), visiblePosition.deepEquivalent());
 
     switch (rule) {
     case CanCrossEditingBoundary:
         return prev;
     case CannotCrossEditingBoundary:
         return honorEditingBoundaryAtOrBefore(prev, visiblePosition.deepEquivalent());
     case CanSkipOverEditingBoundary:
         return skipToStartOfEditingBoundary(prev, visiblePosition.deepEquivalent());
     }
 
     ASSERT_NOT_REACHED();
     return honorEditingBoundaryAtOrBefore(prev, visiblePosition.deepEquivalent());
 }
 
 VisiblePosition previousPositionOf(const VisiblePosition& visiblePosition, EditingBoundaryCrossingRule rule)
 {
     return previousPositionOfAlgorithm<EditingStrategy>(visiblePosition, rule);
 }
 
 VisiblePositionInFlatTree previousPositionOf(const VisiblePositionInFlatTree& visiblePosition, EditingBoundaryCrossingRule rule)
 {
     return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(visiblePosition, rule);
 }
 
 } // namespace blink