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

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2004-2008, 2013, 2014 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * 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
  * License as published by the Free Software Foundation; either
@@ skipping 106 matching lines @@
         return tagQName().hasPrefix()
             ? Element::nodeName().upper()
             : tagQName().localName().upper();
     }
     return Element::nodeName();
 }
 
 String HTMLElement::nodeName() const
 {
     // localNameUpper may intern and cache an AtomicString.
-    ASSERT(isMainThread());
+    DCHECK(isMainThread());
 
     // FIXME: Would be nice to have an atomicstring lookup based off uppercase
     // chars that does not have to copy the string on a hit in the hash.
     // FIXME: We should have a way to detect XHTML elements and replace the hasPrefix() check with it.
     if (document().isHTMLDocument()) {
         if (!tagQName().hasPrefix())
             return tagQName().localNameUpper();
         return Element::nodeName().upper();
     }
     return Element::nodeName();
@@ skipping 545 matching lines @@
         return TranslateAttributeNo;
 
     return TranslateAttributeInherit;
 }
 
 bool HTMLElement::translate() const
 {
     for (const HTMLElement* element = this; element; element = Traversal<HTMLElement>::firstAncestor(*element)) {
         TranslateAttributeMode mode = element->translateAttributeMode();
         if (mode != TranslateAttributeInherit) {
-            ASSERT(mode == TranslateAttributeYes || mode == TranslateAttributeNo);
+            DCHECK(mode == TranslateAttributeYes || mode == TranslateAttributeNo);
             return mode == TranslateAttributeYes;
         }
     }
 
     // Default on the root element is translate=yes.
     return true;
 }
 
 void HTMLElement::setTranslate(bool enable)
 {
@@ skipping 122 matching lines @@
     Element* parent = FlatTreeTraversal::parentElement(*this);
     if (parent && parent->isHTMLElement() && toHTMLElement(parent)->selfOrAncestorHasDirAutoAttribute())
         toHTMLElement(parent)->adjustDirectionalityIfNeededAfterChildAttributeChanged(this);
 
     if (equalIgnoringCase(value, "auto"))
         calculateAndAdjustDirectionality();
 }
 
 void HTMLElement::adjustDirectionalityIfNeededAfterChildAttributeChanged(Element* child)
 {
-    ASSERT(selfOrAncestorHasDirAutoAttribute());
+    DCHECK(selfOrAncestorHasDirAutoAttribute());
     TextDirection textDirection = directionality();
     if (layoutObject() && layoutObject()->style() && layoutObject()->style()->direction() != textDirection) {
         Element* elementToAdjust = this;
         for (; elementToAdjust; elementToAdjust = FlatTreeTraversal::parentElement(*elementToAdjust)) {
             if (elementAffectsDirectionality(elementToAdjust)) {
                 elementToAdjust->setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::WritingModeChange));
                 return;
             }
         }
     }
@@ skipping 83 matching lines @@
         return Color::black;
 
     // Pad the buffer out to at least the next multiple of three in size.
     digitBuffer.append('0');
     digitBuffer.append('0');
 
     if (digitBuffer.size() < 6)
         return makeRGB(toASCIIHexValue(digitBuffer[0]), toASCIIHexValue(digitBuffer[1]), toASCIIHexValue(digitBuffer[2]));
 
     // Split the digits into three components, then search the last 8 digits of each component.
-    ASSERT(digitBuffer.size() >= 6);
+    DCHECK_GE(digitBuffer.size(), 6u);
     size_t componentLength = digitBuffer.size() / 3;
     size_t componentSearchWindowLength = min<size_t>(componentLength, 8);
     size_t redIndex = componentLength - componentSearchWindowLength;
     size_t greenIndex = componentLength * 2 - componentSearchWindowLength;
     size_t blueIndex = componentLength * 3 - componentSearchWindowLength;
     // Skip digits until one of them is non-zero, or we've only got two digits left in the component.
     while (digitBuffer[redIndex] == '0' && digitBuffer[greenIndex] == '0' && digitBuffer[blueIndex] == '0' && (componentLength - redIndex) > 2) {
         redIndex++;
         greenIndex++;
         blueIndex++;
     }
-    ASSERT(redIndex + 1 < componentLength);
-    ASSERT(greenIndex >= componentLength);
-    ASSERT(greenIndex + 1 < componentLength * 2);
-    ASSERT(blueIndex >= componentLength * 2);
-    ASSERT_WITH_SECURITY_IMPLICATION(blueIndex + 1 < digitBuffer.size());
+    DCHECK_LT(redIndex + 1, componentLength);
+    DCHECK_GE(greenIndex, componentLength);
+    DCHECK_LT(greenIndex + 1, componentLength * 2);
+    DCHECK_GE(blueIndex, componentLength * 2);
+    SECURITY_DCHECK(blueIndex + 1 < digitBuffer.size());
 
     int redValue = toASCIIHexValue(digitBuffer[redIndex], digitBuffer[redIndex + 1]);
     int greenValue = toASCIIHexValue(digitBuffer[greenIndex], digitBuffer[greenIndex + 1]);
     int blueValue = toASCIIHexValue(digitBuffer[blueIndex], digitBuffer[blueIndex + 1]);
     return makeRGB(redValue, greenValue, blueValue);
 }
 
 // Color parsing that matches HTML's "rules for parsing a legacy color value"
 bool HTMLElement::parseColorWithLegacyRules(const String& attributeValue, Color& parsedColor)
 {
@@ skipping 180 matching lines @@
 #ifndef NDEBUG
 
 // For use in the debugger
 void dumpInnerHTML(blink::HTMLElement*);
 
 void dumpInnerHTML(blink::HTMLElement* element)
 {
     printf("%s\n", element->innerHTML().ascii().data());
 }
 #endif