ASSERT -> DCHECK in core/editing.

third_party/WebKit/Source/core/editing/serializers/StyledMarkupSerializer.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009, 2010, 2011 Google Inc. All rights reserved.
  * Copyright (C) 2011 Igalia S.L.
  * Copyright (C) 2011 Motorola Mobility. 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
@@ skipping 134 matching lines @@
 
 template <typename Strategy>
 static bool needInterchangeNewlineAt(const VisiblePositionTemplate<Strategy>& v)
 {
     return needInterchangeNewlineAfter(previousPositionOf(v));
 }
 
 template<typename Strategy>
 static bool areSameRanges(Node* node, const PositionTemplate<Strategy>& startPosition, const PositionTemplate<Strategy>& endPosition)
 {
-    ASSERT(node);
+    DCHECK(node);
     const EphemeralRange range = VisibleSelection::selectionFromContentsOfNode(node).toNormalizedEphemeralRange();
     return toPositionInDOMTree(startPosition) == range.startPosition() && toPositionInDOMTree(endPosition) == range.endPosition();
 }
 
 static EditingStyle* styleFromMatchedRulesAndInlineDecl(const HTMLElement* element)
 {
     EditingStyle* style = EditingStyle::create(element->inlineStyle());
     // FIXME: Having to const_cast here is ugly, but it is quite a bit of work to untangle
     // the non-const-ness of styleFromMatchedRulesForElement.
     style->mergeStyleFromRules(const_cast<HTMLElement*>(element));
@@ skipping 24 matching lines @@
     }
 
     if (!m_lastClosed)
         m_lastClosed = StyledMarkupTraverser<Strategy>().traverse(firstNode, pastEnd);
     StyledMarkupTraverser<Strategy> traverser(&markupAccumulator, m_lastClosed);
     Node* lastClosed = traverser.traverse(firstNode, pastEnd);
 
     if (m_highestNodeToBeSerialized && lastClosed) {
         // TODO(hajimehoshi): This is calculated at createMarkupInternal too.
         Node* commonAncestor = Strategy::commonAncestor(*m_start.computeContainerNode(), *m_end.computeContainerNode());
-        ASSERT(commonAncestor);
+        DCHECK(commonAncestor);
         HTMLBodyElement* body = toHTMLBodyElement(enclosingElementWithTag(firstPositionInNode(commonAncestor), bodyTag));
         HTMLBodyElement* fullySelectedRoot = nullptr;
         // FIXME: Do this for all fully selected blocks, not just the body.
         if (body && areSameRanges(body, m_start, m_end))
             fullySelectedRoot = body;
 
         // Also include all of the ancestors of lastClosed up to this special ancestor.
         // FIXME: What is ancestor?
         for (ContainerNode* ancestor = Strategy::parent(*lastClosed); ancestor; ancestor = Strategy::parent(*ancestor)) {
             if (ancestor == fullySelectedRoot && !markupAccumulator.convertBlocksToInlines()) {
@@ skipping 44 matching lines @@
 {
 }
 
 template<typename Strategy>
 StyledMarkupTraverser<Strategy>::StyledMarkupTraverser(StyledMarkupAccumulator* accumulator, Node* lastClosed)
     : m_accumulator(accumulator)
     , m_lastClosed(lastClosed)
     , m_wrappingStyle(nullptr)
 {
     if (!m_accumulator) {
-        ASSERT(!m_lastClosed);
+        DCHECK(!m_lastClosed);

[yosin_UTC9, 2016/04/14 04:35:04]

|DCHECK_EQ(m_lastClosed, nullptr)|

         return;
     }
     if (!m_lastClosed)
         return;
     ContainerNode* parent = Strategy::parent(*m_lastClosed);
     if (!parent)
         return;
     if (shouldAnnotate()) {
         m_wrappingStyle = EditingStyle::wrappingStyleForAnnotatedSerialization(parent);
         return;
@@ skipping 40 matching lines @@
         }
 
         // If we didn't insert open tag and there's no more siblings or we're at the end of the traversal, take care of ancestors.
         // FIXME: What happens if we just inserted open tag and reached the end?
         if (Strategy::nextSibling(*n) && next != pastEnd)
             continue;
 
         // Close up the ancestors.
         while (!ancestorsToClose.isEmpty()) {
             ContainerNode* ancestor = ancestorsToClose.last();
-            ASSERT(ancestor);
+            DCHECK(ancestor);
             if (next && next != pastEnd && Strategy::isDescendantOf(*next, *ancestor))
                 break;
             // Not at the end of the range, close ancestors up to sibling of next node.
             appendEndMarkup(*ancestor);
             lastClosed = ancestor;
             ancestorsToClose.removeLast();
         }
 
         // Surround the currently accumulated markup with markup for ancestors we never opened as we leave the subtree(s) rooted at those ancestors.
         ContainerNode* nextParent = next ? Strategy::parent(*next) : nullptr;
         if (next == pastEnd || n == nextParent)
             continue;
 
-        ASSERT(n);
+        DCHECK(n);
         Node* lastAncestorClosedOrSelf = (lastClosed && Strategy::isDescendantOf(*n, *lastClosed)) ? lastClosed : n;
         for (ContainerNode* parent = Strategy::parent(*lastAncestorClosedOrSelf); parent && parent != nextParent; parent = Strategy::parent(*parent)) {
             // All ancestors that aren't in the ancestorsToClose list should either be a) unrendered:
             if (!parent->layoutObject())
                 continue;
             // or b) ancestors that we never encountered during a pre-order traversal starting at startNode:
-            ASSERT(startNode);
-            ASSERT(Strategy::isDescendantOf(*startNode, *parent));
+            DCHECK(startNode);
+            DCHECK(Strategy::isDescendantOf(*startNode, *parent));

[yosin_UTC9, 2016/04/14 04:35:04]

How about adding |<< startNode << ' ' << parent|?

             EditingStyle* style = createInlineStyleIfNeeded(*parent);
             wrapWithNode(*parent, style);
             lastClosed = parent;
         }
     }
 
     return lastClosed;
 }
 
 template<typename Strategy>
@@ skipping 115 matching lines @@
     if (element.isHTMLElement() && shouldAnnotate())
         inlineStyle->mergeStyleFromRulesForSerialization(&toHTMLElement(element));
 
     return inlineStyle;
 }
 
 template class StyledMarkupSerializer<EditingStrategy>;
 template class StyledMarkupSerializer<EditingInFlatTreeStrategy>;
 
 } // namespace blink