ASSERT -> DCHECK in core/editing.

third_party/WebKit/Source/core/editing/VisibleSelection.cpp

 /*
  * Copyright (C) 2004, 2005, 2006 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 82 matching lines @@
 template <typename Strategy>
 VisibleSelectionTemplate<Strategy>::VisibleSelectionTemplate(const EphemeralRangeTemplate<Strategy>& range, TextAffinity affinity, bool isDirectional)
     : VisibleSelectionTemplate(range.startPosition(), range.endPosition(), affinity, isDirectional)
 {
 }
 
 template <typename Strategy>
 static SelectionType computeSelectionType(const PositionTemplate<Strategy>& start, const PositionTemplate<Strategy>& end)
 {
     if (start.isNull()) {
-        ASSERT(end.isNull());
+        DCHECK(end.isNull());
         return NoSelection;
     }
     if (start == end)
         return CaretSelection;
     // TODO(yosin) We should call |Document::updateLayout()| here for
     // |mostBackwardCaretPosition()|. However, we are here during
     // |Node::removeChild()|.
     start.anchorNode()->updateDistribution();
     end.anchorNode()->updateDistribution();
     if (mostBackwardCaretPosition(start) == mostBackwardCaretPosition(end))
@@ skipping 32 matching lines @@
     m_baseIsFirst = other.m_baseIsFirst;
     m_isDirectional = other.m_isDirectional;
     m_granularity = other.m_granularity;
     m_hasTrailingWhitespace = other.m_hasTrailingWhitespace;
     return *this;
 }
 
 template <typename Strategy>
 VisibleSelectionTemplate<Strategy> VisibleSelectionTemplate<Strategy>::selectionFromContentsOfNode(Node* node)
 {
-    ASSERT(!Strategy::editingIgnoresContent(node));
+    DCHECK(!Strategy::editingIgnoresContent(node));
     return VisibleSelectionTemplate(PositionTemplate<Strategy>::firstPositionInNode(node), PositionTemplate<Strategy>::lastPositionInNode(node));
 }
 
 template <typename Strategy>
 void VisibleSelectionTemplate<Strategy>::setBase(const PositionTemplate<Strategy>& position)
 {
     const PositionTemplate<Strategy> oldBase = m_base;
     m_base = position;
     validate();
     if (m_base != oldBase)
@@ skipping 71 matching lines @@
     // the selection. Again, this is to match the conventions of text editors
     // tested, which make style determinations based on the first character of
     // the selection. For instance, this operation helps to make sure that the
     // "X" selected below is the only thing selected. The range should not be
     // allowed to "leak" out to the end of the previous text node, or to the
     // beginning of the next text node, each of which has a different style.
     //
     // On a treasure map, <b>X</b> marks the spot.
     //                       ^ selected
     //
-    ASSERT(isRange());
+    DCHECK(isRange());
     return normalizeRange(EphemeralRangeTemplate<Strategy>(m_start, m_end));
 }
 
 template <typename Strategy>
 bool VisibleSelectionTemplate<Strategy>::expandUsingGranularity(TextGranularity granularity)
 {
     if (isNone())
         return false;
 
     // TODO(yosin) Do we need to check all of them?
@@ skipping 19 matching lines @@
     Element* boundary = enclosingBlockFlowElement(*node);
     if (!boundary)
         return EphemeralRangeTemplate<Strategy>();
 
     return EphemeralRangeTemplate<Strategy>(pos, PositionTemplate<Strategy>::lastPositionInNode(boundary));
 }
 
 template <typename Strategy>
 void VisibleSelectionTemplate<Strategy>::appendTrailingWhitespace()
 {
-    ASSERT(m_granularity == WordGranularity);
+    DCHECK_EQ(m_granularity, WordGranularity);
     const EphemeralRangeTemplate<Strategy> searchRange = makeSearchRange(end());
     if (searchRange.isNull())
         return;
 
     CharacterIteratorAlgorithm<Strategy> charIt(searchRange.startPosition(), searchRange.endPosition(), TextIteratorEmitsCharactersBetweenAllVisiblePositions);
     bool changed = false;
 
     for (; charIt.length(); charIt.advance(1)) {
         UChar c = charIt.characterAt(0);
         if ((!isSpaceOrNewline(c) && c != noBreakSpaceCharacter) || c == '\n')
@@ skipping 30 matching lines @@
         m_extent = m_base;
         m_baseIsFirst = true;
     } else {
         m_baseIsFirst = m_base.compareTo(m_extent) <= 0;
     }
 }
 
 template <typename Strategy>
 void VisibleSelectionTemplate<Strategy>::setStartRespectingGranularity(TextGranularity granularity, EWordSide wordSide)
 {
-    ASSERT(m_base.isNotNull());
-    ASSERT(m_extent.isNotNull());
+    DCHECK(m_base.isNotNull());
+    DCHECK(m_extent.isNotNull());
 
     m_start = m_baseIsFirst ? m_base : m_extent;
 
     switch (granularity) {
     case CharacterGranularity:
         // Don't do any expansion.
         break;
     case WordGranularity: {
         // General case: Select the word the caret is positioned inside of.
         // If the caret is on the word boundary, select the word according to |wordSide|.
@@ skipping 38 matching lines @@
     }
 
     // Make sure we do not have a Null position.
     if (m_start.isNull())
         m_start = m_baseIsFirst ? m_base : m_extent;
 }
 
 template <typename Strategy>
 void VisibleSelectionTemplate<Strategy>::setEndRespectingGranularity(TextGranularity granularity, EWordSide wordSide)
 {
-    ASSERT(m_base.isNotNull());
-    ASSERT(m_extent.isNotNull());
+    DCHECK(m_base.isNotNull());
+    DCHECK(m_extent.isNotNull());
 
     m_end = m_baseIsFirst ? m_extent : m_base;
 
     switch (granularity) {
     case CharacterGranularity:
         // Don't do any expansion.
         break;
     case WordGranularity: {
         // General case: Select the word the caret is positioned inside of.
         // If the caret is on the word boundary, select the word according to
@@ skipping 114 matching lines @@
     setBaseAndExtentToDeepEquivalents();
     if (m_base.isNull() || m_extent.isNull()) {
         m_base = m_extent = m_start = m_end = PositionTemplate<Strategy>();
         updateSelectionType();
         return;
     }
 
     m_start = m_baseIsFirst ? m_base : m_extent;
     m_end = m_baseIsFirst ? m_extent : m_base;
     setStartRespectingGranularity(granularity);
-    ASSERT(m_start.isNotNull());
+    DCHECK(m_start.isNotNull());
     setEndRespectingGranularity(granularity);
-    ASSERT(m_end.isNotNull());
+    DCHECK(m_end.isNotNull());
     adjustSelectionToAvoidCrossingShadowBoundaries();
     adjustSelectionToAvoidCrossingEditingBoundaries();
     updateSelectionType();
 
     if (getSelectionType() == RangeSelection) {
         // "Constrain" the selection to be the smallest equivalent range of
         // nodes. This is a somewhat arbitrary choice, but experience shows that
         // it is useful to make to make the selection "canonical" (if only for
         // purposes of comparing selections). This is an ideal point of the code
         // to do this operation, since all selection changes that result in a
@@ skipping 243 matching lines @@
 {
 }
 
 VisibleSelectionChangeObserver::~VisibleSelectionChangeObserver()
 {
 }
 
 template <typename Strategy>
 void VisibleSelectionTemplate<Strategy>::setChangeObserver(VisibleSelectionChangeObserver& observer)
 {
-    ASSERT(!m_changeObserver);
+    DCHECK(!m_changeObserver);
     m_changeObserver = &observer;
 }
 
 template <typename Strategy>
 void VisibleSelectionTemplate<Strategy>::clearChangeObserver()
 {
-    ASSERT(m_changeObserver);
+    DCHECK(m_changeObserver);
     m_changeObserver = nullptr;
 }
 
 template <typename Strategy>
 void VisibleSelectionTemplate<Strategy>::didChange()
 {
     if (m_changeObserver)
         m_changeObserver->didChangeVisibleSelection();
 }
 
@@ skipping 148 matching lines @@
 {
     sel.showTreeForThis();
 }
 
 void showTree(const blink::VisibleSelectionInFlatTree* sel)
 {
     if (sel)
         sel->showTreeForThis();
 }
 #endif