ASSERT -> DCHECK in core/editing.

third_party/WebKit/Source/core/editing/commands/CompositeEditCommand.cpp

 /*
  * Copyright (C) 2005, 2006, 2007, 2008 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 78 matching lines @@
     , m_startingSelection(startingSelection)
     , m_endingSelection(endingSelection)
     , m_startingRootEditableElement(startingSelection.rootEditableElement())
     , m_endingRootEditableElement(endingSelection.rootEditableElement())
     , m_editAction(editAction)
 {
 }
 
 bool EditCommandComposition::belongsTo(const LocalFrame& frame) const
 {
-    ASSERT(m_document);
+    DCHECK(m_document);
     return m_document->frame() == &frame;
 }
 
 void EditCommandComposition::unapply()
 {
-    ASSERT(m_document);
+    DCHECK(m_document);
     RawPtr<LocalFrame> frame = m_document->frame();
-    ASSERT(frame);
+    DCHECK(frame);
 
     // Changes to the document may have been made since the last editing operation that require a layout, as in <rdar://problem/5658603>.
     // Low level operations, like RemoveNodeCommand, don't require a layout because the high level operations that use them perform one
     // if one is necessary (like for the creation of VisiblePositions).
     m_document->updateLayoutIgnorePendingStylesheets();
 
     {
         size_t size = m_commands.size();
         for (size_t i = size; i; --i)
             m_commands[i - 1]->doUnapply();
     }
 
     frame->editor().unappliedEditing(this);
 }
 
 void EditCommandComposition::reapply()
 {
-    ASSERT(m_document);
+    DCHECK(m_document);
     RawPtr<LocalFrame> frame = m_document->frame();
-    ASSERT(frame);
+    DCHECK(frame);
 
     // Changes to the document may have been made since the last editing operation that require a layout, as in <rdar://problem/5658603>.
     // Low level operations, like RemoveNodeCommand, don't require a layout because the high level operations that use them perform one
     // if one is necessary (like for the creation of VisiblePositions).
     m_document->updateLayoutIgnorePendingStylesheets();
 
     {
         for (const auto& command : m_commands)
             command->doReapply();
     }
@@ skipping 29 matching lines @@
     UndoStep::trace(visitor);
 }
 
 CompositeEditCommand::CompositeEditCommand(Document& document)
     : EditCommand(document)
 {
 }
 
 CompositeEditCommand::~CompositeEditCommand()
 {
-    ASSERT(isTopLevelCommand() || !m_composition);
+    DCHECK(isTopLevelCommand() || !m_composition);
 }
 
 bool CompositeEditCommand::apply()
 {
     if (!endingSelection().isContentRichlyEditable()) {
         switch (editingAction()) {
         case EditActionTyping:
         case EditActionPaste:
         case EditActionDrag:
         case EditActionSetWritingDirection:
         case EditActionCut:
         case EditActionUnspecified:
             break;
         default:
             ASSERT_NOT_REACHED();
             return false;
         }
     }
     ensureComposition();
 
     // Changes to the document may have been made since the last editing operation that require a layout, as in <rdar://problem/5658603>.
     // Low level operations, like RemoveNodeCommand, don't require a layout because the high level operations that use them perform one
     // if one is necessary (like for the creation of VisiblePositions).
     document().updateLayoutIgnorePendingStylesheets();
 
     LocalFrame* frame = document().frame();
-    ASSERT(frame);
+    DCHECK(frame);
     EditingState editingState;
     {
         EventQueueScope eventQueueScope;
         doApply(&editingState);
     }
 
     // Only need to call appliedEditing for top-level commands,
     // and TypingCommands do it on their own (see TypingCommand::typingAddedToOpenCommand).
     if (!isTypingCommand())
         frame->editor().appliedEditing(this);
@@ skipping 81 matching lines @@
     applyCommandToComposite(ApplyStyleCommand::create(element, true), editingState);
 }
 
 void CompositeEditCommand::insertParagraphSeparator(EditingState* editingState, bool useDefaultParagraphElement, bool pasteBlockqutoeIntoUnquotedArea)
 {
     applyCommandToComposite(InsertParagraphSeparatorCommand::create(document(), useDefaultParagraphElement, pasteBlockqutoeIntoUnquotedArea), editingState);
 }
 
 bool CompositeEditCommand::isRemovableBlock(const Node* node)
 {
-    ASSERT(node);
+    DCHECK(node);
     if (!isHTMLDivElement(*node))
         return false;
 
     const HTMLDivElement& element = toHTMLDivElement(*node);
     ContainerNode* parentNode = element.parentNode();
     if (parentNode && parentNode->firstChild() != parentNode->lastChild())
         return false;
 
     if (!element.hasAttributes())
         return true;
 
     return false;
 }
 
 void CompositeEditCommand::insertNodeBefore(RawPtr<Node> insertChild, RawPtr<Node> refChild, EditingState* editingState, ShouldAssumeContentIsAlwaysEditable shouldAssumeContentIsAlwaysEditable)
 {
-    ASSERT(document().body() != refChild);
+    DCHECK_NE(document().body(), refChild);
     ABORT_EDITING_COMMAND_IF(!refChild->parentNode()->hasEditableStyle() && refChild->parentNode()->inActiveDocument());
     applyCommandToComposite(InsertNodeBeforeCommand::create(insertChild, refChild, shouldAssumeContentIsAlwaysEditable), editingState);
 }
 
 void CompositeEditCommand::insertNodeAfter(RawPtr<Node> insertChild, RawPtr<Node> refChild, EditingState* editingState)
 {
-    ASSERT(insertChild);
-    ASSERT(refChild);
-    ASSERT(document().body() != refChild);
+    DCHECK(insertChild);
+    DCHECK(refChild);
+    DCHECK_NE(document().body(), refChild);
     ContainerNode* parent = refChild->parentNode();
-    ASSERT(parent);
-    ASSERT(!parent->isShadowRoot());
+    DCHECK(parent);
+    DCHECK(!parent->isShadowRoot());
     if (parent->lastChild() == refChild) {
         appendNode(insertChild, parent, editingState);
     } else {
-        ASSERT(refChild->nextSibling());
+        DCHECK(refChild->nextSibling());
         insertNodeBefore(insertChild, refChild->nextSibling(), editingState);
     }
 }
 
 void CompositeEditCommand::insertNodeAt(RawPtr<Node> insertChild, const Position& editingPosition, EditingState* editingState)
 {
     ABORT_EDITING_COMMAND_IF(!isEditablePosition(editingPosition, ContentIsEditable, DoNotUpdateStyle));
     // For editing positions like [table, 0], insert before the table,
     // likewise for replaced elements, brs, etc.
     Position p = editingPosition.parentAnchoredEquivalent();
@@ skipping 63 matching lines @@
 }
 
 void CompositeEditCommand::removeNodePreservingChildren(RawPtr<Node> node, EditingState* editingState, ShouldAssumeContentIsAlwaysEditable shouldAssumeContentIsAlwaysEditable)
 {
     ABORT_EDITING_COMMAND_IF(!node->document().frame());
     applyCommandToComposite(RemoveNodePreservingChildrenCommand::create(node, shouldAssumeContentIsAlwaysEditable), editingState);
 }
 
 void CompositeEditCommand::removeNodeAndPruneAncestors(RawPtr<Node> node, EditingState* editingState, Node* excludeNode)
 {
-    ASSERT(node.get() != excludeNode);
+    DCHECK_NE(node.get(), excludeNode);
     RawPtr<ContainerNode> parent = node->parentNode();
     removeNode(node, editingState);
     if (editingState->isAborted())
         return;
     prune(parent.release(), editingState, excludeNode);
 }
 
 void CompositeEditCommand::moveRemainingSiblingsToNewParent(Node* node, Node* pastLastNodeToMove, RawPtr<Element> prpNewParent, EditingState* editingState)
 {
     NodeVector nodesToRemove;
@@ skipping 25 matching lines @@
 {
     // It would also be possible to implement all of ReplaceNodeWithSpanCommand
     // as a series of existing smaller edit commands.  Someone who wanted to
     // reduce the number of edit commands could do so here.
     RawPtr<ReplaceNodeWithSpanCommand> command = ReplaceNodeWithSpanCommand::create(node);
     // ReplaceNodeWithSpanCommand is never aborted.
     applyCommandToComposite(command, ASSERT_NO_EDITING_ABORT);
     // Returning a raw pointer here is OK because the command is retained by
     // applyCommandToComposite (thus retaining the span), and the span is also
     // in the DOM tree, and thus alive whie it has a parent.
-    ASSERT(command->spanElement()->inShadowIncludingDocument());
+    DCHECK(command->spanElement()->inShadowIncludingDocument());
     return command->spanElement();
 }
 
 void CompositeEditCommand::prune(RawPtr<Node> node, EditingState* editingState, Node* excludeNode)
 {
     if (RawPtr<Node> highestNodeToRemove = highestNodeToRemoveInPruning(node.get(), excludeNode))
         removeNode(highestNodeToRemove.release(), editingState);
 }
 
 void CompositeEditCommand::splitTextNode(RawPtr<Text> node, unsigned offset)
 {
     // SplitTextNodeCommand is never aborted.
     applyCommandToComposite(SplitTextNodeCommand::create(node, offset), ASSERT_NO_EDITING_ABORT);
 }
 
 void CompositeEditCommand::splitElement(RawPtr<Element> element, RawPtr<Node> atChild)
 {
     // SplitElementCommand is never aborted.
     applyCommandToComposite(SplitElementCommand::create(element, atChild), ASSERT_NO_EDITING_ABORT);
 }
 
 void CompositeEditCommand::mergeIdenticalElements(RawPtr<Element> prpFirst, RawPtr<Element> prpSecond, EditingState* editingState)
 {
     RawPtr<Element> first = prpFirst;
     RawPtr<Element> second = prpSecond;
-    ASSERT(!first->isDescendantOf(second.get()) && second != first);
+    DCHECK(!first->isDescendantOf(second.get()) && second != first);
     if (first->nextSibling() != second) {
         removeNode(second, editingState);
         if (editingState->isAborted())
             return;
         insertNodeAfter(second, first, editingState);
         if (editingState->isAborted())
             return;
     }
     applyCommandToComposite(MergeIdenticalElementsCommand::create(first, second), editingState);
 }
@@ skipping 60 matching lines @@
 void CompositeEditCommand::replaceTextInNodePreservingMarkers(RawPtr<Text> prpNode, unsigned offset, unsigned count, const String& replacementText)
 {
     RawPtr<Text> node(prpNode);
     DocumentMarkerController& markerController = document().markers();
     Vector<DocumentMarker::MarkerType> types;
     Vector<String> descriptions;
     copyMarkerTypesAndDescriptions(markerController.markersInRange(EphemeralRange(Position(node.get(), offset), Position(node.get(), offset + count)), DocumentMarker::AllMarkers()), types, descriptions);
     replaceTextInNode(node, offset, count, replacementText);
     Position startPosition(node.get(), offset);
     Position endPosition(node.get(), offset + replacementText.length());
-    ASSERT(types.size() == descriptions.size());
+    DCHECK_EQ(types.size(), descriptions.size());
     for (size_t i = 0; i < types.size(); ++i)
         markerController.addMarker(startPosition, endPosition, types[i], descriptions[i]);
 }
 
 Position CompositeEditCommand::positionOutsideTabSpan(const Position& pos)
 {
     if (!isTabHTMLSpanElementTextNode(pos.anchorNode()))
         return pos;
 
     switch (pos.anchorType()) {
     case PositionAnchorType::BeforeChildren:
     case PositionAnchorType::AfterChildren:
         ASSERT_NOT_REACHED();
         return pos;
     case PositionAnchorType::OffsetInAnchor:
         break;
     case PositionAnchorType::BeforeAnchor:
         return positionInParentBeforeNode(*pos.anchorNode());
     case PositionAnchorType::AfterAnchor:
         return positionInParentAfterNode(*pos.anchorNode());
     }
 
     HTMLSpanElement* tabSpan = tabSpanElement(pos.computeContainerNode());
-    ASSERT(tabSpan);
+    DCHECK(tabSpan);
 
     if (pos.offsetInContainerNode() <= caretMinOffset(pos.computeContainerNode()))
         return positionInParentBeforeNode(*tabSpan);
 
     if (pos.offsetInContainerNode() >= caretMaxOffset(pos.computeContainerNode()))
         return positionInParentAfterNode(*tabSpan);
 
     splitTextNodeContainingElement(toText(pos.computeContainerNode()), pos.offsetInContainerNode());
     return positionInParentBeforeNode(*tabSpan);
 }
@@ skipping 82 matching lines @@
     }
 
     rebalanceWhitespaceOnTextSubstring(toText(node), position.offsetInContainerNode(), position.offsetInContainerNode());
 }
 
 void CompositeEditCommand::rebalanceWhitespaceOnTextSubstring(RawPtr<Text> prpTextNode, int startOffset, int endOffset)
 {
     RawPtr<Text> textNode = prpTextNode;
 
     String text = textNode->data();
-    ASSERT(!text.isEmpty());
+    DCHECK(!text.isEmpty());
 
     // Set upstream and downstream to define the extent of the whitespace surrounding text[offset].
     int upstream = startOffset;
     while (upstream > 0 && isWhitespace(text[upstream - 1]))
         upstream--;
 
     int downstream = endOffset;
     while ((unsigned)downstream < text.length() && isWhitespace(text[downstream]))
         downstream++;
 
@@ skipping 133 matching lines @@
     }
 
     if (!str.isNull()) {
         // Replace the text between start and end with our pruned version.
         if (!str.isEmpty()) {
             replaceTextInNode(textNode, start, end - start, str);
         } else {
             // Assert that we are not going to delete all of the text in the node.
             // If we were, that should have been done above with the call to
             // removeNode and return.
-            ASSERT(start > 0 || end - start < textNode->length());
+            DCHECK(start > 0 || end - start < textNode->length());
             deleteTextFromNode(textNode, start, end - start);
         }
     }
 }
 
 void CompositeEditCommand::deleteInsignificantText(const Position& start, const Position& end)
 {
     if (start.isNull() || end.isNull())
         return;
 
@@ skipping 23 matching lines @@
 }
 
 RawPtr<HTMLBRElement> CompositeEditCommand::appendBlockPlaceholder(RawPtr<Element> container, EditingState* editingState)
 {
     if (!container)
         return nullptr;
 
     document().updateLayoutIgnorePendingStylesheets();
 
     // Should assert isLayoutBlockFlow || isInlineFlow when deletion improves. See 4244964.
-    ASSERT(container->layoutObject());
+    DCHECK(container->layoutObject());
 
     RawPtr<HTMLBRElement> placeholder = HTMLBRElement::create(document());
     appendNode(placeholder, container, editingState);
     if (editingState->isAborted())
         return nullptr;
     return placeholder.release();
 }
 
 RawPtr<HTMLBRElement> CompositeEditCommand::insertBlockPlaceholder(const Position& pos, EditingState* editingState)
 {
     if (pos.isNull())
         return nullptr;
 
     // Should assert isLayoutBlockFlow || isInlineFlow when deletion improves. See 4244964.
-    ASSERT(pos.anchorNode()->layoutObject());
+    DCHECK(pos.anchorNode()->layoutObject());
 
     RawPtr<HTMLBRElement> placeholder = HTMLBRElement::create(document());
     insertNodeAt(placeholder, pos, editingState);
     if (editingState->isAborted())
         return nullptr;
     return placeholder.release();
 }
 
 RawPtr<HTMLBRElement> CompositeEditCommand::addBlockPlaceholderIfNeeded(Element* container, EditingState* editingState)
 {
@@ skipping 11 matching lines @@
     LayoutBlockFlow* block = toLayoutBlockFlow(layoutObject);
     if (block->size().height() == 0 || (block->isListItem() && toLayoutListItem(block)->isEmpty()))
         return appendBlockPlaceholder(container, editingState);
 
     return nullptr;
 }
 
 // Assumes that the position is at a placeholder and does the removal without much checking.
 void CompositeEditCommand::removePlaceholderAt(const Position& p)
 {
-    ASSERT(lineBreakExistsAtPosition(p));
+    DCHECK(lineBreakExistsAtPosition(p));
 
     // We are certain that the position is at a line break, but it may be a br or a preserved newline.
     if (isHTMLBRElement(*p.anchorNode())) {
         // Removing a BR element won't dispatch synchronous events.
         removeNode(p.anchorNode(), ASSERT_NO_EDITING_ABORT);
         return;
     }
 
     deleteTextFromNode(toText(p.anchorNode()), p.offsetInContainerNode(), 1);
 }
 
 RawPtr<HTMLElement> CompositeEditCommand::insertNewDefaultParagraphElementAt(const Position& position, EditingState* editingState)
 {
     RawPtr<HTMLElement> paragraphElement = createDefaultParagraphElement(document());
     paragraphElement->appendChild(HTMLBRElement::create(document()));
     insertNodeAt(paragraphElement, position, editingState);
     if (editingState->isAborted())
         return nullptr;
     return paragraphElement.release();
 }
 
 // If the paragraph is not entirely within it's own block, create one and move the paragraph into
 // it, and return that block.  Otherwise return 0.
 RawPtr<HTMLElement> CompositeEditCommand::moveParagraphContentsToNewBlockIfNecessary(const Position& pos, EditingState* editingState)
 {
-    ASSERT(isEditablePosition(pos, ContentIsEditable, DoNotUpdateStyle));
+    DCHECK(isEditablePosition(pos, ContentIsEditable, DoNotUpdateStyle));
 
     // It's strange that this function is responsible for verifying that pos has not been invalidated
     // by an earlier call to this function.  The caller, applyBlockStyle, should do this.
     VisiblePosition visiblePos = createVisiblePosition(pos, VP_DEFAULT_AFFINITY);
     VisiblePosition visibleParagraphStart = startOfParagraph(visiblePos);
     VisiblePosition visibleParagraphEnd = endOfParagraph(visiblePos);
     VisiblePosition next = nextPositionOf(visibleParagraphEnd);
     VisiblePosition visibleEnd = next.isNotNull() ? next : visibleParagraphEnd;
 
     Position upstreamStart = mostBackwardCaretPosition(visibleParagraphStart.deepEquivalent());
@@ skipping 54 matching lines @@
     }
 
     return newBlock.release();
 }
 
 void CompositeEditCommand::pushAnchorElementDown(Element* anchorNode, EditingState* editingState)
 {
     if (!anchorNode)
         return;
 
-    ASSERT(anchorNode->isLink());
+    DCHECK(anchorNode->isLink());
 
     setEndingSelection(VisibleSelection::selectionFromContentsOfNode(anchorNode));
     applyStyledElement(anchorNode, editingState);
     if (editingState->isAborted())
         return;
     // Clones of anchorNode have been pushed down, now remove it.
     if (anchorNode->inShadowIncludingDocument())
         removeNodePreservingChildren(anchorNode, editingState);
 }
 
 // Clone the paragraph between start and end under blockElement,
 // preserving the hierarchy up to outerNode.
 
 void CompositeEditCommand::cloneParagraphUnderNewElement(const Position& start, const Position& end, Node* passedOuterNode, Element* blockElement, EditingState* editingState)
 {
-    ASSERT(comparePositions(start, end) <= 0);
-    ASSERT(passedOuterNode);
-    ASSERT(blockElement);
+    DCHECK_LE(comparePositions(start, end), 0);
+    DCHECK(passedOuterNode);
+    DCHECK(blockElement);
 
     // First we clone the outerNode
     RawPtr<Node> lastNode = nullptr;
     RawPtr<Node> outerNode = passedOuterNode;
 
     if (outerNode->isRootEditableElement()) {
         lastNode = blockElement;
     } else {
         lastNode = outerNode->cloneNode(isDisplayInsideTable(outerNode.get()));
         appendNode(lastNode, blockElement, editingState);
@@ skipping 112 matching lines @@
 }
 
 // This is a version of moveParagraph that preserves style by keeping the original markup
 // It is currently used only by IndentOutdentCommand but it is meant to be used in the
 // future by several other commands such as InsertList and the align commands.
 // The blockElement parameter is the element to move the paragraph to,
 // outerNode is the top element of the paragraph hierarchy.
 
 void CompositeEditCommand::moveParagraphWithClones(const VisiblePosition& startOfParagraphToMove, const VisiblePosition& endOfParagraphToMove, HTMLElement* blockElement, Node* outerNode, EditingState* editingState)
 {
-    ASSERT(outerNode);
-    ASSERT(blockElement);
+    DCHECK(outerNode);
+    DCHECK(blockElement);
 
     VisiblePosition beforeParagraph = previousPositionOf(startOfParagraphToMove);
     VisiblePosition afterParagraph = nextPositionOf(endOfParagraphToMove);
 
     // We upstream() the end and downstream() the start so that we don't include collapsed whitespace in the move.
     // When we paste a fragment, spaces after the end and before the start are treated as though they were rendered.
     Position start = mostForwardCaretPosition(startOfParagraphToMove.deepEquivalent());
     Position end = startOfParagraphToMove.deepEquivalent() == endOfParagraphToMove.deepEquivalent() ? start : mostBackwardCaretPosition(endOfParagraphToMove.deepEquivalent());
     if (comparePositions(start, end) > 0)
         end = start;
@@ skipping 25 matching lines @@
 
     if (beforeParagraph.isNotNull() && !isDisplayInsideTable(beforeParagraph.deepEquivalent().anchorNode())
         && ((!isEndOfParagraph(beforeParagraph) && !isStartOfParagraph(beforeParagraph)) || beforeParagraph.deepEquivalent() == afterParagraph.deepEquivalent())) {
         // FIXME: Trim text between beforeParagraph and afterParagraph if they aren't equal.
         insertNodeAt(HTMLBRElement::create(document()), beforeParagraph.deepEquivalent(), editingState);
     }
 }
 
 void CompositeEditCommand::moveParagraph(const VisiblePosition& startOfParagraphToMove, const VisiblePosition& endOfParagraphToMove, const VisiblePosition& destination, EditingState* editingState, bool preserveSelection, bool preserveStyle, Node* constrainingAncestor)
 {
-    ASSERT(isStartOfParagraph(startOfParagraphToMove));
-    ASSERT(isEndOfParagraph(endOfParagraphToMove));
+    DCHECK(isStartOfParagraph(startOfParagraphToMove));
+    DCHECK(isEndOfParagraph(endOfParagraphToMove));
     moveParagraphs(startOfParagraphToMove, endOfParagraphToMove, destination, editingState, preserveSelection, preserveStyle, constrainingAncestor);
 }
 
 void CompositeEditCommand::moveParagraphs(const VisiblePosition& startOfParagraphToMove, const VisiblePosition& endOfParagraphToMove, const VisiblePosition& destination, EditingState* editingState, bool preserveSelection, bool preserveStyle, Node* constrainingAncestor)
 {
     if (startOfParagraphToMove.deepEquivalent() == destination.deepEquivalent() || startOfParagraphToMove.isNull())
         return;
 
     int startIndex = -1;
     int endIndex = -1;
@@ skipping 45 matching lines @@
     }
 
     // FIXME (5098931): We should add a new insert action "WebViewInsertActionMoved" and call shouldInsertFragment here.
 
     setEndingSelection(VisibleSelection(start, end));
     document().frame()->spellChecker().clearMisspellingsAndBadGrammar(endingSelection());
     deleteSelection(editingState, false, false, false);
     if (editingState->isAborted())
         return;
 
-    ASSERT(destination.deepEquivalent().inShadowIncludingDocument());
+    DCHECK(destination.deepEquivalent().inShadowIncludingDocument());
     cleanupAfterDeletion(editingState, destination);
     if (editingState->isAborted())
         return;
-    ASSERT(destination.deepEquivalent().inShadowIncludingDocument());
+    DCHECK(destination.deepEquivalent().inShadowIncludingDocument());
 
     // Add a br if pruning an empty block level element caused a collapse. For example:
     // foo^
     // <div>bar</div>
     // baz
     // Imagine moving 'bar' to ^. 'bar' will be deleted and its div pruned. That would
     // cause 'baz' to collapse onto the line with 'foobar' unless we insert a br.
     // Must recononicalize these two VisiblePositions after the pruning above.
     beforeParagraph = createVisiblePosition(beforeParagraph.deepEquivalent());
     afterParagraph = createVisiblePosition(afterParagraph.deepEquivalent());
     if (beforeParagraph.isNotNull() && (!isEndOfParagraph(beforeParagraph) || beforeParagraph.deepEquivalent() == afterParagraph.deepEquivalent())) {
         // FIXME: Trim text between beforeParagraph and afterParagraph if they aren't equal.
         insertNodeAt(HTMLBRElement::create(document()), beforeParagraph.deepEquivalent(), editingState);
         if (editingState->isAborted())
             return;
         // Need an updateLayout here in case inserting the br has split a text node.
         document().updateLayoutIgnorePendingStylesheets();
     }
 
     destinationIndex = TextIterator::rangeLength(firstPositionInNode(document().documentElement()), destination.toParentAnchoredPosition(), true);
 
     setEndingSelection(VisibleSelection(destination, originalIsDirectional));
-    ASSERT(endingSelection().isCaretOrRange());
+    DCHECK(endingSelection().isCaretOrRange());
     ReplaceSelectionCommand::CommandOptions options = ReplaceSelectionCommand::SelectReplacement | ReplaceSelectionCommand::MovingParagraph;
     if (!preserveStyle)
         options |= ReplaceSelectionCommand::MatchStyle;
     applyCommandToComposite(ReplaceSelectionCommand::create(document(), fragment, options), editingState);
     if (editingState->isAborted())
         return;
 
     document().frame()->spellChecker().markMisspellingsAndBadGrammar(endingSelection());
 
     // If the selection is in an empty paragraph, restore styles from the old empty paragraph to the new empty paragraph.
@@ skipping 140 matching lines @@
             return false;
     }
     setEndingSelection(VisibleSelection(atBR, endingSelection().isDirectional()));
 
     // If this is an empty paragraph there must be a line break here.
     if (!lineBreakExistsAtVisiblePosition(caret))
         return false;
 
     Position caretPos(mostForwardCaretPosition(caret.deepEquivalent()));
     // A line break is either a br or a preserved newline.
-    ASSERT(isHTMLBRElement(caretPos.anchorNode()) || (caretPos.anchorNode()->isTextNode() && caretPos.anchorNode()->layoutObject()->style()->preserveNewline()));
+    DCHECK(isHTMLBRElement(caretPos.anchorNode()) || (caretPos.anchorNode()->isTextNode() && caretPos.anchorNode()->layoutObject()->style()->preserveNewline()));
 
     if (isHTMLBRElement(*caretPos.anchorNode())) {
         removeNodeAndPruneAncestors(caretPos.anchorNode(), editingState);
         if (editingState->isAborted())
             return false;
     } else if (caretPos.anchorNode()->isTextNode()) {
-        ASSERT(caretPos.computeOffsetInContainerNode() == 0);
+        DCHECK_EQ(caretPos.computeOffsetInContainerNode(), 0);
         Text* textNode = toText(caretPos.anchorNode());
         ContainerNode* parentNode = textNode->parentNode();
         // The preserved newline must be the first thing in the node, since otherwise the previous
         // paragraph would be quoted, and we verified that it wasn't above.
         deleteTextFromNode(textNode, 0, 1);
         prune(parentNode, editingState);
         if (editingState->isAborted())
             return false;
     }
 
@@ skipping 62 matching lines @@
     if (result.isNull() || !rootEditableElementOf(result))
         result = original;
 
     return result;
 }
 
 // Splits the tree parent by parent until we reach the specified ancestor. We use VisiblePositions
 // to determine if the split is necessary. Returns the last split node.
 RawPtr<Node> CompositeEditCommand::splitTreeToNode(Node* start, Node* end, bool shouldSplitAncestor)
 {
-    ASSERT(start);
-    ASSERT(end);
-    ASSERT(start != end);
+    DCHECK(start);
+    DCHECK(end);
+    DCHECK_NE(start, end);
 
     if (shouldSplitAncestor && end->parentNode())
         end = end->parentNode();
     if (!start->isDescendantOf(end))
         return end;
 
     RawPtr<Node> endNode = end;
     RawPtr<Node> node = nullptr;
     for (node = start; node->parentNode() != endNode; node = node->parentNode()) {
         Element* parentElement = node->parentElement();
@@ skipping 10 matching lines @@
 }
 
 DEFINE_TRACE(CompositeEditCommand)
 {
     visitor->trace(m_commands);
     visitor->trace(m_composition);
     EditCommand::trace(visitor);
 }
 
 } // namespace blink