Replace ASSERT()s with DCHECK*() in core/html/*.{cpp,h}.

third_party/WebKit/Source/core/html/HTMLCollection.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003-2008, 2011, 2012, 2014 Apple Inc. All rights reserved.
  * Copyright (C) 2014 Samsung Electronics. 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
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 57 matching lines @@
     case TRCells:
     case TSectionRows:
     case TableTBodies:
         return true;
     case NameNodeListType:
     case RadioNodeListType:
     case RadioImgNodeListType:
     case LabelsNodeListType:
         break;
     }
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return false;
 }
 
 static NodeListRootType rootTypeFromCollectionType(CollectionType type)
 {
     switch (type) {
     case DocImages:
     case DocApplets:
     case DocEmbeds:
     case DocForms:
@@ skipping 17 matching lines @@
     case SelectedOptions:
     case DataListOptions:
     case MapAreas:
         return NodeListRootType::Node;
     case NameNodeListType:
     case RadioNodeListType:
     case RadioImgNodeListType:
     case LabelsNodeListType:
         break;
     }
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return NodeListRootType::Node;
 }
 
 static NodeListInvalidationType invalidationTypeExcludingIdAndNameAttributes(CollectionType type)
 {
     switch (type) {
     case TagCollectionType:
     case HTMLTagCollectionType:
     case DocImages:
     case DocEmbeds:
@@ skipping 24 matching lines @@
     case FormControls:
         return InvalidateForFormControls;
     case ClassCollectionType:
         return InvalidateOnClassAttrChange;
     case NameNodeListType:
     case RadioNodeListType:
     case RadioImgNodeListType:
     case LabelsNodeListType:
         break;
     }
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return DoNotInvalidateOnAttributeChanges;
 }
 
 HTMLCollection::HTMLCollection(ContainerNode& ownerNode, CollectionType type, ItemAfterOverrideType itemAfterOverrideType)
     : LiveNodeListBase(ownerNode, rootTypeFromCollectionType(type), invalidationTypeExcludingIdAndNameAttributes(type), type)
     , m_overridesItemAfter(itemAfterOverrideType == OverridesItemAfter)
     , m_shouldOnlyIncludeDirectChildren(shouldTypeOnlyIncludeDirectChildren(type))
 {
 }
 
@@ skipping 60 matching lines @@
     case HTMLTagCollectionType:
     case DocAll:
     case NodeChildren:
     case FormControls:
     case TableRows:
     case WindowNamedItems:
     case NameNodeListType:
     case RadioNodeListType:
     case RadioImgNodeListType:
     case LabelsNodeListType:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
     }
     return false;
 }
 
 inline bool HTMLCollection::elementMatches(const Element& element) const
 {
     // These collections apply to any kind of Elements, not just HTMLElements.
     switch (type()) {
     case DocAll:
     case NodeChildren:
@@ skipping 33 matching lines @@
     Member<const HTMLCollectionType> m_list;
 };
 
 } // namespace
 
 template <class HTMLCollectionType>
 static inline IsMatch<HTMLCollectionType> makeIsMatch(const HTMLCollectionType& list) { return IsMatch<HTMLCollectionType>(list); }
 
 Element* HTMLCollection::virtualItemAfter(Element*) const
 {
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return nullptr;
 }
 
 // https://html.spec.whatwg.org/multipage/infrastructure.html#all-named-elements
 // The document.all collection returns only certain types of elements by name,
 // although it returns any type of element by id.
 static inline bool nameShouldBeVisibleInDocumentAll(const HTMLElement& element)
 {
     return element.hasTagName(aTag)
         || element.hasTagName(appletTag)
@@ skipping 23 matching lines @@
         if (overridesItemAfter())
             return virtualItemAfter(0);
         if (shouldOnlyIncludeDirectChildren())
             return ElementTraversal::firstChild(rootNode(), makeIsMatch(*this));
         return ElementTraversal::firstWithin(rootNode(), makeIsMatch(*this));
     }
 }
 
 Element* HTMLCollection::traverseToLast() const
 {
-    ASSERT(canTraverseBackward());
+    DCHECK(canTraverseBackward());
     if (shouldOnlyIncludeDirectChildren())
         return ElementTraversal::lastChild(rootNode(), makeIsMatch(*this));
     return ElementTraversal::lastWithin(rootNode(), makeIsMatch(*this));
 }
 
 Element* HTMLCollection::traverseForwardToOffset(unsigned offset, Element& currentElement, unsigned& currentOffset) const
 {
-    ASSERT(currentOffset < offset);
+    DCHECK_LT(currentOffset, offset);
     switch (type()) {
     case HTMLTagCollectionType:
         return traverseMatchingElementsForwardToOffset(currentElement, &rootNode(), offset, currentOffset, makeIsMatch(toHTMLTagCollection(*this)));
     case ClassCollectionType:
         return traverseMatchingElementsForwardToOffset(currentElement, &rootNode(), offset, currentOffset, makeIsMatch(toClassCollection(*this)));
     default:
         if (overridesItemAfter()) {
             for (Element* next = virtualItemAfter(&currentElement); next; next = virtualItemAfter(next)) {
                 if (++currentOffset == offset)
                     return next;
             }
             return nullptr;
         }
         if (shouldOnlyIncludeDirectChildren()) {
             IsMatch<HTMLCollection> isMatch(*this);
             for (Element* next = ElementTraversal::nextSibling(currentElement, isMatch); next; next = ElementTraversal::nextSibling(*next, isMatch)) {
                 if (++currentOffset == offset)
                     return next;
             }
             return nullptr;
         }
         return traverseMatchingElementsForwardToOffset(currentElement, &rootNode(), offset, currentOffset, makeIsMatch(*this));
     }
 }
 
 Element* HTMLCollection::traverseBackwardToOffset(unsigned offset, Element& currentElement, unsigned& currentOffset) const
 {
-    ASSERT(currentOffset > offset);
-    ASSERT(canTraverseBackward());
+    DCHECK_GT(currentOffset, offset);
+    DCHECK(canTraverseBackward());
     if (shouldOnlyIncludeDirectChildren()) {
         IsMatch<HTMLCollection> isMatch(*this);
         for (Element* previous = ElementTraversal::previousSibling(currentElement, isMatch); previous; previous = ElementTraversal::previousSibling(*previous, isMatch)) {
             if (--currentOffset == offset)
                 return previous;
         }
         return nullptr;
     }
     return traverseMatchingElementsBackwardToOffset(currentElement, &rootNode(), offset, currentOffset, makeIsMatch(*this));
 }
@@ skipping 77 matching lines @@
         const AtomicString& nameAttrVal = element->getNameAttribute();
         if (!nameAttrVal.isEmpty() && idAttrVal != nameAttrVal && (type() != DocAll || nameShouldBeVisibleInDocumentAll(toHTMLElement(*element))))
             cache->addElementWithName(nameAttrVal, element);
     }
     // Set the named item cache last as traversing the tree may cause cache invalidation.
     setNamedItemCache(cache);
 }
 
 void HTMLCollection::namedItems(const AtomicString& name, HeapVector<Member<Element>>& result) const
 {
-    ASSERT(result.isEmpty());
+    DCHECK(result.isEmpty());
     if (name.isEmpty())
         return;
 
     updateIdNameCache();
 
     const NamedItemCache& cache = namedItemCache();
     if (HeapVector<Member<Element>>* idResults = cache.getElementsById(name)) {
         for (unsigned i = 0; i < idResults->size(); ++i)
             result.append(idResults->at(i));
     }
     if (HeapVector<Member<Element>>* nameResults = cache.getElementsByName(name)) {
         for (unsigned i = 0; i < nameResults->size(); ++i)
             result.append(nameResults->at(i));
     }
 }
 
 HTMLCollection::NamedItemCache::NamedItemCache()
 {
 }
 
 DEFINE_TRACE(HTMLCollection)
 {
     visitor->trace(m_namedItemCache);
     visitor->trace(m_collectionItemsCache);
     LiveNodeListBase::trace(visitor);
 }
 
 } // namespace blink