ASSERT -> {DCHECK|DCHECK_XX}, ENABLE(ASSERT) -> DCHECK_IS_ON() in dom

third_party/WebKit/Source/core/dom/Range.cpp

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Gunnstein Lye (gunnstein@netcom.no)
  * (C) 2000 Frederik Holljen (frederik.holljen@hig.no)
  * (C) 2001 Peter Kelly (pmk@post.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Motorola Mobility. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 78 matching lines @@
 {
     return new Range(ownerDocument, start.computeContainerNode(), start.computeOffsetInContainerNode(), end.computeContainerNode(), end.computeOffsetInContainerNode());
 }
 
 RawPtr<Range> Range::createAdjustedToTreeScope(const TreeScope& treeScope, const Position& position)
 {
     RawPtr<Range> range = create(treeScope.document(), position, position);
 
     // Make sure the range is in this scope.
     Node* firstNode = range->firstNode();
-    ASSERT(firstNode);
+    DCHECK(firstNode);
     Node* shadowHostInThisScopeOrFirstNode = treeScope.ancestorInThisScope(firstNode);
-    ASSERT(shadowHostInThisScopeOrFirstNode);
+    DCHECK(shadowHostInThisScopeOrFirstNode);
     if (shadowHostInThisScopeOrFirstNode == firstNode)
         return range.release();
 
     // If not, create a range for the shadow host in this scope.
     ContainerNode* container = shadowHostInThisScopeOrFirstNode->parentNode();
-    ASSERT(container);
+    DCHECK(container);
     unsigned offset = shadowHostInThisScopeOrFirstNode->nodeIndex();
     return Range::create(treeScope.document(), container, offset, container, offset);
 }
 
 void Range::dispose()
 {
 #if ENABLE(OILPAN)
     // A prompt detach from the owning Document helps avoid GC overhead.
     m_ownerDocument->detachRange(this);
 #endif
 }
 
 bool Range::inShadowIncludingDocument() const
 {
-    ASSERT(m_start.inShadowIncludingDocument() == m_end.inShadowIncludingDocument());
+    DCHECK_EQ(m_start.inShadowIncludingDocument(), m_end.inShadowIncludingDocument());
     return m_start.inShadowIncludingDocument();
 }
 
 void Range::setDocument(Document& document)
 {
-    ASSERT(m_ownerDocument != document);
-    ASSERT(m_ownerDocument);
+    DCHECK_NE(m_ownerDocument, document);
+    DCHECK(m_ownerDocument);
     m_ownerDocument->detachRange(this);
     m_ownerDocument = &document;
     m_start.setToStartOfNode(document);
     m_end.setToStartOfNode(document);
     m_ownerDocument->attachRange(this);
 }
 
 Node* Range::commonAncestorContainer() const
 {
     return commonAncestorContainer(m_start.container(), m_end.container());
@@ skipping 206 matching lines @@
 }
 
 bool Range::boundaryPointsValid() const
 {
     TrackExceptionState exceptionState;
     return compareBoundaryPoints(m_start, m_end, exceptionState) <= 0 && !exceptionState.hadException();
 }
 
 void Range::deleteContents(ExceptionState& exceptionState)
 {
-    ASSERT(boundaryPointsValid());
+    DCHECK(boundaryPointsValid());
 
     {
         EventQueueScope eventQueueScope;
         processContents(DELETE_CONTENTS, exceptionState);
     }
 }
 
 static bool nodeValidForIntersects(Node* refNode, Document* expectedDocument, ExceptionState& exceptionState)
 {
     if (!refNode) {
@@ skipping 47 matching lines @@
     if (!parentNode)
         return true;
 
     int nodeIndex = refNode->nodeIndex();
 
     Node* startContainerNode = start.computeContainerNode();
     int startOffset = start.computeOffsetInContainerNode();
 
     if (compareBoundaryPoints(parentNode, nodeIndex, startContainerNode, startOffset, exceptionState) < 0 // starts before start
         && compareBoundaryPoints(parentNode, nodeIndex + 1, startContainerNode, startOffset, exceptionState) < 0) { // ends before start
-        ASSERT(!exceptionState.hadException());
+        DCHECK(!exceptionState.hadException());
         return false;
     }
 
     Node* endContainerNode = end.computeContainerNode();
     int endOffset = end.computeOffsetInContainerNode();
 
     if (compareBoundaryPoints(parentNode, nodeIndex, endContainerNode, endOffset, exceptionState) > 0 // starts after end
         && compareBoundaryPoints(parentNode, nodeIndex + 1, endContainerNode, endOffset, exceptionState) > 0) { // ends after end
-        ASSERT(!exceptionState.hadException());
+        DCHECK(!exceptionState.hadException());
         return false;
     }
 
     return true; // all other cases
 }
 
 static inline Node* highestAncestorUnderCommonRoot(Node* node, Node* commonRoot)
 {
     if (node == commonRoot)
         return 0;
 
-    ASSERT(commonRoot->contains(node));
+    DCHECK(commonRoot->contains(node));
 
     while (node->parentNode() != commonRoot)
         node = node->parentNode();
 
     return node;
 }
 
 static inline Node* childOfCommonRootBeforeOffset(Node* container, unsigned offset, Node* commonRoot)
 {
-    ASSERT(container);
-    ASSERT(commonRoot);
+    DCHECK(container);
+    DCHECK(commonRoot);
 
     if (!commonRoot->contains(container))
         return 0;
 
     if (container == commonRoot) {
         container = container->firstChild();
         for (unsigned i = 0; container && i < offset; i++)
             container = container->nextSibling();
     } else {
         while (container->parentNode() != commonRoot)
             container = container->parentNode();
     }
 
     return container;
 }
 
 RawPtr<DocumentFragment> Range::processContents(ActionType action, ExceptionState& exceptionState)
 {
     typedef HeapVector<Member<Node>> NodeVector;
 
     RawPtr<DocumentFragment> fragment = nullptr;
     if (action == EXTRACT_CONTENTS || action == CLONE_CONTENTS)
         fragment = DocumentFragment::create(*m_ownerDocument.get());
 
     if (collapsed())
         return fragment.release();
 
     RawPtr<Node> commonRoot = commonAncestorContainer();
-    ASSERT(commonRoot);
+    DCHECK(commonRoot);
 
     if (m_start.container() == m_end.container()) {
         processContentsBetweenOffsets(action, fragment, m_start.container(), m_start.offset(), m_end.offset(), exceptionState);
         return fragment;
     }
 
     // Since mutation observers can modify the range during the process, the boundary points need to be saved.
     RangeBoundaryPoint originalStart(m_start);
     RangeBoundaryPoint originalEnd(m_end);
 
@@ skipping 81 matching lines @@
 {
     if (data->length() - endOffset)
         data->deleteData(endOffset, data->length() - endOffset, exceptionState);
     if (startOffset)
         data->deleteData(0, startOffset, exceptionState);
 }
 
 RawPtr<Node> Range::processContentsBetweenOffsets(ActionType action, RawPtr<DocumentFragment> fragment,
     Node* container, unsigned startOffset, unsigned endOffset, ExceptionState& exceptionState)
 {
-    ASSERT(container);
-    ASSERT(startOffset <= endOffset);
+    DCHECK(container);
+    DCHECK_LE(startOffset, endOffset);
 
     // This switch statement must be consistent with that of Node::lengthOfContents.
     RawPtr<Node> result = nullptr;
     switch (container->getNodeType()) {
     case Node::TEXT_NODE:
     case Node::CDATA_SECTION_NODE:
     case Node::COMMENT_NODE:
     case Node::PROCESSING_INSTRUCTION_NODE:
         endOffset = std::min(endOffset, toCharacterData(container)->length());
         if (action == EXTRACT_CONTENTS || action == CLONE_CONTENTS) {
@@ skipping 67 matching lines @@
         if (action == EXTRACT_CONTENTS || action == CLONE_CONTENTS) {
             if (RawPtr<Node> clonedAncestor = ancestor->cloneNode(false)) { // Might have been removed already during mutation event.
                 clonedAncestor->appendChild(clonedContainer, exceptionState);
                 clonedContainer = clonedAncestor;
             }
         }
 
         // Copy siblings of an ancestor of start/end containers
         // FIXME: This assertion may fail if DOM is modified during mutation event
         // FIXME: Share code with Range::processNodes
-        ASSERT(!firstChildInAncestorToProcess || firstChildInAncestorToProcess->parentNode() == ancestor);
+        DCHECK(!firstChildInAncestorToProcess || firstChildInAncestorToProcess->parentNode() == ancestor);
 
         NodeVector nodes;
         for (Node* child = firstChildInAncestorToProcess.get(); child;
             child = (direction == ProcessContentsForward) ? child->nextSibling() : child->previousSibling())
             nodes.append(child);
 
         for (const RawPtr<Node>& node : nodes) {
             Node* child = node.get();
             switch (action) {
             case DELETE_CONTENTS:
@@ skipping 128 matching lines @@
                 return;
             }
             m_end.setToBeforeChild(*newText);
         }
     } else {
         RawPtr<Node> lastChild = (newNodeType == Node::DOCUMENT_FRAGMENT_NODE) ? toDocumentFragment(newNode)->lastChild() : newNode.get();
         if (lastChild && lastChild == m_start.childBefore()) {
             // The insertion will do nothing, but we need to extend the range to include
             // the inserted nodes.
             Node* firstChild = (newNodeType == Node::DOCUMENT_FRAGMENT_NODE) ? toDocumentFragment(newNode)->firstChild() : newNode.get();
-            ASSERT(firstChild);
+            DCHECK(firstChild);
             m_start.setToBeforeChild(*firstChild);
             return;
         }
 
         container = m_start.container();
         container->insertBefore(newNode.release(), NodeTraversal::childAt(*container, m_start.offset()), exceptionState);
         if (exceptionState.hadException())
             return;
 
         // Note that m_start.offset() may have changed as a result of container->insertBefore,
@@ skipping 379 matching lines @@
 {
     checkNodeBA(refNode, exceptionState);
     if (exceptionState.hadException())
         return;
 
     setStart(refNode->parentNode(), refNode->nodeIndex(), exceptionState);
 }
 
 void Range::checkExtractPrecondition(ExceptionState& exceptionState)
 {
-    ASSERT(boundaryPointsValid());
+    DCHECK(boundaryPointsValid());
 
     if (!commonAncestorContainer())
         return;
 
     Node* pastLast = pastLastNode();
     for (Node* n = firstNode(); n != pastLast; n = NodeTraversal::next(*n)) {
         if (n->isDocumentTypeNode()) {
             exceptionState.throwDOMException(HierarchyRequestError, "The Range contains a doctype node.");
             return;
         }
@@ skipping 31 matching lines @@
     Vector<IntRect> rects;
     textRects(rects);
     for (const IntRect& rect : rects)
         result.unite(rect);
     return result;
 }
 
 void Range::textRects(Vector<IntRect>& rects, bool useSelectionHeight) const
 {
     Node* startContainer = m_start.container();
-    ASSERT(startContainer);
+    DCHECK(startContainer);
     Node* endContainer = m_end.container();
-    ASSERT(endContainer);
+    DCHECK(endContainer);
 
     Node* stopNode = pastLastNode();
     for (Node* node = firstNode(); node != stopNode; node = NodeTraversal::next(*node)) {
         LayoutObject* r = node->layoutObject();
         if (!r || !r->isText())
             continue;
         LayoutText* layoutText = toLayoutText(r);
         int startOffset = node == startContainer ? m_start.offset() : 0;
         int endOffset = node == endContainer ? m_end.offset() : std::numeric_limits<int>::max();
         layoutText->absoluteRectsForRange(rects, startOffset, endOffset, useSelectionHeight);
     }
 }
 
 void Range::textQuads(Vector<FloatQuad>& quads, bool useSelectionHeight) const
 {
     Node* startContainer = m_start.container();
-    ASSERT(startContainer);
+    DCHECK(startContainer);
     Node* endContainer = m_end.container();
-    ASSERT(endContainer);
+    DCHECK(endContainer);
 
     Node* stopNode = pastLastNode();
     for (Node* node = firstNode(); node != stopNode; node = NodeTraversal::next(*node)) {
         LayoutObject* r = node->layoutObject();
         if (!r || !r->isText())
             continue;
         LayoutText* layoutText = toLayoutText(r);
         int startOffset = node == startContainer ? m_start.offset() : 0;
         int endOffset = node == endContainer ? m_end.offset() : std::numeric_limits<int>::max();
         layoutText->absoluteQuadsForRange(quads, startOffset, endOffset, useSelectionHeight);
@@ skipping 35 matching lines @@
 {
     if (!boundary.childBefore())
         return;
     if (boundary.container() != container)
         return;
     boundary.invalidateOffset();
 }
 
 void Range::nodeChildrenChanged(ContainerNode* container)
 {
-    ASSERT(container);
-    ASSERT(container->document() == m_ownerDocument);
+    DCHECK(container);
+    DCHECK_EQ(container->document(), m_ownerDocument);
     boundaryNodeChildrenChanged(m_start, container);
     boundaryNodeChildrenChanged(m_end, container);
 }
 
 static inline void boundaryNodeChildrenWillBeRemoved(RangeBoundaryPoint& boundary, ContainerNode& container)
 {
     for (Node* nodeToBeRemoved = container.firstChild(); nodeToBeRemoved; nodeToBeRemoved = nodeToBeRemoved->nextSibling()) {
         if (boundary.childBefore() == nodeToBeRemoved) {
             boundary.setToStartOfNode(container);
             return;
         }
 
         for (Node* n = boundary.container(); n; n = n->parentNode()) {
             if (n == nodeToBeRemoved) {
                 boundary.setToStartOfNode(container);
                 return;
             }
         }
     }
 }
 
 void Range::nodeChildrenWillBeRemoved(ContainerNode& container)
 {
-    ASSERT(container.document() == m_ownerDocument);
+    DCHECK_EQ(container.document(), m_ownerDocument);
     boundaryNodeChildrenWillBeRemoved(m_start, container);
     boundaryNodeChildrenWillBeRemoved(m_end, container);
 }
 
 static inline void boundaryNodeWillBeRemoved(RangeBoundaryPoint& boundary, Node& nodeToBeRemoved)
 {
     if (boundary.childBefore() == nodeToBeRemoved) {
         boundary.childBeforeWillBeRemoved();
         return;
     }
 
     for (Node* n = boundary.container(); n; n = n->parentNode()) {
         if (n == nodeToBeRemoved) {
             boundary.setToBeforeChild(nodeToBeRemoved);
             return;
         }
     }
 }
 
 void Range::nodeWillBeRemoved(Node& node)
 {
-    ASSERT(node.document() == m_ownerDocument);
-    ASSERT(node != m_ownerDocument.get());
+    DCHECK_EQ(node.document(), m_ownerDocument);
+    DCHECK_NE(node, m_ownerDocument.get());
 
     // FIXME: Once DOMNodeRemovedFromDocument mutation event removed, we
-    // should change following if-statement to ASSERT(!node->parentNode).
+    // should change following if-statement to DCHECK(!node->parentNode).
     if (!node.parentNode())
         return;
     boundaryNodeWillBeRemoved(m_start, node);
     boundaryNodeWillBeRemoved(m_end, node);
 }
 
 static inline void boundaryTextInserted(RangeBoundaryPoint& boundary, Node* text, unsigned offset, unsigned length)
 {
     if (boundary.container() != text)
         return;
     unsigned boundaryOffset = boundary.offset();
     if (offset >= boundaryOffset)
         return;
     boundary.setOffset(boundaryOffset + length);
 }
 
 void Range::didInsertText(Node* text, unsigned offset, unsigned length)
 {
-    ASSERT(text);
-    ASSERT(text->document() == m_ownerDocument);
+    DCHECK(text);
+    DCHECK_EQ(text->document(), m_ownerDocument);
     boundaryTextInserted(m_start, text, offset, length);
     boundaryTextInserted(m_end, text, offset, length);
 }
 
 static inline void boundaryTextRemoved(RangeBoundaryPoint& boundary, Node* text, unsigned offset, unsigned length)
 {
     if (boundary.container() != text)
         return;
     unsigned boundaryOffset = boundary.offset();
     if (offset >= boundaryOffset)
         return;
     if (offset + length >= boundaryOffset)
         boundary.setOffset(offset);
     else
         boundary.setOffset(boundaryOffset - length);
 }
 
 void Range::didRemoveText(Node* text, unsigned offset, unsigned length)
 {
-    ASSERT(text);
-    ASSERT(text->document() == m_ownerDocument);
+    DCHECK(text);
+    DCHECK_EQ(text->document(), m_ownerDocument);
     boundaryTextRemoved(m_start, text, offset, length);
     boundaryTextRemoved(m_end, text, offset, length);
 }
 
 static inline void boundaryTextNodesMerged(RangeBoundaryPoint& boundary, const NodeWithIndex& oldNode, unsigned offset)
 {
     if (boundary.container() == oldNode.node())
         boundary.set(oldNode.node().previousSibling(), boundary.offset() + offset, 0);
     else if (boundary.container() == oldNode.node().parentNode() && boundary.offset() == oldNode.index())
         boundary.set(oldNode.node().previousSibling(), offset, 0);
 }
 
 void Range::didMergeTextNodes(const NodeWithIndex& oldNode, unsigned offset)
 {
-    ASSERT(oldNode.node().document() == m_ownerDocument);
-    ASSERT(oldNode.node().parentNode());
-    ASSERT(oldNode.node().isTextNode());
-    ASSERT(oldNode.node().previousSibling());
-    ASSERT(oldNode.node().previousSibling()->isTextNode());
+    DCHECK_EQ(oldNode.node().document(), m_ownerDocument);
+    DCHECK(oldNode.node().parentNode());
+    DCHECK(oldNode.node().isTextNode());
+    DCHECK(oldNode.node().previousSibling());
+    DCHECK(oldNode.node().previousSibling()->isTextNode());
     boundaryTextNodesMerged(m_start, oldNode, offset);
     boundaryTextNodesMerged(m_end, oldNode, offset);
 }
 
 void Range::updateOwnerDocumentIfNeeded()
 {
-    ASSERT(m_start.container());
-    ASSERT(m_end.container());
+    DCHECK(m_start.container());
+    DCHECK(m_end.container());
     Document& newDocument = m_start.container()->document();
-    ASSERT(newDocument == m_end.container()->document());
+    DCHECK_EQ(newDocument, m_end.container()->document());
     if (newDocument == m_ownerDocument)
         return;
     m_ownerDocument->detachRange(this);
     m_ownerDocument = &newDocument;
     m_ownerDocument->attachRange(this);
 }
 
 static inline void boundaryTextNodeSplit(RangeBoundaryPoint& boundary, Text& oldNode)
 {
     Node* boundaryContainer = boundary.container();
     unsigned boundaryOffset = boundary.offset();
     if (boundary.childBefore() == &oldNode)
         boundary.set(boundaryContainer, boundaryOffset + 1, oldNode.nextSibling());
     else if (boundary.container() == &oldNode && boundaryOffset > oldNode.length())
         boundary.set(oldNode.nextSibling(), boundaryOffset - oldNode.length(), 0);
 }
 
 void Range::didSplitTextNode(Text& oldNode)
 {
-    ASSERT(oldNode.document() == m_ownerDocument);
-    ASSERT(oldNode.parentNode());
-    ASSERT(oldNode.nextSibling());
-    ASSERT(oldNode.nextSibling()->isTextNode());
+    DCHECK_EQ(oldNode.document(), m_ownerDocument);
+    DCHECK(oldNode.parentNode());
+    DCHECK(oldNode.nextSibling());
+    DCHECK(oldNode.nextSibling()->isTextNode());
     boundaryTextNodeSplit(m_start, oldNode);
     boundaryTextNodeSplit(m_end, oldNode);
-    ASSERT(boundaryPointsValid());
+    DCHECK(boundaryPointsValid());
 }
 
 void Range::expand(const String& unit, ExceptionState& exceptionState)
 {
     VisiblePosition start = createVisiblePosition(startPosition());
     VisiblePosition end = createVisiblePosition(endPosition());
     if (unit == "word") {
         start = startOfWord(start);
         end = endOfWord(end);
     } else if (unit == "sentence") {
@@ skipping 102 matching lines @@
 {
     if (range && range->boundaryPointsValid()) {
         range->startContainer()->showTreeAndMark(range->startContainer(), "S", range->endContainer(), "E");
         fprintf(stderr, "start offset: %d, end offset: %d\n", range->startOffset(), range->endOffset());
     } else {
         fprintf(stderr, "Cannot show tree if range is null, or if boundary points are invalid.\n");
     }
 }
 
 #endif