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

third_party/WebKit/Source/core/html/CollectionIndexCache.h

 /*
  * Copyright (C) 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2014 Samsung Electronics. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 51 matching lines @@
 
     void invalidate();
 
     DEFINE_INLINE_VIRTUAL_TRACE()
     {
         visitor->trace(m_currentNode);
     }
 
 protected:
     ALWAYS_INLINE NodeType* cachedNode() const { return m_currentNode; }
-    ALWAYS_INLINE unsigned cachedNodeIndex() const { ASSERT(cachedNode()); return m_cachedNodeIndex; }
+    ALWAYS_INLINE unsigned cachedNodeIndex() const
+    {
+        DCHECK(cachedNode());
+        return m_cachedNodeIndex;
+    }
     ALWAYS_INLINE void setCachedNode(NodeType* node, unsigned index)
     {
-        ASSERT(node);
+        DCHECK(node);
         m_currentNode = node;
         m_cachedNodeIndex = index;
     }
 
     ALWAYS_INLINE bool isCachedNodeCountValid() const { return m_isLengthCacheValid; }
     ALWAYS_INLINE unsigned cachedNodeCount() const { return m_cachedNodeCount; }
     ALWAYS_INLINE void setCachedNodeCount(unsigned length)
     {
         m_cachedNodeCount = length;
         m_isLengthCacheValid = true;
@@ skipping 25 matching lines @@
     m_isLengthCacheValid = false;
 }
 
 template <typename Collection, typename NodeType>
 inline unsigned CollectionIndexCache<Collection, NodeType>::nodeCount(const Collection& collection)
 {
     if (isCachedNodeCountValid())
         return cachedNodeCount();
 
     nodeAt(collection, UINT_MAX);
-    ASSERT(isCachedNodeCountValid());
+    DCHECK(isCachedNodeCountValid());
 
     return cachedNodeCount();
 }
 
 template <typename Collection, typename NodeType>
 inline NodeType* CollectionIndexCache<Collection, NodeType>::nodeAt(const Collection& collection, unsigned index)
 {
     if (isCachedNodeCountValid() && index >= cachedNodeCount())
         return nullptr;
 
     if (cachedNode()) {
         if (index > cachedNodeIndex())
             return nodeAfterCachedNode(collection, index);
         if (index < cachedNodeIndex())
             return nodeBeforeCachedNode(collection, index);
         return cachedNode();
     }
 
     // No valid cache yet, let's find the first matching element.
-    ASSERT(!isCachedNodeCountValid());
+    DCHECK(!isCachedNodeCountValid());
     NodeType* firstNode = collection.traverseToFirst();
     if (!firstNode) {
         // The collection is empty.
         setCachedNodeCount(0);
         return nullptr;
     }
     setCachedNode(firstNode, 0);
     return index ? nodeAfterCachedNode(collection, index) : firstNode;
 }
 
 template <typename Collection, typename NodeType>
 inline NodeType* CollectionIndexCache<Collection, NodeType>::nodeBeforeCachedNode(const Collection& collection, unsigned index)
 {
-    ASSERT(cachedNode()); // Cache should be valid.
+    DCHECK(cachedNode()); // Cache should be valid.
     unsigned currentIndex = cachedNodeIndex();
-    ASSERT(currentIndex > index);
+    DCHECK_GT(currentIndex, index);
 
     // Determine if we should traverse from the beginning of the collection instead of the cached node.
     bool firstIsCloser = index < currentIndex - index;
     if (firstIsCloser || !collection.canTraverseBackward()) {
         NodeType* firstNode = collection.traverseToFirst();
-        ASSERT(firstNode);
+        DCHECK(firstNode);
         setCachedNode(firstNode, 0);
         return index ? nodeAfterCachedNode(collection, index) : firstNode;
     }
 
     // Backward traversal from the cached node to the requested index.
-    ASSERT(collection.canTraverseBackward());
+    DCHECK(collection.canTraverseBackward());
     NodeType* currentNode = collection.traverseBackwardToOffset(index, *cachedNode(), currentIndex);
-    ASSERT(currentNode);
+    DCHECK(currentNode);
     setCachedNode(currentNode, currentIndex);
     return currentNode;
 }
 
 template <typename Collection, typename NodeType>
 inline NodeType* CollectionIndexCache<Collection, NodeType>::nodeAfterCachedNode(const Collection& collection, unsigned index)
 {
-    ASSERT(cachedNode()); // Cache should be valid.
+    DCHECK(cachedNode()); // Cache should be valid.
     unsigned currentIndex = cachedNodeIndex();
-    ASSERT(currentIndex < index);
+    DCHECK_LT(currentIndex, index);
 
     // Determine if we should traverse from the end of the collection instead of the cached node.
     bool lastIsCloser = isCachedNodeCountValid() && cachedNodeCount() - index < index - currentIndex;
     if (lastIsCloser && collection.canTraverseBackward()) {
         NodeType* lastItem = collection.traverseToLast();
-        ASSERT(lastItem);
+        DCHECK(lastItem);
         setCachedNode(lastItem, cachedNodeCount() - 1);
         if (index < cachedNodeCount() - 1)
             return nodeBeforeCachedNode(collection, index);
         return lastItem;
     }
 
     // Forward traversal from the cached node to the requested index.
     NodeType* currentNode = collection.traverseForwardToOffset(index, *cachedNode(), currentIndex);
     if (!currentNode) {
         // Did not find the node. On plus side, we now know the length.
         setCachedNodeCount(currentIndex + 1);
         return nullptr;
     }
     setCachedNode(currentNode, currentIndex);
     return currentNode;
 }
 
 } // namespace blink
 
 #endif // CollectionIndexCache_h