ASSERT -> DCHECK in core/editing.

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

 /*
  * Copyright (C) 2005 Apple Computer, 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 30 matching lines @@
 #include "core/html/HTMLTableRowElement.h"
 #include "core/layout/LayoutTableCell.h"
 #include "core/layout/LayoutText.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 static bool isTableCellEmpty(Node* cell)
 {
-    ASSERT(isTableCell(cell));
+    DCHECK(isTableCell(cell)) << cell;
     return createVisiblePosition(firstPositionInNode(cell)).deepEquivalent() == createVisiblePosition(lastPositionInNode(cell)).deepEquivalent();
 }
 
 static bool isTableRowEmpty(Node* row)
 {
     if (!isHTMLTableRowElement(row))
         return false;
 
     for (Node* child = row->firstChild(); child; child = child->nextSibling()) {
         if (isTableCell(child) && !isTableCellEmpty(child))
@@ skipping 97 matching lines @@
     bool isBaseFirst = startingSelection().isBaseFirst();
     VisiblePosition newBase = createVisiblePosition(isBaseFirst ? start : end);
     VisiblePosition newExtent = createVisiblePosition(isBaseFirst ? end : start);
     setStartingSelection(VisibleSelection(newBase, newExtent, startingSelection().isDirectional()));
 }
 
 void DeleteSelectionCommand::initializePositionData(EditingState* editingState)
 {
     Position start, end;
     initializeStartEnd(start, end);
-    ASSERT(start.isNotNull());
-    ASSERT(end.isNotNull());
+    DCHECK(start.isNotNull());
+    DCHECK(end.isNotNull());
     if (!isEditablePosition(start, ContentIsEditable, DoNotUpdateStyle)) {
         editingState->abort();
         return;
     }
     if (!isEditablePosition(end, ContentIsEditable, DoNotUpdateStyle)) {
         Node* highestRoot = highestEditableRoot(start);
-        ASSERT(highestRoot);
+        DCHECK(highestRoot);
         end = lastEditablePositionBeforePositionInRoot(end, *highestRoot);
     }
 
     m_upstreamStart = mostBackwardCaretPosition(start);
     m_downstreamStart = mostForwardCaretPosition(start);
     m_upstreamEnd = mostBackwardCaretPosition(end);
     m_downstreamEnd = mostForwardCaretPosition(end);
 
     m_startRoot = rootEditableElementOf(start);
     m_endRoot = rootEditableElementOf(end);
@@ skipping 139 matching lines @@
     if (upstreamStartIsBR && downstreamStartIsBR && !(isStartOfBlock(createVisiblePosition(positionBeforeNode(nodeAfterUpstreamStart))) && isEndOfBlock(createVisiblePosition(positionAfterNode(nodeAfterUpstreamStart))))) {
         m_startsAtEmptyLine = true;
         m_endingPosition = m_downstreamEnd;
     }
 
     return false;
 }
 
 static Position firstEditablePositionInNode(Node* node)
 {
-    ASSERT(node);
+    DCHECK(node);
     Node* next = node;
     while (next && !next->hasEditableStyle())
         next = NodeTraversal::next(*next, node);
     return next ? firstPositionInOrBeforeNode(next) : Position();
 }
 
 void DeleteSelectionCommand::removeNode(Node* node, EditingState* editingState, ShouldAssumeContentIsAlwaysEditable shouldAssumeContentIsAlwaysEditable)
 {
     if (!node)
         return;
@@ skipping 108 matching lines @@
     }
 }
 
 void DeleteSelectionCommand::handleGeneralDelete(EditingState* editingState)
 {
     if (m_upstreamStart.isNull())
         return;
 
     int startOffset = m_upstreamStart.computeEditingOffset();
     Node* startNode = m_upstreamStart.anchorNode();
-    ASSERT(startNode);
+    DCHECK(startNode);
 
     makeStylingElementsDirectChildrenOfEditableRootToPreventStyleLoss(editingState);
     if (editingState->isAborted())
         return;
 
     // Never remove the start block unless it's a table, in which case we won't merge content in.
     if (startNode == m_startBlock.get() && !startOffset && canHaveChildrenForEditing(startNode) && !isHTMLTableElement(*startNode)) {
         startOffset = 0;
         startNode = NodeTraversal::next(*startNode);
         if (!startNode)
@@ skipping 118 matching lines @@
 }
 
 void DeleteSelectionCommand::fixupWhitespace()
 {
     document().updateLayoutIgnorePendingStylesheets();
     // TODO(yosin) |isRenderedCharacter()| should be removed, and we should use
     // |VisiblePosition::characterAfter()| and
     // |VisiblePosition::characterBefore()|
     if (m_leadingWhitespace.isNotNull() && !isRenderedCharacter(m_leadingWhitespace) && m_leadingWhitespace.anchorNode()->isTextNode()) {
         Text* textNode = toText(m_leadingWhitespace.anchorNode());
-        ASSERT(!textNode->layoutObject() || textNode->layoutObject()->style()->collapseWhiteSpace());
+        DCHECK(!textNode->layoutObject() || textNode->layoutObject()->style()->collapseWhiteSpace()) << textNode;
         replaceTextInNodePreservingMarkers(textNode, m_leadingWhitespace.computeOffsetInContainerNode(), 1, nonBreakingSpaceString());
     }
     if (m_trailingWhitespace.isNotNull() && !isRenderedCharacter(m_trailingWhitespace) && m_trailingWhitespace.anchorNode()->isTextNode()) {
         Text* textNode = toText(m_trailingWhitespace.anchorNode());
-        ASSERT(!textNode->layoutObject() || textNode->layoutObject()->style()->collapseWhiteSpace());
+        DCHECK(!textNode->layoutObject() || textNode->layoutObject()->style()->collapseWhiteSpace()) << textNode;
         replaceTextInNodePreservingMarkers(textNode, m_trailingWhitespace.computeOffsetInContainerNode(), 1, nonBreakingSpaceString());
     }
 }
 
 // If a selection starts in one block and ends in another, we have to merge to bring content before the
 // start together with content after the end.
 void DeleteSelectionCommand::mergeParagraphs(EditingState* editingState)
 {
     if (!m_mergeBlocksAfterDelete) {
         if (m_pruneStartBlockIfNecessary) {
             // We aren't going to merge into the start block, so remove it if it's empty.
             prune(m_startBlock, editingState);
             if (editingState->isAborted())
                 return;
             // Removing the start block during a deletion is usually an indication that we need
             // a placeholder, but not in this case.
             m_needPlaceholder = false;
         }
         return;
     }
 
     // It shouldn't have been asked to both try and merge content into the start block and prune it.
-    ASSERT(!m_pruneStartBlockIfNecessary);
+    DCHECK(!m_pruneStartBlockIfNecessary);
 
     // FIXME: Deletion should adjust selection endpoints as it removes nodes so that we never get into this state (4099839).
     if (!m_downstreamEnd.inShadowIncludingDocument() || !m_upstreamStart.inShadowIncludingDocument())
         return;
 
     // FIXME: The deletion algorithm shouldn't let this happen.
     if (comparePositions(m_upstreamStart, m_downstreamEnd) > 0)
         return;
 
     // There's nothing to merge.
@@ skipping 319 matching lines @@
     visitor->trace(m_deleteIntoBlockquoteStyle);
     visitor->trace(m_startRoot);
     visitor->trace(m_endRoot);
     visitor->trace(m_startTableRow);
     visitor->trace(m_endTableRow);
     visitor->trace(m_temporaryPlaceholder);
     CompositeEditCommand::trace(visitor);
 }
 
 } // namespace blink