ASSERT -> DCHECK in core/editing.

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

 /*
  * Copyright (C) 2005, 2006, 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 68 matching lines @@
     if (attributes.isEmpty())
         return true;
 
     unsigned matchedAttributes = 0;
     if (element->getAttribute(classAttr) == styleSpanClassString())
         matchedAttributes++;
     if (element->hasAttribute(styleAttr) && (shouldStyleAttributeBeEmpty == AllowNonEmptyStyleAttribute
         || !element->inlineStyle() || element->inlineStyle()->isEmpty()))
         matchedAttributes++;
 
-    ASSERT(matchedAttributes <= attributes.size());
+    DCHECK_LE(matchedAttributes, attributes.size());
     return matchedAttributes == attributes.size();
 }
 
 bool isStyleSpanOrSpanWithOnlyStyleAttribute(const Element* element)
 {
     if (!isHTMLSpanElement(element))
         return false;
     return hasNoAttributeOrOnlyStyleAttribute(toHTMLSpanElement(element), AllowNonEmptyStyleAttribute);
 }
 
@@ skipping 63 matching lines @@
     , m_end(mostBackwardCaretPosition(endingSelection().end()))
     , m_useEndingSelection(true)
     , m_styledInlineElement(nullptr)
     , m_removeOnly(true)
     , m_isInlineElementToRemoveFunction(isInlineElementToRemoveFunction)
 {
 }
 
 void ApplyStyleCommand::updateStartEnd(const Position& newStart, const Position& newEnd)
 {
-    ASSERT(comparePositions(newEnd, newStart) >= 0);
+    DCHECK_GE(comparePositions(newEnd, newStart), 0);
 
     if (!m_useEndingSelection && (newStart != m_start || newEnd != m_end))
         m_useEndingSelection = true;
 
     setEndingSelection(VisibleSelection(newStart, newEnd, VP_DEFAULT_AFFINITY, endingSelection().isDirectional()));
     m_start = newStart;
     m_end = newEnd;
 }
 
 Position ApplyStyleCommand::startPosition()
@@ skipping 168 matching lines @@
     if (isValidCaretPositionInTextNode(end)) {
         splitTextAtEnd(start, end);
         start = startPosition();
         end = endPosition();
     }
 
     // Calculate loop end point.
     // If the end node is before the start node (can only happen if the end node is
     // an ancestor of the start node), we gather nodes up to the next sibling of the end node
     Node* beyondEnd;
-    ASSERT(start.anchorNode());
-    ASSERT(end.anchorNode());
+    DCHECK(start.anchorNode());
+    DCHECK(end.anchorNode());
     if (start.anchorNode()->isDescendantOf(end.anchorNode()))
         beyondEnd = NodeTraversal::nextSkippingChildren(*end.anchorNode());
     else
         beyondEnd = NodeTraversal::next(*end.anchorNode());
 
     start = mostBackwardCaretPosition(start); // Move upstream to ensure we do not add redundant spans.
     Node* startNode = start.anchorNode();
-    ASSERT(startNode);
+    DCHECK(startNode);
 
     // Make sure we're not already at the end or the next NodeTraversal::next() will traverse
     // past it.
     if (startNode == beyondEnd)
         return;
 
     if (startNode->isTextNode() && start.computeOffsetInContainerNode() >= caretMaxOffset(startNode)) {
         // Move out of text node if range does not include its characters.
         startNode = NodeTraversal::next(*startNode);
         if (!startNode)
             return;
     }
 
     // Store away font size before making any changes to the document.
     // This ensures that changes to one node won't effect another.
     HeapHashMap<Member<Node>, float> startingFontSizes;
     for (Node* node = startNode; node != beyondEnd; node = NodeTraversal::next(*node)) {
-        ASSERT(node);
+        DCHECK(node);
         startingFontSizes.set(node, computedFontSize(node));
     }
 
     // These spans were added by us. If empty after font size changes, they can be removed.
     HeapVector<Member<HTMLElement>> unstyledSpans;
 
     Node* lastStyledNode = nullptr;
     for (Node* node = startNode; node != beyondEnd; node = NodeTraversal::next(*node)) {
-        ASSERT(node);
+        DCHECK(node);
         RawPtr<HTMLElement> element = nullptr;
         if (node->isHTMLElement()) {
             // Only work on fully selected nodes.
             if (!elementFullySelected(toHTMLElement(*node), start, end))
                 continue;
             element = toHTMLElement(node);
         } else if (node->isTextNode() && node->layoutObject() && node->parentNode() != lastStyledNode) {
             // Last styled node was not parent node of this text node, but we wish to style this
             // text node. To make this possible, add a style span to surround this text node.
             RawPtr<HTMLSpanElement> span = HTMLSpanElement::create(document());
@@ skipping 287 matching lines @@
 
     RawPtr<EditingStyle> styleToApply = style;
     if (hasTextDirection) {
         // Avoid applying the unicode-bidi and direction properties beneath ancestors that already have them.
         HTMLElement* embeddingStartElement = highestEmbeddingAncestor(start.anchorNode(), enclosingBlock(start.anchorNode()));
         HTMLElement* embeddingEndElement = highestEmbeddingAncestor(end.anchorNode(), enclosingBlock(end.anchorNode()));
 
         if (embeddingStartElement || embeddingEndElement) {
             Position embeddingApplyStart = embeddingStartElement ? positionInParentAfterNode(*embeddingStartElement) : start;
             Position embeddingApplyEnd = embeddingEndElement ? positionInParentBeforeNode(*embeddingEndElement) : end;
-            ASSERT(embeddingApplyStart.isNotNull() && embeddingApplyEnd.isNotNull());
+            DCHECK(embeddingApplyStart.isNotNull() && embeddingApplyEnd.isNotNull());
 
             if (!embeddingStyle) {
                 styleWithoutEmbedding = style->copy();
                 embeddingStyle = styleWithoutEmbedding->extractAndRemoveTextDirection();
             }
             fixRangeAndApplyInlineStyle(embeddingStyle.get(), embeddingApplyStart, embeddingApplyEnd, editingState);
             if (editingState->isAborted())
                 return;
 
             styleToApply = styleWithoutEmbedding;
         }
     }
 
     fixRangeAndApplyInlineStyle(styleToApply.get(), start, end, editingState);
     if (editingState->isAborted())
         return;
 
     // Remove dummy style spans created by splitting text elements.
     cleanupUnstyledAppleStyleSpans(startDummySpanAncestor.get(), editingState);
     if (editingState->isAborted())
         return;
     if (endDummySpanAncestor != startDummySpanAncestor)
         cleanupUnstyledAppleStyleSpans(endDummySpanAncestor.get(), editingState);
 }
 
 void ApplyStyleCommand::fixRangeAndApplyInlineStyle(EditingStyle* style, const Position& start, const Position& end, EditingState* editingState)
 {
     Node* startNode = start.anchorNode();
-    ASSERT(startNode);
+    DCHECK(startNode);
 
     if (start.computeEditingOffset() >= caretMaxOffset(start.anchorNode())) {
         startNode = NodeTraversal::next(*startNode);
         if (!startNode || comparePositions(end, firstPositionInOrBeforeNode(startNode)) < 0)
             return;
     }
 
     Node* pastEndNode = end.anchorNode();
     if (end.computeEditingOffset() >= caretMaxOffset(end.anchorNode()))
         pastEndNode = NodeTraversal::nextSkippingChildren(*end.anchorNode());
@@ skipping 31 matching lines @@
 }
 
 class InlineRunToApplyStyle {
     DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 public:
     InlineRunToApplyStyle(Node* start, Node* end, Node* pastEndNode)
         : start(start)
         , end(end)
         , pastEndNode(pastEndNode)
     {
-        ASSERT(start->parentNode() == end->parentNode());
+        DCHECK_EQ(start->parentNode(), end->parentNode());
     }
 
     bool startAndEndAreStillInDocument()
     {
         return start && end && start->inShadowIncludingDocument() && end->inShadowIncludingDocument();
     }
 
     DEFINE_INLINE_TRACE()
     {
         visitor->trace(start);
@@ skipping 63 matching lines @@
 
         Node* runStart = node.get();
         Node* runEnd = node.get();
         Node* sibling = node->nextSibling();
         while (sibling && sibling != pastEndNode && !sibling->contains(pastEndNode.get())
             && (!isEnclosingBlock(sibling) || isHTMLBRElement(*sibling))
             && !containsNonEditableRegion(*sibling)) {
             runEnd = sibling;
             sibling = runEnd->nextSibling();
         }
-        ASSERT(runEnd);
+        DCHECK(runEnd);
         next = NodeTraversal::nextSkippingChildren(*runEnd);
 
         Node* pastEndNode = NodeTraversal::nextSkippingChildren(*runEnd);
         if (!shouldApplyInlineStyleToRun(style, runStart, pastEndNode))
             continue;
 
         runs.append(InlineRunToApplyStyle(runStart, runEnd, pastEndNode));
     }
 
     for (auto& run : runs) {
@@ skipping 29 matching lines @@
 }
 
 bool ApplyStyleCommand::isStyledInlineElementToRemove(Element* element) const
 {
     return (m_styledInlineElement && element->hasTagName(m_styledInlineElement->tagQName()))
         || (m_isInlineElementToRemoveFunction && m_isInlineElementToRemoveFunction(element));
 }
 
 bool ApplyStyleCommand::shouldApplyInlineStyleToRun(EditingStyle* style, Node* runStart, Node* pastEndNode)
 {
-    ASSERT(style && runStart);
+    DCHECK(style && runStart);
 
     for (Node* node = runStart; node && node != pastEndNode; node = NodeTraversal::next(*node)) {
         if (node->hasChildren())
             continue;
         // We don't consider m_isInlineElementToRemoveFunction here because we never apply style when m_isInlineElementToRemoveFunction is specified
         if (!style->styleIsPresentInComputedStyleOfNode(node))
             return true;
         if (m_styledInlineElement && !enclosingElementWithTag(positionBeforeNode(node), m_styledInlineElement->tagQName()))
             return true;
     }
     return false;
 }
 
 void ApplyStyleCommand::removeConflictingInlineStyleFromRun(EditingStyle* style, Member<Node>& runStart, Member<Node>& runEnd, RawPtr<Node> pastEndNode, EditingState* editingState)
 {
-    ASSERT(runStart && runEnd);
+    DCHECK(runStart && runEnd);
     RawPtr<Node> next = runStart;
     for (RawPtr<Node> node = next; node && node->inShadowIncludingDocument() && node != pastEndNode; node = next) {
         if (editingIgnoresContent(node.get())) {
-            ASSERT(!node->contains(pastEndNode.get()));
+            DCHECK(!node->contains(pastEndNode.get()));
             next = NodeTraversal::nextSkippingChildren(*node);
         } else {
             next = NodeTraversal::next(*node);
         }
         if (!node->isHTMLElement())
             continue;
 
         HTMLElement& element = toHTMLElement(*node);
         RawPtr<Node> previousSibling = element.previousSibling();
         RawPtr<Node> nextSibling = element.nextSibling();
         RawPtr<ContainerNode> parent = element.parentNode();
         removeInlineStyleFromElement(style, &element, editingState, RemoveAlways);
         if (editingState->isAborted())
             return;
         if (!element.inShadowIncludingDocument()) {
             // FIXME: We might need to update the start and the end of current selection here but need a test.
             if (runStart == element)
                 runStart = previousSibling ? previousSibling->nextSibling() : parent->firstChild();
             if (runEnd == element)
                 runEnd = nextSibling ? nextSibling->previousSibling() : parent->lastChild();
         }
     }
 }
 
 bool ApplyStyleCommand::removeInlineStyleFromElement(EditingStyle* style, RawPtr<HTMLElement> element, EditingState* editingState, InlineStyleRemovalMode mode, EditingStyle* extractedStyle)
 {
-    ASSERT(element);
+    DCHECK(element);
 
     if (!element->parentNode() || !element->parentNode()->isContentEditable(Node::UserSelectAllIsAlwaysNonEditable))
         return false;
 
     if (isStyledInlineElementToRemove(element.get())) {
         if (mode == RemoveNone)
             return true;
         if (extractedStyle)
             extractedStyle->mergeInlineStyleOfElement(element.get(), EditingStyle::OverrideValues);
         removeNodePreservingChildren(element, editingState);
@@ skipping 22 matching lines @@
 void ApplyStyleCommand::replaceWithSpanOrRemoveIfWithoutAttributes(HTMLElement* elem, EditingState* editingState)
 {
     if (hasNoAttributeOrOnlyStyleAttribute(elem, StyleAttributeShouldBeEmpty))
         removeNodePreservingChildren(elem, editingState);
     else
         replaceElementWithSpanPreservingChildrenAndAttributes(elem);
 }
 
 bool ApplyStyleCommand::removeImplicitlyStyledElement(EditingStyle* style, HTMLElement* element, InlineStyleRemovalMode mode, EditingStyle* extractedStyle, EditingState* editingState)
 {
-    ASSERT(style);
+    DCHECK(style);
     if (mode == RemoveNone) {
-        ASSERT(!extractedStyle);
+        DCHECK(!extractedStyle);
         return style->conflictsWithImplicitStyleOfElement(element) || style->conflictsWithImplicitStyleOfAttributes(element);
     }
 
-    ASSERT(mode == RemoveIfNeeded || mode == RemoveAlways);
+    DCHECK(mode == RemoveIfNeeded || mode == RemoveAlways);
     if (style->conflictsWithImplicitStyleOfElement(element, extractedStyle, mode == RemoveAlways ? EditingStyle::ExtractMatchingStyle : EditingStyle::DoNotExtractMatchingStyle)) {
         replaceWithSpanOrRemoveIfWithoutAttributes(element, editingState);
         if (editingState->isAborted())
             return false;
         return true;
     }
 
     // unicode-bidi and direction are pushed down separately so don't push down with other styles
     Vector<QualifiedName> attributes;
     if (!style->extractConflictingImplicitStyleOfAttributes(element, extractedStyle ? EditingStyle::PreserveWritingDirection : EditingStyle::DoNotPreserveWritingDirection,
         extractedStyle, attributes, mode == RemoveAlways ? EditingStyle::ExtractMatchingStyle : EditingStyle::DoNotExtractMatchingStyle))
         return false;
 
     for (const auto& attribute : attributes)
         removeElementAttribute(element, attribute);
 
     if (isEmptyFontTag(element) || isSpanWithoutAttributesOrUnstyledStyleSpan(element)) {
         removeNodePreservingChildren(element, editingState);
         if (editingState->isAborted())
             return false;
     }
 
     return true;
 }
 
 bool ApplyStyleCommand::removeCSSStyle(EditingStyle* style, HTMLElement* element, EditingState* editingState, InlineStyleRemovalMode mode, EditingStyle* extractedStyle)
 {
-    ASSERT(style);
-    ASSERT(element);
+    DCHECK(style);
+    DCHECK(element);
 
     if (mode == RemoveNone)
         return style->conflictsWithInlineStyleOfElement(element);
 
     Vector<CSSPropertyID> properties;
     if (!style->conflictsWithInlineStyleOfElement(element, extractedStyle, properties))
         return false;
 
     // FIXME: We should use a mass-removal function here but we don't have an undoable one yet.
     for (const auto& property : properties)
@@ skipping 20 matching lines @@
         // also stop at the unsplittable element to be consistent with other UAs
         if (n == unsplittableElement)
             break;
     }
 
     return result;
 }
 
 void ApplyStyleCommand::applyInlineStyleToPushDown(Node* node, EditingStyle* style, EditingState* editingState)
 {
-    ASSERT(node);
+    DCHECK(node);
 
     node->document().updateLayoutTree();
 
     if (!style || style->isEmpty() || !node->layoutObject() || isHTMLIFrameElement(*node))
         return;
 
     RawPtr<EditingStyle> newInlineStyle = style;
     if (node->isHTMLElement() && toHTMLElement(node)->inlineStyle()) {
         newInlineStyle = style->copy();
         newInlineStyle->mergeInlineStyleOfElement(toHTMLElement(node), EditingStyle::OverrideValues);
@@ skipping 73 matching lines @@
             // We found the next node for the outer loop (contains targetNode)
             // When reached targetNode, stop the outer loop upon the completion of the current inner loop
             if (child == targetNode || child->contains(targetNode))
                 current = child;
         }
     }
 }
 
 void ApplyStyleCommand::removeInlineStyle(EditingStyle* style, const Position &start, const Position &end, EditingState* editingState)
 {
-    ASSERT(start.isNotNull());
-    ASSERT(end.isNotNull());
-    ASSERT(start.inShadowIncludingDocument());
-    ASSERT(end.inShadowIncludingDocument());
-    ASSERT(Position::commonAncestorTreeScope(start, end));
-    ASSERT(comparePositions(start, end) <= 0);
+    DCHECK(start.isNotNull());
+    DCHECK(end.isNotNull());
+    DCHECK(start.inShadowIncludingDocument());
+    DCHECK(end.inShadowIncludingDocument());
+    DCHECK(Position::commonAncestorTreeScope(start, end));
+    DCHECK_LE(comparePositions(start, end), 0);
     // FIXME: We should assert that start/end are not in the middle of a text node.
 
     Position pushDownStart = mostForwardCaretPosition(start);
     // If the pushDownStart is at the end of a text node, then this node is not fully selected.
     // Move it to the next deep quivalent position to avoid removing the style from this node.
     // e.g. if pushDownStart was at Position("hello", 5) in <b>hello<div>world</div></b>, we want Position("world", 0) instead.
     Node* pushDownStartContainer = pushDownStart.computeContainerNode();
     if (pushDownStartContainer && pushDownStartContainer->isTextNode()
         && pushDownStart.computeOffsetInContainerNode() == pushDownStartContainer->maxCharacterOffset())
         pushDownStart = nextVisuallyDistinctCandidate(pushDownStart);
@@ skipping 21 matching lines @@
 
     // Current ending selection resetting algorithm assumes |start| and |end|
     // are in a same DOM tree even if they are not in document.
     if (!Position::commonAncestorTreeScope(start, end))
         return;
 
     RawPtr<Node> node = start.anchorNode();
     while (node) {
         RawPtr<Node> next = nullptr;
         if (editingIgnoresContent(node.get())) {
-            ASSERT(node == end.anchorNode() || !node->contains(end.anchorNode()));
+            DCHECK(node == end.anchorNode() || !node->contains(end.anchorNode()));
             next = NodeTraversal::nextSkippingChildren(*node);
         } else {
             next = NodeTraversal::next(*node);
         }
         if (node->isHTMLElement() && elementFullySelected(toHTMLElement(*node), start, end)) {
             RawPtr<HTMLElement> elem = toHTMLElement(node);
             RawPtr<Node> prev = NodeTraversal::previousPostOrder(*elem);
             RawPtr<Node> next = NodeTraversal::next(*elem);
             RawPtr<EditingStyle> styleToPushDown = nullptr;
             RawPtr<Node> childNode = nullptr;
             if (isStyledInlineElementToRemove(elem.get())) {
                 styleToPushDown = EditingStyle::create();
                 childNode = elem->firstChild();
             }
 
             removeInlineStyleFromElement(style, elem.get(), editingState, RemoveIfNeeded, styleToPushDown.get());
             if (editingState->isAborted())
                 return;
             if (!elem->inShadowIncludingDocument()) {
                 if (s.anchorNode() == elem) {
                     // Since elem must have been fully selected, and it is at the start
                     // of the selection, it is clear we can set the new s offset to 0.
-                    ASSERT(s.isBeforeAnchor() || s.isBeforeChildren() || s.offsetInContainerNode() <= 0);
+                    DCHECK(s.isBeforeAnchor() || s.isBeforeChildren() || s.offsetInContainerNode() <= 0);
                     s = firstPositionInOrBeforeNode(next.get());
                 }
                 if (e.anchorNode() == elem) {
                     // Since elem must have been fully selected, and it is at the end
                     // of the selection, it is clear we can set the new e offset to
                     // the max range offset of prev.
-                    ASSERT(s.isAfterAnchor() || !offsetIsBeforeLastNodeOffset(s.offsetInContainerNode(), s.computeContainerNode()));
+                    DCHECK(s.isAfterAnchor() || !offsetIsBeforeLastNodeOffset(s.offsetInContainerNode(), s.computeContainerNode()));
                     e = lastPositionInOrAfterNode(prev.get());
                 }
             }
 
             if (styleToPushDown) {
                 for (; childNode; childNode = childNode->nextSibling()) {
                     applyInlineStyleToPushDown(childNode.get(), styleToPushDown.get(), editingState);
                     if (editingState->isAborted())
                         return;
                 }
@@ skipping 11 matching lines @@
 {
     // The tree may have changed and Position::upstream() relies on an up-to-date layout.
     element.document().updateLayoutIgnorePendingStylesheets();
 
     return comparePositions(firstPositionInOrBeforeNode(&element), start) >= 0
         && comparePositions(mostBackwardCaretPosition(lastPositionInOrAfterNode(&element)), end) <= 0;
 }
 
 void ApplyStyleCommand::splitTextAtStart(const Position& start, const Position& end)
 {
-    ASSERT(start.computeContainerNode()->isTextNode());
+    DCHECK(start.computeContainerNode()->isTextNode());
 
     Position newEnd;
     if (end.isOffsetInAnchor() && start.computeContainerNode() == end.computeContainerNode())
         newEnd = Position(end.computeContainerNode(), end.offsetInContainerNode() - start.offsetInContainerNode());
     else
         newEnd = end;
 
     RawPtr<Text> text = toText(start.computeContainerNode());
     splitTextNode(text, start.offsetInContainerNode());
     updateStartEnd(firstPositionInNode(text.get()), newEnd);
 }
 
 void ApplyStyleCommand::splitTextAtEnd(const Position& start, const Position& end)
 {
-    ASSERT(end.computeContainerNode()->isTextNode());
+    DCHECK(end.computeContainerNode()->isTextNode());
 
     bool shouldUpdateStart = start.isOffsetInAnchor() && start.computeContainerNode() == end.computeContainerNode();
     Text* text = toText(end.anchorNode());
     splitTextNode(text, end.offsetInContainerNode());
 
     Node* prevNode = text->previousSibling();
     if (!prevNode || !prevNode->isTextNode())
         return;
 
     Position newStart = shouldUpdateStart ? Position(toText(prevNode), start.offsetInContainerNode()) : start;
     updateStartEnd(newStart, lastPositionInNode(prevNode));
 }
 
 void ApplyStyleCommand::splitTextElementAtStart(const Position& start, const Position& end)
 {
-    ASSERT(start.computeContainerNode()->isTextNode());
+    DCHECK(start.computeContainerNode()->isTextNode());
 
     Position newEnd;
     if (start.computeContainerNode() == end.computeContainerNode())
         newEnd = Position(end.computeContainerNode(), end.offsetInContainerNode() - start.offsetInContainerNode());
     else
         newEnd = end;
 
     splitTextNodeContainingElement(toText(start.computeContainerNode()), start.offsetInContainerNode());
     updateStartEnd(positionBeforeNode(start.computeContainerNode()), newEnd);
 }
 
 void ApplyStyleCommand::splitTextElementAtEnd(const Position& start, const Position& end)
 {
-    ASSERT(end.computeContainerNode()->isTextNode());
+    DCHECK(end.computeContainerNode()->isTextNode());
 
     bool shouldUpdateStart = start.computeContainerNode() == end.computeContainerNode();
     splitTextNodeContainingElement(toText(end.computeContainerNode()), end.offsetInContainerNode());
 
     Node* parentElement = end.computeContainerNode()->parentNode();
     if (!parentElement || !parentElement->previousSibling())
         return;
     Node* firstTextNode = parentElement->previousSibling()->lastChild();
     if (!firstTextNode || !firstTextNode->isTextNode())
         return;
 
     Position newStart = shouldUpdateStart ? Position(toText(firstTextNode), start.offsetInContainerNode()) : start;
     updateStartEnd(newStart, positionAfterNode(firstTextNode));
 }
 
 bool ApplyStyleCommand::shouldSplitTextElement(Element* element, EditingStyle* style)
 {
     if (!element || !element->isHTMLElement())
         return false;
 
     return shouldRemoveInlineStyleFromElement(style, toHTMLElement(element));
 }
 
 bool ApplyStyleCommand::isValidCaretPositionInTextNode(const Position& position)
 {
-    ASSERT(position.isNotNull());
+    DCHECK(position.isNotNull());
 
     Node* node = position.computeContainerNode();
     if (!position.isOffsetInAnchor() || !node->isTextNode())
         return false;
     int offsetInText = position.offsetInContainerNode();
     return offsetInText > caretMinOffset(node) && offsetInText < caretMaxOffset(node);
 }
 
 bool ApplyStyleCommand::mergeStartWithPreviousIfIdentical(const Position& start, const Position& end, EditingState* editingState)
 {
@@ skipping 13 matching lines @@
 
     if (!startNode->isElementNode())
         return false;
 
     Node* previousSibling = startNode->previousSibling();
 
     if (previousSibling && areIdenticalElements(*startNode, *previousSibling)) {
         Element* previousElement = toElement(previousSibling);
         Element* element = toElement(startNode);
         Node* startChild = element->firstChild();
-        ASSERT(startChild);
+        DCHECK(startChild);
         mergeIdenticalElements(previousElement, element, editingState);
         if (editingState->isAborted())
             return false;
 
         int startOffsetAdjustment = startChild->nodeIndex();
         int endOffsetAdjustment = startNode == end.anchorNode() ? startOffsetAdjustment : 0;
         updateStartEnd(Position(startNode, startOffsetAdjustment),
             Position(end.anchorNode(), end.computeEditingOffset() + endOffsetAdjustment));
         return true;
     }
@@ skipping 34 matching lines @@
         updateStartEnd(shouldUpdateStart ? Position(nextElement, start.offsetInContainerNode()) : start,
             Position(nextElement, endOffset));
         return true;
     }
 
     return false;
 }
 
 void ApplyStyleCommand::surroundNodeRangeWithElement(RawPtr<Node> passedStartNode, RawPtr<Node> endNode, RawPtr<Element> elementToInsert, EditingState* editingState)
 {
-    ASSERT(passedStartNode);
-    ASSERT(endNode);
-    ASSERT(elementToInsert);
+    DCHECK(passedStartNode);
+    DCHECK(endNode);
+    DCHECK(elementToInsert);
     RawPtr<Node> node = passedStartNode;
     RawPtr<Element> element = elementToInsert;
 
     insertNodeBefore(element, node, editingState);
     if (editingState->isAborted())
         return;
 
     while (node) {
         RawPtr<Node> next = node->nextSibling();
         if (node->isContentEditable(Node::UserSelectAllIsAlwaysNonEditable)) {
@@ skipping 82 matching lines @@
         return positionBeforeNode(dummyElement.get());
     }
 
     return firstPositionInOrBeforeNode(startNode.get());
 }
 
 void ApplyStyleCommand::applyInlineStyleChange(RawPtr<Node> passedStart, RawPtr<Node> passedEnd, StyleChange& styleChange, EAddStyledElement addStyledElement, EditingState* editingState)
 {
     RawPtr<Node> startNode = passedStart;
     RawPtr<Node> endNode = passedEnd;
-    ASSERT(startNode->inShadowIncludingDocument());
-    ASSERT(endNode->inShadowIncludingDocument());
+    DCHECK(startNode->inShadowIncludingDocument());
+    DCHECK(endNode->inShadowIncludingDocument());
 
     // Find appropriate font and span elements top-down.
     HTMLFontElement* fontContainer = nullptr;
     HTMLElement* styleContainer = nullptr;
     for (Node* container = startNode.get(); container && startNode == endNode; container = container->firstChild()) {
         if (isHTMLFontElement(*container))
             fontContainer = toHTMLFontElement(container);
         bool styleContainerIsNotSpan = !isHTMLSpanElement(styleContainer);
         if (container->isHTMLElement()) {
             HTMLElement* containerElement = toHTMLElement(container);
@@ skipping 95 matching lines @@
         return 0;
 
     CSSComputedStyleDeclaration* style = CSSComputedStyleDeclaration::create(node);
     if (!style)
         return 0;
 
     CSSPrimitiveValue* value = toCSSPrimitiveValue(style->getPropertyCSSValue(CSSPropertyFontSize));
     if (!value)
         return 0;
 
-    ASSERT(value->typeWithCalcResolved() == CSSPrimitiveValue::UnitType::Pixels);
+    DCHECK(value->typeWithCalcResolved() == CSSPrimitiveValue::UnitType::Pixels);
     return value->getFloatValue();
 }
 
 void ApplyStyleCommand::joinChildTextNodes(ContainerNode* node, const Position& start, const Position& end)
 {
     if (!node)
         return;
 
     Position newStart = start;
     Position newEnd = end;
@@ skipping 30 matching lines @@
 DEFINE_TRACE(ApplyStyleCommand)
 {
     visitor->trace(m_style);
     visitor->trace(m_start);
     visitor->trace(m_end);
     visitor->trace(m_styledInlineElement);
     CompositeEditCommand::trace(visitor);
 }
 
 } // namespace blink