ASSERT -> DCHECK in core/editing.

third_party/WebKit/Source/core/editing/serializers/Serialization.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 109 matching lines @@
                 changes.append(AttributeChange(&element, attribute.name(), KURL(parsedBaseURL, attribute.value()).getString()));
         }
     }
 
     for (auto& change : changes)
         change.apply();
 }
 
 static bool isHTMLBlockElement(const Node* node)
 {
-    ASSERT(node);
+    DCHECK(node);
     return isHTMLTableCellElement(*node)
         || isNonTableCellHTMLBlockElement(node);
 }
 
 static HTMLElement* ancestorToRetainStructureAndAppearanceForBlock(Element* commonAncestorBlock)
 {
     if (!commonAncestorBlock)
         return 0;
 
     if (commonAncestorBlock->hasTagName(tbodyTag) || isHTMLTableRowElement(*commonAncestorBlock))
@@ skipping 38 matching lines @@
         || element.hasTagName(iTag) || element.hasTagName(emTag) || element.hasTagName(bTag) || element.hasTagName(strongTag);
 }
 
 template<typename Strategy>
 static HTMLElement* highestAncestorToWrapMarkup(const PositionTemplate<Strategy>& startPosition, const PositionTemplate<Strategy>& endPosition, EAnnotateForInterchange shouldAnnotate, Node* constrainingAncestor)
 {
     Node* firstNode = startPosition.nodeAsRangeFirstNode();
     // For compatibility reason, we use container node of start and end
     // positions rather than first node and last node in selection.
     Node* commonAncestor = Strategy::commonAncestor(*startPosition.computeContainerNode(), *endPosition.computeContainerNode());
-    ASSERT(commonAncestor);
+    DCHECK(commonAncestor);
     HTMLElement* specialCommonAncestor = nullptr;
     if (shouldAnnotate == AnnotateForInterchange) {
         // Include ancestors that aren't completely inside the range but are required to retain
         // the structure and appearance of the copied markup.
         specialCommonAncestor = ancestorToRetainStructureAndAppearance(commonAncestor);
         if (Node* parentListNode = enclosingNodeOfType(firstPositionInOrBeforeNode(firstNode), isListItem)) {
             EphemeralRangeTemplate<Strategy> markupRange = EphemeralRangeTemplate<Strategy>(startPosition, endPosition);
             EphemeralRangeTemplate<Strategy> nodeRange = normalizeRange(EphemeralRangeTemplate<Strategy>::rangeOfContents(*parentListNode));
             if (nodeRange == markupRange) {
                 ContainerNode* ancestor = parentListNode->parentNode();
@@ skipping 105 matching lines @@
 
 static void trimFragment(DocumentFragment* fragment, Comment* nodeBeforeContext, Comment* nodeAfterContext)
 {
     Node* next = nullptr;
     for (Node* node = fragment->firstChild(); node; node = next) {
         if (nodeBeforeContext->isDescendantOf(node)) {
             next = NodeTraversal::next(*node);
             continue;
         }
         next = NodeTraversal::nextSkippingChildren(*node);
-        ASSERT(!node->contains(nodeAfterContext));
+        DCHECK(!node->contains(nodeAfterContext));

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

How about adding |<< node << ' ' << nodeAfterContext|?

         node->parentNode()->removeChild(node, ASSERT_NO_EXCEPTION);
         if (nodeBeforeContext == node)
             break;
     }
 
-    ASSERT(nodeAfterContext->parentNode());
+    DCHECK(nodeAfterContext->parentNode());

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

How about adding |<< nodeAfterContext|?

     for (Node* node = nodeAfterContext; node; node = next) {
         next = NodeTraversal::nextSkippingChildren(*node);
         node->parentNode()->removeChild(node, ASSERT_NO_EXCEPTION);
     }
 }
 
 DocumentFragment* createFragmentFromMarkupWithContext(Document& document, const String& markup, unsigned fragmentStart, unsigned fragmentEnd,
     const String& baseURL, ParserContentPolicy parserContentPolicy)
 {
     // FIXME: Need to handle the case where the markup already contains these markers.
@@ skipping 51 matching lines @@
 
 static void fillContainerFromString(ContainerNode* paragraph, const String& string)
 {
     Document& document = paragraph->document();
 
     if (string.isEmpty()) {
         paragraph->appendChild(HTMLBRElement::create(document));
         return;
     }
 
-    ASSERT(string.find('\n') == kNotFound);
+    DCHECK_EQ(string.find('\n'), kNotFound);

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

How about adding |<< string|?

 
     Vector<String> tabList;
     string.split('\t', true, tabList);
     StringBuilder tabText;
     bool first = true;
     size_t numEntries = tabList.size();
     for (size_t i = 0; i < numEntries; ++i) {
         const String& s = tabList[i];
 
         // append the non-tab textual part
@@ skipping 12 matching lines @@
             tabText.append('\t');
         else if (!tabText.isEmpty())
             paragraph->appendChild(createTabSpanElement(document, tabText.toString()));
 
         first = false;
     }
 }
 
 bool isPlainTextMarkup(Node* node)
 {
-    ASSERT(node);
+    DCHECK(node);
     if (!isHTMLDivElement(*node))
         return false;
 
     HTMLDivElement& element = toHTMLDivElement(*node);
     if (!element.hasAttributes())
         return false;
 
     if (element.hasOneChild())
         return element.firstChild()->isTextNode() || element.firstChild()->hasChildren();
 
@@ skipping 71 matching lines @@
                 element = createDefaultParagraphElement(document);
             fillContainerFromString(element, s);
         }
         fragment->appendChild(element);
     }
     return fragment;
 }
 
 DocumentFragment* createFragmentForInnerOuterHTML(const String& markup, Element* contextElement, ParserContentPolicy parserContentPolicy, const char* method, ExceptionState& exceptionState)
 {
-    ASSERT(contextElement);
+    DCHECK(contextElement);
     Document& document = isHTMLTemplateElement(*contextElement) ? contextElement->document().ensureTemplateDocument() : contextElement->document();
     DocumentFragment* fragment = DocumentFragment::create(document);
 
     if (document.isHTMLDocument()) {
         fragment->parseHTML(markup, contextElement, parserContentPolicy);
         return fragment;
     }
 
     bool wasValid = fragment->parseXML(markup, contextElement, parserContentPolicy);
     if (!wasValid) {
@@ skipping 33 matching lines @@
     for (Node* child = element->firstChild(); child; child = nextChild) {
         nextChild = child->nextSibling();
         element->removeChild(child);
         fragment->insertBefore(child, element);
     }
     fragment->removeChild(element);
 }
 
 static inline bool isSupportedContainer(Element* element)
 {
-    ASSERT(element);
+    DCHECK(element);
     if (!element->isHTMLElement())
         return true;
 
     HTMLElement& htmlElement = toHTMLElement(*element);
     if (htmlElement.hasTagName(colTag) || htmlElement.hasTagName(colgroupTag) || htmlElement.hasTagName(framesetTag)
         || htmlElement.hasTagName(headTag) || htmlElement.hasTagName(styleTag) || htmlElement.hasTagName(titleTag)) {
         return false;
     }
     return !htmlElement.ieForbidsInsertHTML();
 }
 
 DocumentFragment* createContextualFragment(const String& markup, Element* element, ParserContentPolicy parserContentPolicy, ExceptionState& exceptionState)
 {
-    ASSERT(element);
+    DCHECK(element);
     if (!isSupportedContainer(element)) {
         exceptionState.throwDOMException(NotSupportedError, "The range's container is '" + element->localName() + "', which is not supported.");
         return nullptr;
     }
 
     DocumentFragment* fragment = createFragmentForInnerOuterHTML(markup, element, parserContentPolicy, "createContextualFragment", exceptionState);
     if (!fragment)
         return nullptr;
 
     // We need to pop <html> and <body> elements and remove <head> to
     // accommodate folks passing complete HTML documents to make the
     // child of an element.
 
     Node* nextNode = nullptr;
     for (Node* node = fragment->firstChild(); node; node = nextNode) {
         nextNode = node->nextSibling();
         if (isHTMLHtmlElement(*node) || isHTMLHeadElement(*node) || isHTMLBodyElement(*node)) {
             HTMLElement* element = toHTMLElement(node);
             if (Node* firstChild = element->firstChild())
                 nextNode = firstChild;
             removeElementPreservingChildren(fragment, element);
         }
     }
     return fragment;
 }
 
 void replaceChildrenWithFragment(ContainerNode* container, DocumentFragment* fragment, ExceptionState& exceptionState)
 {
-    ASSERT(container);
+    DCHECK(container);
     ContainerNode* containerNode(container);
 
     ChildListMutationScope mutation(*containerNode);
 
     if (!fragment->firstChild()) {
         containerNode->removeChildren();
         return;
     }
 
     // FIXME: This is wrong if containerNode->firstChild() has more than one ref!
     if (containerNode->hasOneTextChild() && fragment->hasOneTextChild()) {
         toText(containerNode->firstChild())->setData(toText(fragment->firstChild())->data());
         return;
     }
 
     // FIXME: No need to replace the child it is a text node and its contents are already == text.
     if (containerNode->hasOneChild()) {
         containerNode->replaceChild(fragment, containerNode->firstChild(), exceptionState);
         return;
     }
 
     containerNode->removeChildren();
     containerNode->appendChild(fragment, exceptionState);
 }
 
 void replaceChildrenWithText(ContainerNode* container, const String& text, ExceptionState& exceptionState)
 {
-    ASSERT(container);
+    DCHECK(container);
     ContainerNode* containerNode(container);
 
     ChildListMutationScope mutation(*containerNode);
 
     // FIXME: This is wrong if containerNode->firstChild() has more than one ref! Example:
     // <div>foo</div>
     // <script>
     // var oldText = div.firstChild;
     // console.log(oldText.data); // foo
     // div.innerText = "bar";
@@ skipping 14 matching lines @@
         containerNode->replaceChild(textNode, containerNode->firstChild(), exceptionState);
         return;
     }
 
     containerNode->removeChildren();
     containerNode->appendChild(textNode, exceptionState);
 }
 
 void mergeWithNextTextNode(Text* textNode, ExceptionState& exceptionState)
 {
-    ASSERT(textNode);
+    DCHECK(textNode);
     Node* next = textNode->nextSibling();
     if (!next || !next->isTextNode())
         return;
 
     Text* textNext = toText(next);
     textNode->appendData(textNext->data());
     if (textNext->parentNode()) // Might have been removed by mutation event.
         textNext->remove(exceptionState);
 }
 
 template class CORE_TEMPLATE_EXPORT CreateMarkupAlgorithm<EditingStrategy>;
 template class CORE_TEMPLATE_EXPORT CreateMarkupAlgorithm<EditingInFlatTreeStrategy>;
 
 } // namespace blink