ASSERT -> DCHECK in 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 69 matching lines @@
 // 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)
 {
-    ASSERT(containerA);
-    ASSERT(containerB);
+    DCHECK(containerA);
+    DCHECK(containerB);
 
     if (disconnected)
         *disconnected = false;
 
     if (!containerA)
         return -1;
     if (!containerB)
         return 1;
 
     // see DOM2 traversal & range section 2.5
@@ skipping 84 matching lines @@
 
 int comparePositionsInFlatTree(Node* containerA, int offsetA, Node* containerB, int offsetB, bool* disconnected)
 {
     return comparePositions<FlatTreeTraversal>(containerA, offsetA, containerB, offsetB, disconnected);
 }
 
 // Compare two positions, taking into account the possibility that one or both
 // could be inside a shadow tree. Only works for non-null values.
 int comparePositions(const Position& a, const Position& b)
 {
-    ASSERT(a.isNotNull());
-    ASSERT(b.isNotNull());
+    DCHECK(a.isNotNull());
+    DCHECK(b.isNotNull());
     const TreeScope* commonScope = Position::commonAncestorTreeScope(a, b);
 
-    ASSERT(commonScope);
+    DCHECK(commonScope);
     if (!commonScope)
         return 0;
 
     Node* nodeA = commonScope->ancestorInThisScope(a.computeContainerNode());
-    ASSERT(nodeA);
+    DCHECK(nodeA);
     bool hasDescendentA = nodeA != a.computeContainerNode();
     int offsetA = hasDescendentA ? 0 : a.computeOffsetInContainerNode();
 
     Node* nodeB = commonScope->ancestorInThisScope(b.computeContainerNode());
-    ASSERT(nodeB);
+    DCHECK(nodeB);
     bool hasDescendentB = nodeB != b.computeContainerNode();
     int offsetB = hasDescendentB ? 0 : b.computeOffsetInContainerNode();
 
     int bias = 0;
     if (nodeA == nodeB) {
         if (hasDescendentA)
             bias = -1;
         else if (hasDescendentB)
             bias = 1;
     }
@@ skipping 42 matching lines @@
 }
 
 bool isEditablePosition(const Position& p, EditableType editableType, EUpdateStyle updateStyle)
 {
     Node* node = p.parentAnchoredEquivalent().anchorNode();
     if (!node)
         return false;
     if (updateStyle == UpdateStyle)
         node->document().updateLayoutIgnorePendingStylesheets();
     else
-        ASSERT(updateStyle == DoNotUpdateStyle);
+        DCHECK_EQ(updateStyle, DoNotUpdateStyle);
 
     if (isDisplayInsideTable(node))
         node = node->parentNode();
 
     if (node->isDocumentNode())
         return false;
     return node->hasEditableStyle(editableType);
 }
 
 bool isEditablePosition(const PositionInFlatTree& p, EditableType editableType, EUpdateStyle updateStyle)
@@ skipping 388 matching lines @@
 }
 
 PositionInFlatTree previousPositionOf(const PositionInFlatTree& position, PositionMoveType moveType)
 {
     return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(position, moveType);
 }
 
 template <typename Strategy>
 PositionTemplate<Strategy> nextPositionOfAlgorithm(const PositionTemplate<Strategy>& position, PositionMoveType moveType)
 {
-    ASSERT(moveType != PositionMoveType::BackwardDeletion);
+    DCHECK(moveType == PositionMoveType::BackwardDeletion);
 
     Node* node = position.anchorNode();
     if (!node)
         return position;
 
     const int offset = position.computeEditingOffset();
 
     if (Node* child = Strategy::childAt(*node, offset))
         return PositionTemplate<Strategy>::firstPositionInOrBeforeNode(child);
 
@@ skipping 143 matching lines @@
 
         if (previousCharacterWasSpace || (!i && startIsStartOfParagraph) || (i + 1 == length && endIsEndOfParagraph)) {
             rebalancedString.append(noBreakSpaceCharacter);
             previousCharacterWasSpace = false;
         } else {
             rebalancedString.append(' ');
             previousCharacterWasSpace = true;
         }
     }
 
-    ASSERT(rebalancedString.length() == length);
+    DCHECK_EQ(rebalancedString.length(), length);
 
     return rebalancedString.toString();
 }
 
 bool isTableStructureNode(const Node *node)
 {
     LayoutObject* layoutObject = node->layoutObject();
     return (layoutObject && (layoutObject->isTableCell() || layoutObject->isTableRow() || layoutObject->isTableSection() || layoutObject->isLayoutTableCol()));
 }
 
@@ skipping 159 matching lines @@
         node = nextNodeConsideringAtomicNodes(*node);
     }
     return nullptr;
 }
 
 // Returns the visible position at the beginning of a node
 VisiblePosition visiblePositionBeforeNode(Node& node)
 {
     if (node.hasChildren())
         return createVisiblePosition(firstPositionInOrBeforeNode(&node));
-    ASSERT(node.parentNode());
-    ASSERT(!node.parentNode()->isShadowRoot());
+    DCHECK(node.parentNode());
+    DCHECK(!node.parentNode()->isShadowRoot());
     return createVisiblePosition(positionInParentBeforeNode(node));
 }
 
 // Returns the visible position at the ending of a node
 VisiblePosition visiblePositionAfterNode(Node& node)
 {
     if (node.hasChildren())
         return createVisiblePosition(lastPositionInOrAfterNode(&node));
-    ASSERT(node.parentNode());
-    ASSERT(!node.parentNode()->isShadowRoot());
+    DCHECK(node.parentNode());
+    DCHECK(!node.parentNode()->isShadowRoot());
     return createVisiblePosition(positionInParentAfterNode(node));
 }
 
 bool isHTMLListElement(Node* n)
 {
     return (n && (isHTMLUListElement(*n) || isHTMLOListElement(*n) || isHTMLDListElement(*n)));
 }
 
 bool isListItem(const Node* n)
 {
@@ skipping 25 matching lines @@
             return 0;
     }
 
     return 0;
 }
 
 template <typename Strategy>
 static Node* enclosingNodeOfTypeAlgorithm(const PositionTemplate<Strategy>& p, bool (*nodeIsOfType)(const Node*), EditingBoundaryCrossingRule rule)
 {
     // TODO(yosin) support CanSkipCrossEditingBoundary
-    ASSERT(rule == CanCrossEditingBoundary || rule == CannotCrossEditingBoundary);
+    DCHECK(rule == CanCrossEditingBoundary || rule == CannotCrossEditingBoundary);
     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.
         if (root && !n->hasEditableStyle())
             continue;
         if (nodeIsOfType(n))
@@ skipping 167 matching lines @@
 {
     if (!node || !node->isElementNode())
         return false;
 
     LayoutObject* layoutObject = node->layoutObject();
     return (layoutObject && layoutObject->isTable());
 }
 
 bool isTableCell(const Node* node)
 {
-    ASSERT(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
     //   .) the BR child of such a table cell
@@ skipping 125 matching lines @@
             return currentPos;
         }
     }
 
     return position;
 }
 
 // This assumes that it starts in editable content.
 Position leadingWhitespacePosition(const Position& position, TextAffinity affinity, WhitespacePositionOption option)
 {
-    ASSERT(isEditablePosition(position, ContentIsEditable, DoNotUpdateStyle));
+    DCHECK(isEditablePosition(position, ContentIsEditable, DoNotUpdateStyle));
     if (position.isNull())
         return Position();
 
     if (isHTMLBRElement(*mostBackwardCaretPosition(position).anchorNode()))
         return Position();
 
     const Position& prev = previousCharacterPosition(position, affinity);
     if (prev == position)
         return Position();
     const Node* const anchorNode = prev.anchorNode();
     if (!anchorNode || !anchorNode->isTextNode())
         return Position();
     if (enclosingBlockFlowElement(*anchorNode) != enclosingBlockFlowElement(*position.anchorNode()))
         return Position();
     if (option == NotConsiderNonCollapsibleWhitespace && anchorNode->layoutObject() && !anchorNode->layoutObject()->style()->collapseWhiteSpace())
         return Position();
     const String& string = toText(anchorNode)->data();
     const UChar previousCharacter = string[prev.computeOffsetInContainerNode()];
     const bool isSpace = option == ConsiderNonCollapsibleWhitespace ? (isSpaceOrNewline(previousCharacter) || previousCharacter == noBreakSpaceCharacter) : isCollapsibleWhitespace(previousCharacter);
     if (!isSpace || !isEditablePosition(prev))
         return Position();
     return prev;
 }
 
 // This assumes that it starts in editable content.
 Position trailingWhitespacePosition(const Position& position, TextAffinity, WhitespacePositionOption option)
 {
-    ASSERT(isEditablePosition(position, ContentIsEditable, DoNotUpdateStyle));
+    DCHECK(isEditablePosition(position, ContentIsEditable, DoNotUpdateStyle));
     if (position.isNull())
         return Position();
 
     VisiblePosition visiblePosition = createVisiblePosition(position);
     UChar characterAfterVisiblePosition = characterAfter(visiblePosition);
     bool isSpace = option == ConsiderNonCollapsibleWhitespace ? (isSpaceOrNewline(characterAfterVisiblePosition) || characterAfterVisiblePosition == noBreakSpaceCharacter) : isCollapsibleWhitespace(characterAfterVisiblePosition);
     // The space must not be in another paragraph and it must be editable.
     if (isSpace && !isEndOfParagraph(visiblePosition) && nextPositionOf(visiblePosition, CannotCrossEditingBoundary).isNotNull())
         return position;
     return Position();
@@ skipping 136 matching lines @@
     Position e = end.deepEquivalent().parentAnchoredEquivalent();
     if (s.isNull() || e.isNull())
         return EphemeralRange();
 
     return EphemeralRange(s, e);
 }
 
 template <typename Strategy>
 static EphemeralRangeTemplate<Strategy> normalizeRangeAlgorithm(const EphemeralRangeTemplate<Strategy>& range)
 {
-    ASSERT(range.isNotNull());
+    DCHECK(range.isNotNull());
     range.document().updateLayoutIgnorePendingStylesheets();
 
     // TODO(yosin) We should not call |parentAnchoredEquivalent()|, it is
     // redundant.
     const PositionTemplate<Strategy> normalizedStart = mostForwardCaretPosition(range.startPosition()).parentAnchoredEquivalent();
     const PositionTemplate<Strategy> normalizedEnd = mostBackwardCaretPosition(range.endPosition()).parentAnchoredEquivalent();
     // The order of the positions of |start| and |end| can be swapped after
     // upstream/downstream. e.g. editing/pasteboard/copy-display-none.html
     if (normalizedStart.compareTo(normalizedEnd) > 0)
         return EphemeralRangeTemplate<Strategy>(normalizedEnd, normalizedStart);
@@ skipping 114 matching lines @@
     // instead of possibly at the end of the last node before the selection
     return mostForwardCaretPosition(visiblePosition.deepEquivalent());
 }
 
 bool isTextSecurityNode(const Node* node)
 {
     return node && node->layoutObject() && node->layoutObject()->style()->textSecurity() != TSNONE;
 }
 
 } // namespace blink