ASSERT -> {DCHECK|DCHECK_XX}, ENABLE(ASSERT) -> DCHECK_IS_ON() in dom

third_party/WebKit/Source/core/dom/Element.h

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Peter Kelly (pmk@post.com)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003-2011, 2013, 2014 Apple Inc. 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 130 matching lines @@
     int getIntegralAttribute(const QualifiedName& attributeName) const;
     void setIntegralAttribute(const QualifiedName& attributeName, int value);
     void setUnsignedIntegralAttribute(const QualifiedName& attributeName, unsigned value);
     double getFloatingPointAttribute(const QualifiedName& attributeName, double fallbackValue = std::numeric_limits<double>::quiet_NaN()) const;
     void setFloatingPointAttribute(const QualifiedName& attributeName, double value);
 
     // Call this to get the value of an attribute that is known not to be the style
     // attribute or one of the SVG animatable attributes.
     bool fastHasAttribute(const QualifiedName&) const;
     const AtomicString& fastGetAttribute(const QualifiedName&) const;
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
     bool fastAttributeLookupAllowed(const QualifiedName&) const;
 #endif
 
 #ifdef DUMP_NODE_STATISTICS
     bool hasNamedNodeMap() const;
 #endif
     bool hasAttributes() const;
 
     bool hasAttribute(const AtomicString& name) const;
     bool hasAttributeNS(const AtomicString& namespaceURI, const AtomicString& localName) const;
@@ skipping 588 matching lines @@
 }
 
 inline Element* Node::parentElement() const
 {
     ContainerNode* parent = parentNode();
     return parent && parent->isElementNode() ? toElement(parent) : nullptr;
 }
 
 inline bool Element::fastHasAttribute(const QualifiedName& name) const
 {
-    ASSERT(fastAttributeLookupAllowed(name));
+#if DCHECK_IS_ON()
+    DCHECK(fastAttributeLookupAllowed(name));
+#endif
     return elementData() && elementData()->attributes().findIndex(name) != kNotFound;
 }
 
 inline const AtomicString& Element::fastGetAttribute(const QualifiedName& name) const
 {
-    ASSERT(fastAttributeLookupAllowed(name));
+#if DCHECK_IS_ON()
+    DCHECK(fastAttributeLookupAllowed(name));
+#endif
     if (elementData()) {
         if (const Attribute* attribute = elementData()->attributes().find(name))
             return attribute->value();
     }
     return nullAtom;
 }
 
 inline AttributeCollection Element::attributes() const
 {
     if (!elementData())
         return AttributeCollection();
     synchronizeAllAttributes();
     return elementData()->attributes();
 }
 
 inline AttributeCollection Element::attributesWithoutUpdate() const
 {
     if (!elementData())
         return AttributeCollection();
     return elementData()->attributes();
 }
 
 inline bool Element::hasAttributes() const
 {
     return !attributes().isEmpty();
 }
 
 inline const AtomicString& Element::idForStyleResolution() const
 {
-    ASSERT(hasID());
+    DCHECK(hasID());
     return elementData()->idForStyleResolution();
 }
 
 inline const AtomicString& Element::getIdAttribute() const
 {
     return hasID() ? fastGetAttribute(HTMLNames::idAttr) : nullAtom;
 }
 
 inline const AtomicString& Element::getNameAttribute() const
 {
     return hasName() ? fastGetAttribute(HTMLNames::nameAttr) : nullAtom;
 }
 
 inline const AtomicString& Element::getClassAttribute() const
 {
     if (!hasClass())
         return nullAtom;
     if (isSVGElement())
         return getAttribute(HTMLNames::classAttr);
     return fastGetAttribute(HTMLNames::classAttr);
 }
 
 inline void Element::setIdAttribute(const AtomicString& value)
 {
     setAttribute(HTMLNames::idAttr, value);
 }
 
 inline const SpaceSplitString& Element::classNames() const
 {
-    ASSERT(hasClass());
-    ASSERT(elementData());
+    DCHECK(hasClass());
+    DCHECK(elementData());
     return elementData()->classNames();
 }
 
 inline bool Element::hasID() const
 {
     return elementData() && elementData()->hasID();
 }
 
 inline bool Element::hasClass() const
 {
     return elementData() && elementData()->hasClass();
 }
 
 inline UniqueElementData& Element::ensureUniqueElementData()
 {
     if (!elementData() || !elementData()->isUnique())
         createUniqueElementData();
     return toUniqueElementData(*m_elementData);
 }
 
 inline Node::InsertionNotificationRequest Node::insertedInto(ContainerNode* insertionPoint)
 {
-    ASSERT(!childNeedsStyleInvalidation());
-    ASSERT(!needsStyleInvalidation());
-    ASSERT(insertionPoint->inShadowIncludingDocument() || insertionPoint->isInShadowTree() || isContainerNode());
+    DCHECK(!childNeedsStyleInvalidation());
+    DCHECK(!needsStyleInvalidation());
+    DCHECK(insertionPoint->inShadowIncludingDocument() || insertionPoint->isInShadowTree() || isContainerNode());
     if (insertionPoint->inShadowIncludingDocument()) {
         setFlag(InDocumentFlag);
         insertionPoint->document().incrementNodeCount();
     }
     if (parentOrShadowHostNode()->isInShadowTree())
         setFlag(IsInShadowTreeFlag);
     if (childNeedsDistributionRecalc() && !insertionPoint->childNeedsDistributionRecalc())
         insertionPoint->markAncestorsWithChildNeedsDistributionRecalc();
     return InsertionDone;
 }
 
 inline void Node::removedFrom(ContainerNode* insertionPoint)
 {
-    ASSERT(insertionPoint->inShadowIncludingDocument() || isContainerNode() || isInShadowTree());
+    DCHECK(insertionPoint->inShadowIncludingDocument() || isContainerNode() || isInShadowTree());
     if (insertionPoint->inShadowIncludingDocument()) {
         clearFlag(InDocumentFlag);
         insertionPoint->document().decrementNodeCount();
     }
     if (isInShadowTree() && !treeScope().rootNode().isShadowRoot())
         clearFlag(IsInShadowTreeFlag);
     if (AXObjectCache* cache = document().existingAXObjectCache())
         cache->remove(this);
 }
 
 inline void Element::invalidateStyleAttribute()
 {
-    ASSERT(elementData());
+    DCHECK(elementData());
     elementData()->m_styleAttributeIsDirty = true;
 }
 
 inline const StylePropertySet* Element::presentationAttributeStyle()
 {
     if (!elementData())
         return nullptr;
     if (elementData()->m_presentationAttributeStyleIsDirty)
         updatePresentationAttributeStyle();
     // Need to call elementData() again since updatePresentationAttributeStyle()
     // might swap it with a UniqueElementData.
     return elementData()->presentationAttributeStyle();
 }
 
 inline void Element::setTagNameForCreateElementNS(const QualifiedName& tagName)
 {
     // We expect this method to be called only to reset the prefix.
-    ASSERT(tagName.localName() == m_tagName.localName());
-    ASSERT(tagName.namespaceURI() == m_tagName.namespaceURI());
+    DCHECK_EQ(tagName.localName(), m_tagName.localName());
+    DCHECK_EQ(tagName.namespaceURI(), m_tagName.namespaceURI());
     m_tagName = tagName;
 }
 
 inline AtomicString Element::localNameForSelectorMatching() const
 {
     if (isHTMLElement() || !document().isHTMLDocument())
         return localName();
     return localName().lower();
 }
 
@@ skipping 39 matching lines @@
     static RawPtr<T> create(const QualifiedName&, Document&)
 #define DEFINE_ELEMENT_FACTORY_WITH_TAGNAME(T) \
     RawPtr<T> T::create(const QualifiedName& tagName, Document& document) \
     { \
         return new T(tagName, document); \
     }
 
 } // namespace blink
 
 #endif // Element_h