Replace ASSERT()s with DCHECK*() in core/html/*.{cpp,h}.

third_party/WebKit/Source/core/html/HTMLTextFormControlElement.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 228 matching lines @@
     setValue(text, TextFieldEventBehavior::DispatchNoEvent);
 
     if (selectionMode == "select") {
         newSelectionStart = start;
         newSelectionEnd = start + replacementLength;
     } else if (selectionMode == "start") {
         newSelectionStart = newSelectionEnd = start;
     } else if (selectionMode == "end") {
         newSelectionStart = newSelectionEnd = start + replacementLength;
     } else {
-        ASSERT(selectionMode == "preserve");
+        DCHECK_EQ(selectionMode, "preserve");
         long delta = replacementLength - (end - start);
 
         if (newSelectionStart > end)
             newSelectionStart += delta;
         else if (newSelectionStart > start)
             newSelectionStart = start;
 
         if (newSelectionEnd > end)
             newSelectionEnd += delta;
         else if (newSelectionEnd > start)
@@ skipping 12 matching lines @@
         direction = SelectionHasBackwardDirection;
 
     if (direction == SelectionHasNoDirection && document().frame() && document().frame()->editor().behavior().shouldConsiderSelectionAsDirectional())
         direction = SelectionHasForwardDirection;
 
     return setSelectionRange(start, end, direction);
 }
 
 static Position positionForIndex(HTMLElement* innerEditor, int index)
 {
-    ASSERT(index >= 0);
+    DCHECK_GE(index, 0);
     if (index == 0) {
         Node* node = NodeTraversal::next(*innerEditor, innerEditor);
         if (node && node->isTextNode())
             return Position(node, 0);
         return Position(innerEditor, 0);
     }
     int remainingCharactersToMoveForward = index;
     Node* lastBrOrText = innerEditor;
     for (Node& node : NodeTraversal::descendantsOf(*innerEditor)) {
-        ASSERT(remainingCharactersToMoveForward >= 0);
+        DCHECK_GE(remainingCharactersToMoveForward, 0);
         if (node.hasTagName(brTag)) {
             if (remainingCharactersToMoveForward == 0)
                 return Position::beforeNode(&node);
             --remainingCharactersToMoveForward;
             lastBrOrText = &node;
             continue;
         }
 
         if (node.isTextNode()) {
             Text& text = toText(node);
             if (remainingCharactersToMoveForward < static_cast<int>(text.length()))
                 return Position(&text, remainingCharactersToMoveForward);
             remainingCharactersToMoveForward -= text.length();
             lastBrOrText = &node;
             continue;
         }
 
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
     }
     return lastPositionInOrAfterNode(lastBrOrText);
 }
 
 static int indexForPosition(HTMLElement* innerEditor, const Position& passedPosition)
 {
     if (!innerEditor || !innerEditor->contains(passedPosition.anchorNode()) || passedPosition.isNull())
         return 0;
 
     if (Position::beforeNode(innerEditor) == passedPosition)
         return 0;
 
     int index = 0;
     Node* startNode = passedPosition.computeNodeBeforePosition();
     if (!startNode)
         startNode = passedPosition.computeContainerNode();
-    ASSERT(startNode);
-    ASSERT(innerEditor->contains(startNode));
+    DCHECK(startNode);
+    DCHECK(innerEditor->contains(startNode));
 
     for (Node* node = startNode; node; node = NodeTraversal::previous(*node, innerEditor)) {
         if (node->isTextNode()) {
             int length = toText(*node).length();
             if (node == passedPosition.computeContainerNode())
                 index += std::min(length, passedPosition.offsetInContainerNode());
             else
                 index += length;
         } else if (node->hasTagName(brTag)) {
             ++index;
         }
     }
 
-    ASSERT(index >= 0);
+    DCHECK_GE(index, 0);
     return index;
 }
 
 void HTMLTextFormControlElement::setSelectionRange(int start, int end, TextFieldSelectionDirection direction, NeedToDispatchSelectEvent eventBehaviour, SelectionOption selectionOption)
 {
     if (openShadowRoot() || !isTextFormControl())
         return;
     const int editorValueLength = static_cast<int>(innerEditorValue().length());
-    ASSERT(editorValueLength >= 0);
+    DCHECK_GE(editorValueLength, 0);
     end = std::max(std::min(end, editorValueLength), 0);
     start = std::min(std::max(start, 0), end);
     cacheSelection(start, end, direction);
 
     if (selectionOption == NotChangeSelection || (selectionOption == ChangeSelectionIfFocused && document().focusedElement() != this) || !isConnected()) {
         if (eventBehaviour == DispatchSelectEvent)
             scheduleSelectEvent();
         return;
     }
 
     LocalFrame* frame = document().frame();
     HTMLElement* innerEditor = innerEditorElement();
     if (!frame || !innerEditor)
         return;
 
     Position startPosition = positionForIndex(innerEditor, start);
     Position endPosition = start == end ? startPosition : positionForIndex(innerEditor, end);
 
-    ASSERT(start == indexForPosition(innerEditor, startPosition));
-    ASSERT(end == indexForPosition(innerEditor, endPosition));
+    DCHECK_EQ(start, indexForPosition(innerEditor, startPosition));
+    DCHECK_EQ(end, indexForPosition(innerEditor, endPosition));
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
     // startPosition and endPosition can be null position for example when
     // "-webkit-user-select: none" style attribute is specified.
     if (startPosition.isNotNull() && endPosition.isNotNull()) {
-        ASSERT(startPosition.anchorNode()->shadowHost() == this
-            && endPosition.anchorNode()->shadowHost() == this);
+        DCHECK_EQ(startPosition.anchorNode()->shadowHost(), this);
+        DCHECK_EQ(endPosition.anchorNode()->shadowHost(), this);
     }
-#endif // ENABLE(ASSERT)
+#endif // DCHECK_IS_ON()
     VisibleSelection newSelection;
     if (direction == SelectionHasBackwardDirection)
         newSelection.setWithoutValidation(endPosition, startPosition);
     else
         newSelection.setWithoutValidation(startPosition, endPosition);
     newSelection.setIsDirectional(direction != SelectionHasNoDirection);
 
     frame->selection().setSelection(newSelection, FrameSelection::DoNotAdjustInFlatTree | FrameSelection::CloseTyping | FrameSelection::ClearTypingStyle | (selectionOption == ChangeSelectionAndFocus ? 0 : FrameSelection::DoNotSetFocus));
     if (eventBehaviour == DispatchSelectEvent)
         scheduleSelectEvent();
@@ skipping 10 matching lines @@
     CharacterIterator it(start, end);
     it.advance(index - 1);
     return createVisiblePosition(it.endPosition(), TextAffinity::Upstream);
 }
 
 int HTMLTextFormControlElement::indexForVisiblePosition(const VisiblePosition& pos) const
 {
     Position indexPosition = pos.deepEquivalent().parentAnchoredEquivalent();
     if (enclosingTextFormControl(indexPosition) != this)
         return 0;
-    ASSERT(indexPosition.document());
+    DCHECK(indexPosition.document());
     Range* range = Range::create(*indexPosition.document());
     range->setStart(innerEditorElement(), 0, ASSERT_NO_EXCEPTION);
     range->setEnd(indexPosition.computeContainerNode(), indexPosition.offsetInContainerNode(), ASSERT_NO_EXCEPTION);
     return TextIterator::rangeLength(range->startPosition(), range->endPosition());
 }
 
 int HTMLTextFormControlElement::selectionStart() const
 {
     if (!isTextFormControl())
         return 0;
     if (document().focusedElement() != this)
         return m_cachedSelectionStart;
 
     return computeSelectionStart();
 }
 
 int HTMLTextFormControlElement::computeSelectionStart() const
 {
-    ASSERT(isTextFormControl());
-    LocalFrame* frame = document().frame();
-    if (!frame)
-        return 0;
-
-    return indexForPosition(innerEditorElement(), frame->selection().start());
+    DCHECK(isTextFormControl());
+    if (LocalFrame* frame = document().frame())
+        return indexForPosition(innerEditorElement(), frame->selection().start());
+    return 0;
 }
 
 int HTMLTextFormControlElement::selectionEnd() const
 {
     if (!isTextFormControl())
         return 0;
     if (document().focusedElement() != this)
         return m_cachedSelectionEnd;
     return computeSelectionEnd();
 }
 
 int HTMLTextFormControlElement::computeSelectionEnd() const
 {
-    ASSERT(isTextFormControl());
-    LocalFrame* frame = document().frame();
-    if (!frame)
-        return 0;
-
-    return indexForPosition(innerEditorElement(), frame->selection().end());
+    DCHECK(isTextFormControl());
+    if (LocalFrame* frame = document().frame())
+        return indexForPosition(innerEditorElement(), frame->selection().end());
+    return 0;
 }
 
 static const AtomicString& directionString(TextFieldSelectionDirection direction)
 {
     DEFINE_STATIC_LOCAL(const AtomicString, none, ("none"));
     DEFINE_STATIC_LOCAL(const AtomicString, forward, ("forward"));
     DEFINE_STATIC_LOCAL(const AtomicString, backward, ("backward"));
 
     switch (direction) {
     case SelectionHasNoDirection:
         return none;
     case SelectionHasForwardDirection:
         return forward;
     case SelectionHasBackwardDirection:
         return backward;
     }
 
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return none;
 }
 
 const AtomicString& HTMLTextFormControlElement::selectionDirection() const
 {
     if (!isTextFormControl())
         return directionString(SelectionHasNoDirection);
     if (document().focusedElement() != this)
         return directionString(m_cachedSelectionDirection);
 
     return directionString(computeSelectionDirection());
 }
 
 TextFieldSelectionDirection HTMLTextFormControlElement::computeSelectionDirection() const
 {
-    ASSERT(isTextFormControl());
+    DCHECK(isTextFormControl());
     LocalFrame* frame = document().frame();
     if (!frame)
         return SelectionHasNoDirection;
 
     const VisibleSelection& selection = frame->selection().selection();
     return selection.isDirectional() ? (selection.isBaseFirst() ? SelectionHasForwardDirection : SelectionHasBackwardDirection) : SelectionHasNoDirection;
 }
 
 static inline void setContainerAndOffsetForRange(Node* node, int offset, Node*& containerNode, int& offsetInContainer)
 {
     if (node->isTextNode()) {
         containerNode = node;
         offsetInContainer = offset;
     } else {
         containerNode = node->parentNode();
         offsetInContainer = node->nodeIndex() + offset;
     }
 }
 
 Range* HTMLTextFormControlElement::selection() const
 {
     if (!layoutObject() || !isTextFormControl())
         return nullptr;
 
     int start = m_cachedSelectionStart;
     int end = m_cachedSelectionEnd;
 
-    ASSERT(start <= end);
+    DCHECK_LE(start, end);
     HTMLElement* innerText = innerEditorElement();
     if (!innerText)
         return nullptr;
 
     if (!innerText->hasChildren())
         return Range::create(document(), innerText, 0, innerText, 0);
 
     int offset = 0;
     Node* startNode = 0;
     Node* endNode = 0;
     for (Node& node : NodeTraversal::descendantsOf(*innerText)) {
-        ASSERT(!node.hasChildren());
-        ASSERT(node.isTextNode() || isHTMLBRElement(node));
+        DCHECK(!node.hasChildren());
+        DCHECK(node.isTextNode() || isHTMLBRElement(node));
         int length = node.isTextNode() ? Position::lastOffsetInNode(&node) : 1;
 
         if (offset <= start && start <= offset + length)
             setContainerAndOffsetForRange(&node, start - offset, startNode, start);
 
         if (offset <= end && end <= offset + length) {
             setContainerAndOffsetForRange(&node, end - offset, endNode, end);
             break;
         }
 
@@ skipping 92 matching lines @@
         return;
     Node* lastChild = innerEditor->lastChild();
     if (!lastChild || !lastChild->isTextNode())
         return;
     if (toText(lastChild)->data().endsWith('\n') || toText(lastChild)->data().endsWith('\r'))
         innerEditor->appendChild(createPlaceholderBreakElement());
 }
 
 void HTMLTextFormControlElement::setInnerEditorValue(const String& value)
 {
-    ASSERT(!openShadowRoot());
+    DCHECK(!openShadowRoot());
     if (!isTextFormControl() || openShadowRoot())
         return;
 
     bool textIsChanged = value != innerEditorValue();
     HTMLElement* innerEditor = innerEditorElement();
     if (!textIsChanged && innerEditor->hasChildren())
         return;
 
     // If the last child is a trailing <br> that's appended below, remove it
     // first so as to enable setInnerText() fast path of updating a text node.
@@ skipping 11 matching lines @@
     addPlaceholderBreakElementIfNecessary();
 
     if (textIsChanged && layoutObject()) {
         if (AXObjectCache* cache = document().existingAXObjectCache())
             cache->handleTextFormControlChanged(this);
     }
 }
 
 String HTMLTextFormControlElement::innerEditorValue() const
 {
-    ASSERT(!openShadowRoot());
+    DCHECK(!openShadowRoot());
     HTMLElement* innerEditor = innerEditorElement();
     if (!innerEditor || !isTextFormControl())
         return emptyString();
 
     StringBuilder result;
     for (Node& node : NodeTraversal::inclusiveDescendantsOf(*innerEditor)) {
         if (isHTMLBRElement(node)) {
-            ASSERT(&node == innerEditor->lastChild());
+            DCHECK_EQ(&node, innerEditor->lastChild());
             if (&node != innerEditor->lastChild())
                 result.append(newlineCharacter);
         } else if (node.isTextNode()) {
             result.append(toText(node).data());
         }
     }
     return result.toString();
 }
 
 static void getNextSoftBreak(RootInlineBox*& line, Node*& breakNode, unsigned& breakOffset)
 {
     RootInlineBox* next;
     for (; line; line = next) {
         next = line->nextRootBox();
         if (next && !line->endsWithBreak()) {
-            ASSERT(line->lineBreakObj());
+            DCHECK(line->lineBreakObj());
             breakNode = line->lineBreakObj().node();
             breakOffset = line->lineBreakPos();
             line = next;
             return;
         }
     }
     breakNode = 0;
     breakOffset = 0;
 }
 
@@ skipping 13 matching lines @@
     unsigned breakOffset;
     RootInlineBox* line = layoutObject->firstRootBox();
     if (!line)
         return value();
 
     getNextSoftBreak(line, breakNode, breakOffset);
 
     StringBuilder result;
     for (Node& node : NodeTraversal::descendantsOf(*innerText)) {
         if (isHTMLBRElement(node)) {
-            ASSERT(&node == innerText->lastChild());
+            DCHECK_EQ(&node, innerText->lastChild());
             if (&node != innerText->lastChild())
                 result.append(newlineCharacter);
         } else if (node.isTextNode()) {
             String data = toText(node).data();
             unsigned length = data.length();
             unsigned position = 0;
             while (breakNode == node && breakOffset <= length) {
                 if (breakOffset > position) {
                     result.append(data, position, breakOffset - position);
                     position = breakOffset;
                     result.append(newlineCharacter);
                 }
                 getNextSoftBreak(line, breakNode, breakOffset);
             }
             result.append(data, position, length - position);
         }
         while (breakNode == node)
             getNextSoftBreak(line, breakNode, breakOffset);
     }
     return result.toString();
 }
 
 HTMLTextFormControlElement* enclosingTextFormControl(const Position& position)
 {
-    ASSERT(position.isNull() || position.isOffsetInAnchor()
+    DCHECK(position.isNull() || position.isOffsetInAnchor()
         || position.computeContainerNode() || !position.anchorNode()->shadowHost()
         || (position.anchorNode()->parentNode() && position.anchorNode()->parentNode()->isShadowRoot()));
     return enclosingTextFormControl(position.computeContainerNode());
 }
 
 HTMLTextFormControlElement* enclosingTextFormControl(Node* container)
 {
     if (!container)
         return nullptr;
     Element* ancestor = container->shadowHost();
@@ skipping 20 matching lines @@
     return "ltr";
 }
 
 HTMLElement* HTMLTextFormControlElement::innerEditorElement() const
 {
     return toHTMLElement(userAgentShadowRoot()->getElementById(ShadowElementNames::innerEditor()));
 }
 
 static Position innerNodePosition(const Position& innerPosition)
 {
-    ASSERT(!innerPosition.isBeforeAnchor());
-    ASSERT(!innerPosition.isAfterAnchor());
+    DCHECK(!innerPosition.isBeforeAnchor());
+    DCHECK(!innerPosition.isAfterAnchor());
     HTMLElement* element = toHTMLElement(innerPosition.anchorNode());
-    ASSERT(element);
+    DCHECK(element);
     NodeList* childNodes = element->childNodes();
     if (!childNodes->length())
         return Position(element, 0);
 
     unsigned offset = 0;
 
     if (innerPosition.isOffsetInAnchor())
         offset = std::max(0, std::min(innerPosition.offsetInContainerNode(), static_cast<int>(childNodes->length())));
     else if (innerPosition.isAfterChildren())
         offset = childNodes->length();
@@ skipping 13 matching lines @@
     FindEnd
 };
 
 static Position findWordBoundary(const HTMLElement* innerEditor, const Position& startPosition, const Position& endPosition, FindOption findOption)
 {
     StringBuilder concatTexts;
     Vector<unsigned> lengthList;
     HeapVector<Member<Text>> textList;
 
     if (startPosition.anchorNode()->isTextNode())
-        ASSERT(startPosition.isOffsetInAnchor());
+        DCHECK(startPosition.isOffsetInAnchor());
     if (endPosition.anchorNode()->isTextNode())
-        ASSERT(endPosition.isOffsetInAnchor());
+        DCHECK(endPosition.isOffsetInAnchor());
 
     // Traverse text nodes.
     for (Node* node = startPosition.anchorNode(); node; node = NodeTraversal::next(*node, innerEditor)) {
         bool isStartNode = node == startPosition.anchorNode();
         bool isEndNode = node == endPosition.anchorNode();
         if (node->isTextNode()) {
             Text* text = toText(node);
             const unsigned start = isStartNode ? startPosition.offsetInContainerNode() : 0;
             const unsigned end = isEndNode ? endPosition.offsetInContainerNode() : text->data().length();
             const unsigned length = end - start;
@@ skipping 14 matching lines @@
     if (findOption == FindEnd && concatTexts[0] == '\n') {
         // findWordBoundary("\ntext", 0, &start, &end) assigns 1 to |end| but
         // we expect 0 at the case.
         start = 0;
         end = 0;
     } else {
         Vector<UChar> characters;
         concatTexts.toString().appendTo(characters);
         findWordBoundary(characters.data(), characters.size(), findOption == FindStart ? characters.size() : 0, &start, &end);
     }
-    ASSERT(start >= 0);
-    ASSERT(end >= 0);
+    DCHECK_GE(start, 0);
+    DCHECK_GE(end, 0);
     unsigned remainingOffset = findOption == FindStart ? start : end;
     // Find position.
     for (unsigned i = 0; i < lengthList.size(); ++i) {
         if (remainingOffset <= lengthList[i])
             return Position(textList[i], (textList[i] == startPosition.anchorNode()) ? remainingOffset + startPosition.offsetInContainerNode() : remainingOffset);
         remainingOffset -= lengthList[i];
     }
 
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return Position();
 }
 
 Position HTMLTextFormControlElement::startOfWord(const Position& position)
 {
     const HTMLTextFormControlElement* textFormControl = enclosingTextFormControl(position);
-    ASSERT(textFormControl);
+    DCHECK(textFormControl);
     HTMLElement* innerEditor = textFormControl->innerEditorElement();
 
     const Position startPosition = startOfSentence(position);
     if (startPosition == position)
         return position;
     const Position endPosition = (position.anchorNode() == innerEditor) ? innerNodePosition(position) : position;
 
     return findWordBoundary(innerEditor, startPosition, endPosition, FindStart);
 }
 
 Position HTMLTextFormControlElement::endOfWord(const Position& position)
 {
     const HTMLTextFormControlElement* textFormControl = enclosingTextFormControl(position);
-    ASSERT(textFormControl);
+    DCHECK(textFormControl);
     HTMLElement* innerEditor = textFormControl->innerEditorElement();
 
     const Position endPosition = endOfSentence(position);
     if (endPosition == position)
         return position;
     const Position startPosition = (position.anchorNode() == innerEditor) ? innerNodePosition(position) : position;
 
     return findWordBoundary(innerEditor, startPosition, endPosition, FindEnd);
 }
 
@@ skipping 18 matching lines @@
         return Position();
 
     // Move back if position is just after line break.
     if (isHTMLBRElement(*position.anchorNode())) {
         if (position.isAfterAnchor())
             return Position(position.anchorNode(), PositionAnchorType::BeforeAnchor);
         if (position.isBeforeAnchor())
             return previousIfPositionIsAfterLineBreak(endOfPrevious(*position.anchorNode(), innerEditor), innerEditor);
         // We don't place caret into BR element, since well-formed BR element
         // doesn't have child nodes.
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
         return position;
     }
 
     if (!position.anchorNode()->isTextNode())
         return position;
 
     Text* textNode = toText(position.anchorNode());
     unsigned offset = position.offsetInContainerNode();
     if (textNode->length() == 0 || offset == 0)
         return previousIfPositionIsAfterLineBreak(endOfPrevious(*position.anchorNode(), innerEditor), innerEditor);
 
     if (offset <= textNode->length() && textNode->data()[offset - 1] == '\n')
         return Position(textNode, offset - 1);
 
     return position;
 }
 
 static inline Position startOfInnerText(const HTMLTextFormControlElement* textFormControl)
 {
     return Position(textFormControl->innerEditorElement(), 0);
 }
 
 Position HTMLTextFormControlElement::startOfSentence(const Position& position)
 {
     HTMLTextFormControlElement* textFormControl = enclosingTextFormControl(position);
-    ASSERT(textFormControl);
+    DCHECK(textFormControl);
 
     HTMLElement* innerEditor = textFormControl->innerEditorElement();
     if (!innerEditor->childNodes()->length())
         return startOfInnerText(textFormControl);
 
     const Position innerPosition = position.anchorNode() == innerEditor ? innerNodePosition(position) : position;
     const Position pivotPosition = previousIfPositionIsAfterLineBreak(innerPosition, innerEditor);
     if (pivotPosition.isNull())
         return startOfInnerText(textFormControl);
 
@@ skipping 15 matching lines @@
 
 static Position endOfInnerText(const HTMLTextFormControlElement* textFormControl)
 {
     HTMLElement* innerEditor = textFormControl->innerEditorElement();
     return Position(innerEditor, innerEditor->childNodes()->length());
 }
 
 Position HTMLTextFormControlElement::endOfSentence(const Position& position)
 {
     HTMLTextFormControlElement* textFormControl = enclosingTextFormControl(position);
-    ASSERT(textFormControl);
+    DCHECK(textFormControl);
 
     HTMLElement* innerEditor = textFormControl->innerEditorElement();
     if (innerEditor->childNodes()->length() == 0)
         return startOfInnerText(textFormControl);
 
     const Position pivotPosition = position.anchorNode() == innerEditor ? innerNodePosition(position) : position;
     if (pivotPosition.isNull())
         return startOfInnerText(textFormControl);
 
     for (Node* node = pivotPosition.anchorNode(); node; node = NodeTraversal::next(*node, innerEditor)) {
@@ skipping 13 matching lines @@
 }
 
 void HTMLTextFormControlElement::copyNonAttributePropertiesFromElement(const Element& source)
 {
     const HTMLTextFormControlElement& sourceElement = static_cast<const HTMLTextFormControlElement&>(source);
     m_lastChangeWasUserEdit = sourceElement.m_lastChangeWasUserEdit;
     HTMLFormControlElement::copyNonAttributePropertiesFromElement(source);
 }
 
 } // namespace blink