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

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

 /*
  * 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)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 Apple Inc. All rights reserved.
  *           (C) 2007 Eric Seidel (eric@webkit.org)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 129 matching lines @@
 
 // We need to retain the scroll customization callbacks until the element
 // they're associated with is destroyed. It would be simplest if the callbacks
 // could be stored in ElementRareData, but we can't afford the space
 // increase. Instead, keep the scroll customization callbacks here. The other
 // option would be to store these callbacks on the FrameHost or document, but
 // that necessitates a bunch more logic for transferring the callbacks between
 // FrameHosts when elements are moved around.
 ScrollCustomizationCallbacks& scrollCustomizationCallbacks()
 {
-    ASSERT(RuntimeEnabledFeatures::scrollCustomizationEnabled());
+    DCHECK(RuntimeEnabledFeatures::scrollCustomizationEnabled());
     DEFINE_STATIC_LOCAL(ScrollCustomizationCallbacks, scrollCustomizationCallbacks, (new ScrollCustomizationCallbacks));
     return scrollCustomizationCallbacks;
 }
 
 } // namespace
 
 using namespace HTMLNames;
 using namespace XMLNames;
 
 enum class ClassStringContent { Empty, WhiteSpaceOnly, HasClasses };
 
 RawPtr<Element> Element::create(const QualifiedName& tagName, Document* document)
 {
     return new Element(tagName, document, CreateElement);
 }
 
 Element::Element(const QualifiedName& tagName, Document* document, ConstructionType type)
     : ContainerNode(document, type)
     , m_tagName(tagName)
 {
 }
 
 Element::~Element()
 {
-    ASSERT(needsAttach());
+    DCHECK(needsAttach());
 
 #if !ENABLE(OILPAN)
     if (hasRareData()) {
         elementRareData()->clearShadow();
         detachAllAttrNodesFromElement();
     }
 
     if (isCustomElement())
         CustomElement::wasDestroyed(this);
 
     if (RuntimeEnabledFeatures::scrollCustomizationEnabled())
         scrollCustomizationCallbacks().removeCallbacksForElement(this);
 
     // With Oilpan, either the Element has been removed from the Document
     // or the Document is dead as well. If the Element has been removed from
     // the Document the element has already been removed from the pending
     // resources. If the document is also dead, there is no need to remove
     // the element from the pending resources.
     if (hasPendingResources()) {
         document().accessSVGExtensions().removeElementFromPendingResources(this);
-        ASSERT(!hasPendingResources());
+        DCHECK(!hasPendingResources());
     }
 #endif
 }
 
 inline ElementRareData* Element::elementRareData() const
 {
-    ASSERT(hasRareData());
+    DCHECK(hasRareData());
     return static_cast<ElementRareData*>(rareData());
 }
 
 inline ElementRareData& Element::ensureElementRareData()
 {
     return static_cast<ElementRareData&>(ensureRareData());
 }
 
 bool Element::hasElementFlagInternal(ElementFlags mask) const
 {
@@ skipping 34 matching lines @@
 {
     return hasRareData() ? elementRareData()->tabIndex() : 0;
 }
 
 bool Element::layoutObjectIsFocusable() const
 {
     // Elements in canvas fallback content are not rendered, but they are allowed to be
     // focusable as long as their canvas is displayed and visible.
     if (isInCanvasSubtree()) {
         const HTMLCanvasElement* canvas = Traversal<HTMLCanvasElement>::firstAncestorOrSelf(*this);
-        ASSERT(canvas);
+        DCHECK(canvas);
         return canvas->layoutObject() && canvas->layoutObject()->style()->visibility() == VISIBLE;
     }
 
     // FIXME: Even if we are not visible, we might have a child that is visible.
     // Hyatt wants to fix that some day with a "has visible content" flag or the like.
     return layoutObject() && layoutObject()->style()->visibility() == VISIBLE;
 }
 
 RawPtr<Node> Element::cloneNode(bool deep)
 {
     return deep ? cloneElementWithChildren() : cloneElementWithoutChildren();
 }
 
 RawPtr<Element> Element::cloneElementWithChildren()
 {
     RawPtr<Element> clone = cloneElementWithoutChildren();
     cloneChildNodes(clone.get());
     return clone.release();
 }
 
 RawPtr<Element> Element::cloneElementWithoutChildren()
 {
     RawPtr<Element> clone = cloneElementWithoutAttributesAndChildren();
     // This will catch HTML elements in the wrong namespace that are not correctly copied.
     // This is a sanity check as HTML overloads some of the DOM methods.
-    ASSERT(isHTMLElement() == clone->isHTMLElement());
+    DCHECK_EQ(isHTMLElement(), clone->isHTMLElement());
 
     clone->cloneDataFromElement(*this);
     return clone.release();
 }
 
 RawPtr<Element> Element::cloneElementWithoutAttributesAndChildren()
 {
     return document().createElement(tagQName(), false);
 }
 
 RawPtr<Attr> Element::detachAttribute(size_t index)
 {
-    ASSERT(elementData());
+    DCHECK(elementData());
     const Attribute& attribute = elementData()->attributes().at(index);
     RawPtr<Attr> attrNode = attrIfExists(attribute.name());
     if (attrNode) {
         detachAttrNodeAtIndex(attrNode.get(), index);
     } else {
         attrNode = Attr::create(document(), attribute.name(), attribute.value());
         removeAttributeInternal(index, NotInSynchronizationOfLazyAttribute);
     }
     return attrNode.release();
 }
 
 void Element::detachAttrNodeAtIndex(Attr* attr, size_t index)
 {
-    ASSERT(attr);
-    ASSERT(elementData());
+    DCHECK(attr);
+    DCHECK(elementData());
 
     const Attribute& attribute = elementData()->attributes().at(index);
-    ASSERT(attribute.name() == attr->getQualifiedName());
+    DCHECK(attribute.name() == attr->getQualifiedName());
     detachAttrNodeFromElementWithValue(attr, attribute.value());
     removeAttributeInternal(index, NotInSynchronizationOfLazyAttribute);
 }
 
 void Element::removeAttribute(const QualifiedName& name)
 {
     if (!elementData())
         return;
 
     size_t index = elementData()->attributes().findIndex(name);
@@ skipping 56 matching lines @@
 }
 
 void Element::synchronizeAllAttributes() const
 {
     if (!elementData())
         return;
     // NOTE: anyAttributeMatches in SelectorChecker.cpp
     // currently assumes that all lazy attributes have a null namespace.
     // If that ever changes we'll need to fix that code.
     if (elementData()->m_styleAttributeIsDirty) {
-        ASSERT(isStyledElement());
+        DCHECK(isStyledElement());
         synchronizeStyleAttributeInternal();
     }
     if (elementData()->m_animatedSVGAttributesAreDirty) {
-        ASSERT(isSVGElement());
+        DCHECK(isSVGElement());
         toSVGElement(this)->synchronizeAnimatedSVGAttribute(anyQName());
     }
 }
 
 inline void Element::synchronizeAttribute(const QualifiedName& name) const
 {
     if (!elementData())
         return;
     if (UNLIKELY(name == styleAttr && elementData()->m_styleAttributeIsDirty)) {
-        ASSERT(isStyledElement());
+        DCHECK(isStyledElement());
         synchronizeStyleAttributeInternal();
         return;
     }
     if (UNLIKELY(elementData()->m_animatedSVGAttributesAreDirty)) {
-        ASSERT(isSVGElement());
+        DCHECK(isSVGElement());
         // See comment in the AtomicString version of synchronizeAttribute()
         // also.
         toSVGElement(this)->synchronizeAnimatedSVGAttribute(name);
     }
 }
 
 void Element::synchronizeAttribute(const AtomicString& localName) const
 {
     // This version of synchronizeAttribute() is streamlined for the case where you don't have a full QualifiedName,
     // e.g when called from DOM API.
     if (!elementData())
         return;
     if (elementData()->m_styleAttributeIsDirty && equalPossiblyIgnoringCase(localName, styleAttr.localName(), shouldIgnoreAttributeCase())) {
-        ASSERT(isStyledElement());
+        DCHECK(isStyledElement());
         synchronizeStyleAttributeInternal();
         return;
     }
     if (elementData()->m_animatedSVGAttributesAreDirty) {
         // We're not passing a namespace argument on purpose. SVGNames::*Attr are defined w/o namespaces as well.
 
         // FIXME: this code is called regardless of whether name is an
         // animated SVG Attribute. It would seem we should only call this method
         // if SVGElement::isAnimatableAttribute is true, but the list of
         // animatable attributes in isAnimatableAttribute does not suffice to
@@ skipping 63 matching lines @@
 }
 
 void Element::setApplyScroll(ScrollStateCallback* scrollStateCallback, String nativeScrollBehavior)
 {
     scrollStateCallback->setNativeScrollBehavior(ScrollStateCallback::toNativeScrollBehavior(nativeScrollBehavior));
     scrollCustomizationCallbacks().setApplyScroll(this, scrollStateCallback);
 }
 
 void Element::nativeDistributeScroll(ScrollState& scrollState)
 {
-    ASSERT(RuntimeEnabledFeatures::scrollCustomizationEnabled());
+    DCHECK(RuntimeEnabledFeatures::scrollCustomizationEnabled());
     if (scrollState.fullyConsumed())
         return;
 
     scrollState.distributeToScrollChainDescendant();
 
     // If the scroll doesn't propagate, and we're currently scrolling
     // an element other than this one, prevent the scroll from
     // propagating to this element.
     if (!scrollState.shouldPropagate()
         && scrollState.deltaConsumedForScrollSequence()
@@ skipping 20 matching lines @@
     if (callback->nativeScrollBehavior() != WebNativeScrollBehavior::PerformAfterNativeScroll)
         callback->handleEvent(&scrollState);
     if (callback->nativeScrollBehavior() != WebNativeScrollBehavior::DisableNativeScroll)
         nativeDistributeScroll(scrollState);
     if (callback->nativeScrollBehavior() == WebNativeScrollBehavior::PerformAfterNativeScroll)
         callback->handleEvent(&scrollState);
 };
 
 void Element::nativeApplyScroll(ScrollState& scrollState)
 {
-    ASSERT(RuntimeEnabledFeatures::scrollCustomizationEnabled());
+    DCHECK(RuntimeEnabledFeatures::scrollCustomizationEnabled());
     if (scrollState.fullyConsumed())
         return;
 
     const double deltaX = scrollState.deltaX();
     const double deltaY = scrollState.deltaY();
     bool scrolled = false;
 
     // TODO(esprehn): This should use updateLayoutIgnorePendingStylesheetsForNode.
     if (deltaY || deltaX)
         document().updateLayoutIgnorePendingStylesheets();
@@ skipping 472 matching lines @@
         }
     }
 
     if (quads.isEmpty())
         return ClientRect::create();
 
     FloatRect result = quads[0].boundingBox();
     for (size_t i = 1; i < quads.size(); ++i)
         result.unite(quads[i].boundingBox());
 
-    ASSERT(elementLayoutObject);
+    DCHECK(elementLayoutObject);
     document().adjustFloatRectForScrollAndAbsoluteZoom(result, *elementLayoutObject);
     return ClientRect::create(result);
 }
 
 const AtomicString& Element::computedRole()
 {
     document().updateLayoutIgnorePendingStylesheetsForNode(this);
     OwnPtr<ScopedAXObjectCache> cache = ScopedAXObjectCache::create(document());
     return cache->get()->computedRoleForNode(this);
 }
@@ skipping 144 matching lines @@
 inline void Element::attributeChangedFromParserOrByCloning(const QualifiedName& name, const AtomicString& newValue, AttributeModificationReason reason)
 {
     if (name == isAttr)
         CustomElementRegistrationContext::setTypeExtension(this, newValue);
     attributeChanged(name, nullAtom, newValue, reason);
 }
 
 template <typename CharacterType>
 static inline ClassStringContent classStringHasClassName(const CharacterType* characters, unsigned length)
 {
-    ASSERT(length > 0);
+    DCHECK_GT(length, 0u);
 
     unsigned i = 0;
     do {
         if (isNotHTMLSpace<CharacterType>(characters[i]))
             break;
         ++i;
     } while (i < length);
 
     if (i == length && length == 1)
         return ClassStringContent::Empty;
@@ skipping 10 matching lines @@
     if (!length)
         return ClassStringContent::Empty;
 
     if (newClassString.is8Bit())
         return classStringHasClassName(newClassString.characters8(), length);
     return classStringHasClassName(newClassString.characters16(), length);
 }
 
 void Element::classAttributeChanged(const AtomicString& newClassString)
 {
-    ASSERT(elementData());
+    DCHECK(elementData());
     ClassStringContent classStringContentType = classStringHasClassName(newClassString);
     const bool shouldFoldCase = document().inQuirksMode();
     if (classStringContentType == ClassStringContent::HasClasses) {
         const SpaceSplitString oldClasses = elementData()->classNames();
         elementData()->setClass(newClassString, shouldFoldCase);
         const SpaceSplitString& newClasses = elementData()->classNames();
         document().styleEngine().classChangedForElement(oldClasses, newClasses, *this);
     } else {
         const SpaceSplitString& oldClasses = elementData()->classNames();
         document().styleEngine().classChangedForElement(oldClasses, *this);
         if (classStringContentType == ClassStringContent::WhiteSpaceOnly)
             elementData()->setClass(newClassString, shouldFoldCase);
         else
             elementData()->clearClass();
     }
 
     if (hasRareData())
         elementRareData()->clearClassListValueForQuirksMode();
 }
 
 bool Element::shouldInvalidateDistributionWhenAttributeChanged(ElementShadow* elementShadow, const QualifiedName& name, const AtomicString& newValue)
 {
-    ASSERT(elementShadow);
+    DCHECK(elementShadow);
     const SelectRuleFeatureSet& featureSet = elementShadow->ensureSelectFeatureSet();
 
     if (name == HTMLNames::idAttr) {
         AtomicString oldId = elementData()->idForStyleResolution();
         AtomicString newId = makeIdForStyleResolution(newValue, document().inQuirksMode());
         if (newId != oldId) {
             if (!oldId.isEmpty() && featureSet.hasSelectorForId(oldId))
                 return true;
             if (!newId.isEmpty() && featureSet.hasSelectorForId(newId))
                 return true;
@@ skipping 50 matching lines @@
         if (source != destination)
             attributeVector[destination] = attributeVector[source];
 
         ++destination;
     }
     attributeVector.shrink(destination);
 }
 
 void Element::parserSetAttributes(const Vector<Attribute>& attributeVector)
 {
-    ASSERT(!inShadowIncludingDocument());
-    ASSERT(!parentNode());
-    ASSERT(!m_elementData);
+    DCHECK(!inShadowIncludingDocument());
+    DCHECK(!parentNode());
+    DCHECK(!m_elementData);
 
     if (!attributeVector.isEmpty()) {
         if (document().elementDataCache())
             m_elementData = document().elementDataCache()->cachedShareableElementDataWithAttributes(attributeVector);
         else
             m_elementData = ShareableElementData::createWithAttributes(attributeVector);
     }
 
     parserDidSetAttributes();
 
@@ skipping 54 matching lines @@
 
 Node::InsertionNotificationRequest Element::insertedInto(ContainerNode* insertionPoint)
 {
     // need to do superclass processing first so inShadowIncludingDocument() is true
     // by the time we reach updateId
     ContainerNode::insertedInto(insertionPoint);
 
     if (containsFullScreenElement() && parentElement() && !parentElement()->containsFullScreenElement())
         setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(true);
 
-    ASSERT(!hasRareData() || !elementRareData()->hasPseudoElements());
+    DCHECK(!hasRareData() || !elementRareData()->hasPseudoElements());
 
     if (!insertionPoint->isInTreeScope())
         return InsertionDone;
 
     if (hasRareData()) {
         ElementRareData* rareData = elementRareData();
         rareData->clearClassListValueForQuirksMode();
         if (rareData->intersectionObserverData())
             rareData->intersectionObserverData()->activateValidIntersectionObservers(*this);
     }
@@ skipping 16 matching lines @@
     if (parentElement() && parentElement()->isInCanvasSubtree())
         setIsInCanvasSubtree(true);
 
     return InsertionDone;
 }
 
 void Element::removedFrom(ContainerNode* insertionPoint)
 {
     bool wasInDocument = insertionPoint->inShadowIncludingDocument();
 
-    ASSERT(!hasRareData() || !elementRareData()->hasPseudoElements());
+    DCHECK(!hasRareData() || !elementRareData()->hasPseudoElements());
 
     if (Fullscreen::isActiveFullScreenElement(*this)) {
         setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(false);
         if (insertionPoint->isElementNode()) {
             toElement(insertionPoint)->setContainsFullScreenElement(false);
             toElement(insertionPoint)->setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(false);
         }
     }
 
     if (Fullscreen* fullscreen = Fullscreen::fromIfExists(document()))
@@ skipping 44 matching lines @@
         if (data->intersectionObserverData())
             data->intersectionObserverData()->deactivateAllIntersectionObservers(*this);
     }
 
     if (document().frame())
         document().frame()->eventHandler().elementRemoved(this);
 }
 
 void Element::attach(const AttachContext& context)
 {
-    ASSERT(document().inStyleRecalc());
+    DCHECK(document().inStyleRecalc());
 
     // We've already been through detach when doing an attach, but we might
     // need to clear any state that's been added since then.
     if (hasRareData() && getStyleChangeType() == NeedsReattachStyleChange) {
         ElementRareData* data = elementRareData();
         data->clearComputedStyle();
     }
 
     if (!isSlotOrActiveInsertionPoint())
         LayoutTreeBuilderForElement(*this, context.resolvedStyle).createLayoutObjectIfNeeded();
@@ skipping 68 matching lines @@
             document().activeChainNodeDetached(*this);
         document().userActionElements().didDetach(*this);
     }
 
     if (context.clearInvalidation)
         document().styleEngine().styleInvalidator().clearInvalidation(*this);
 
     if (svgFilterNeedsLayerUpdate())
         document().unscheduleSVGFilterLayerUpdateHack(*this);
 
-    ASSERT(needsAttach());
+    DCHECK(needsAttach());
 }
 
 bool Element::pseudoStyleCacheIsInvalid(const ComputedStyle* currentStyle, ComputedStyle* newStyle)
 {
-    ASSERT(currentStyle == computedStyle());
-    ASSERT(layoutObject());
+    DCHECK_EQ(currentStyle, computedStyle());
+    DCHECK(layoutObject());
 
     if (!currentStyle)
         return false;
 
     const PseudoStyleCache* pseudoStyleCache = currentStyle->cachedPseudoStyles();
     if (!pseudoStyleCache)
         return false;
 
     size_t cacheSize = pseudoStyleCache->size();
     for (size_t i = 0; i < cacheSize; ++i) {
@@ skipping 13 matching lines @@
             if (pseudoId == PseudoIdFirstLine || pseudoId == PseudoIdFirstLineInherited)
                 layoutObject()->firstLineStyleDidChange(*oldPseudoStyle, *newPseudoStyle);
             return true;
         }
     }
     return false;
 }
 
 PassRefPtr<ComputedStyle> Element::styleForLayoutObject()
 {
-    ASSERT(document().inStyleRecalc());
+    DCHECK(document().inStyleRecalc());
 
     RefPtr<ComputedStyle> style;
 
     // FIXME: Instead of clearing updates that may have been added from calls to styleForElement
     // outside recalcStyle, we should just never set them if we're not inside recalcStyle.
     if (ElementAnimations* elementAnimations = this->elementAnimations())
         elementAnimations->cssAnimations().clearPendingUpdate();
 
     if (hasCustomStyleCallbacks())
         style = customStyleForLayoutObject();
     if (!style)
         style = originalStyleForLayoutObject();
-    ASSERT(style);
+    DCHECK(style);
 
     // styleForElement() might add active animations so we need to get it again.
     if (ElementAnimations* elementAnimations = this->elementAnimations()) {
         elementAnimations->cssAnimations().maybeApplyPendingUpdate(this);
         elementAnimations->updateAnimationFlags(*style);
     }
 
     if (style->hasTransform()) {
         if (const StylePropertySet* inlineStyle = this->inlineStyle())
             style->setHasInlineTransform(inlineStyle->hasProperty(CSSPropertyTransform));
     }
 
     return style.release();
 }
 
 PassRefPtr<ComputedStyle> Element::originalStyleForLayoutObject()
 {
-    ASSERT(document().inStyleRecalc());
+    DCHECK(document().inStyleRecalc());
     return document().ensureStyleResolver().styleForElement(this);
 }
 
 void Element::recalcStyle(StyleRecalcChange change, Text* nextTextSibling)
 {
-    ASSERT(document().inStyleRecalc());
-    ASSERT(!document().lifecycle().inDetach());
-    ASSERT(!parentOrShadowHostNode()->needsStyleRecalc());
-    ASSERT(inActiveDocument());
+    DCHECK(document().inStyleRecalc());
+    DCHECK(!document().lifecycle().inDetach());
+    DCHECK(!parentOrShadowHostNode()->needsStyleRecalc());
+    DCHECK(inActiveDocument());
 
     if (hasCustomStyleCallbacks())
         willRecalcStyle(change);
 
     if (change >= Inherit || needsStyleRecalc()) {
         if (hasRareData()) {
             ElementRareData* data = elementRareData();
             data->clearComputedStyle();
 
             if (change >= Inherit) {
@@ skipping 35 matching lines @@
 
     if (hasCustomStyleCallbacks())
         didRecalcStyle(change);
 
     if (change == Reattach)
         reattachWhitespaceSiblingsIfNeeded(nextTextSibling);
 }
 
 StyleRecalcChange Element::recalcOwnStyle(StyleRecalcChange change)
 {
-    ASSERT(document().inStyleRecalc());
-    ASSERT(!parentOrShadowHostNode()->needsStyleRecalc());
-    ASSERT(change >= Inherit || needsStyleRecalc());
-    ASSERT(parentComputedStyle());
+    DCHECK(document().inStyleRecalc());
+    DCHECK(!parentOrShadowHostNode()->needsStyleRecalc());
+    DCHECK(change >= Inherit || needsStyleRecalc());
+    DCHECK(parentComputedStyle());
 
     RefPtr<ComputedStyle> oldStyle = mutableComputedStyle();
     RefPtr<ComputedStyle> newStyle = styleForLayoutObject();
-    ASSERT(newStyle);
+    DCHECK(newStyle);
 
     StyleRecalcChange localChange = ComputedStyle::stylePropagationDiff(oldStyle.get(), newStyle.get());
     if (localChange == NoChange) {
         INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), stylesUnchanged, 1);
     } else {
         INCREMENT_STYLE_STATS_COUNTER(document().styleEngine(), stylesChanged, 1);
     }
 
     if (localChange == Reattach) {
         AttachContext reattachContext;
         reattachContext.resolvedStyle = newStyle.get();
         bool layoutObjectWillChange = needsAttach() || layoutObject();
         reattach(reattachContext);
         if (layoutObjectWillChange || layoutObject())
             return Reattach;
         return ReattachNoLayoutObject;
     }
 
-    ASSERT(oldStyle);
+    DCHECK(oldStyle);
 
     if (localChange != NoChange)
         updateCallbackSelectors(oldStyle.get(), newStyle.get());
 
     if (LayoutObject* layoutObject = this->layoutObject()) {
         if (localChange != NoChange || pseudoStyleCacheIsInvalid(oldStyle.get(), newStyle.get()) || svgFilterNeedsLayerUpdate()) {
             layoutObject->setStyle(newStyle.get());
         } else {
             // Although no change occurred, we use the new style so that the cousin style sharing code won't get
             // fooled into believing this style is the same.
@@ skipping 103 matching lines @@
     layoutObject->layer()->setNeedsCompositingInputsUpdate();
     // Changes in the return value of requiresAcceleratedCompositing change if
     // the PaintLayer is self-painting.
     layoutObject->layer()->updateSelfPaintingLayer();
 }
 
 void Element::setCustomElementDefinition(RawPtr<CustomElementDefinition> definition)
 {
     if (!hasRareData() && !definition)
         return;
-    ASSERT(!customElementDefinition());
+    DCHECK(!customElementDefinition());
     ensureElementRareData().setCustomElementDefinition(definition);
 }
 
 CustomElementDefinition* Element::customElementDefinition() const
 {
     if (hasRareData())
         return elementRareData()->customElementDefinition();
     return nullptr;
 }
 
@@ skipping 10 matching lines @@
             return nullptr;
         }
     }
     document().styleEngine().setShadowCascadeOrder(ShadowCascadeOrder::ShadowCascadeV0);
 
     return createShadowRootInternal(ShadowRootType::V0, exceptionState);
 }
 
 RawPtr<ShadowRoot> Element::attachShadow(const ScriptState* scriptState, const ShadowRootInit& shadowRootInitDict, ExceptionState& exceptionState)
 {
-    ASSERT(RuntimeEnabledFeatures::shadowDOMV1Enabled());
+    DCHECK(RuntimeEnabledFeatures::shadowDOMV1Enabled());
 
     OriginsUsingFeatures::countMainWorldOnly(scriptState, document(), OriginsUsingFeatures::Feature::ElementAttachShadow);
 
     const AtomicString& tagName = localName();
     bool tagNameIsSupported = isCustomElement()
         || tagName == HTMLNames::articleTag
         || tagName == HTMLNames::asideTag
         || tagName == HTMLNames::blockquoteTag
         || tagName == HTMLNames::bodyTag
         || tagName == HTMLNames::divTag
@@ skipping 33 matching lines @@
     RawPtr<ShadowRoot> shadowRoot = createShadowRootInternal(type, exceptionState);
 
     if (shadowRootInitDict.hasDelegatesFocus())
         shadowRoot->setDelegatesFocus(shadowRootInitDict.delegatesFocus());
 
     return shadowRoot.release();
 }
 
 RawPtr<ShadowRoot> Element::createShadowRootInternal(ShadowRootType type, ExceptionState& exceptionState)
 {
-    ASSERT(!closedShadowRoot());
+    DCHECK(!closedShadowRoot());
 
     if (alwaysCreateUserAgentShadowRoot())
         ensureUserAgentShadowRoot();
 
     // Some elements make assumptions about what kind of layoutObjects they allow
     // as children so we can't allow author shadows on them for now.
     if (!areAuthorShadowsAllowed()) {
         exceptionState.throwDOMException(HierarchyRequestError, "Author-created shadow roots are disabled for this element.");
         return nullptr;
     }
@@ skipping 30 matching lines @@
     ShadowRoot* root = shadowRoot();
     if (!root)
         return nullptr;
     return root->type() != ShadowRootType::UserAgent ? root : nullptr;
 }
 
 ShadowRoot* Element::userAgentShadowRoot() const
 {
     if (ElementShadow* elementShadow = shadow()) {
         if (ShadowRoot* root = elementShadow->oldestShadowRoot()) {
-            ASSERT(root->type() == ShadowRootType::UserAgent);
+            DCHECK(root->type() == ShadowRootType::UserAgent);
             return root;
         }
     }
 
     return nullptr;
 }
 
 ShadowRoot& Element::ensureUserAgentShadowRoot()
 {
     if (ShadowRoot* shadowRoot = userAgentShadowRoot())
@@ skipping 85 matching lines @@
     return hasRareData() ? elementRareData()->attrNodeList() : nullptr;
 }
 
 AttrNodeList& Element::ensureAttrNodeList()
 {
     return ensureElementRareData().ensureAttrNodeList();
 }
 
 void Element::removeAttrNodeList()
 {
-    ASSERT(attrNodeList());
+    DCHECK(attrNodeList());
     if (hasRareData())
         elementRareData()->removeAttrNodeList();
 }
 
 RawPtr<Attr> Element::setAttributeNode(Attr* attrNode, ExceptionState& exceptionState)
 {
     RawPtr<Attr> oldAttrNode = attrIfExists(attrNode->getQualifiedName());
     if (oldAttrNode.get() == attrNode)
         return attrNode; // This Attr is already attached to the element.
 
@@ skipping 48 matching lines @@
     return setAttributeNode(attr, exceptionState);
 }
 
 RawPtr<Attr> Element::removeAttributeNode(Attr* attr, ExceptionState& exceptionState)
 {
     if (attr->ownerElement() != this) {
         exceptionState.throwDOMException(NotFoundError, "The node provided is owned by another element.");
         return nullptr;
     }
 
-    ASSERT(document() == attr->document());
+    DCHECK_EQ(document(), attr->document());
 
     synchronizeAttribute(attr->getQualifiedName());
 
     size_t index = elementData()->attributes().findIndex(attr->getQualifiedName());
     if (index == kNotFound) {
         exceptionState.throwDOMException(NotFoundError, "The attribute was not found on this element.");
         return nullptr;
     }
 
     RawPtr<Attr> guard(attr);
@@ skipping 19 matching lines @@
     } else if (name == XMLNames::langAttr) {
         pseudoStateChanged(CSSSelector::PseudoLang);
     }
 }
 
 bool Element::parseAttributeName(QualifiedName& out, const AtomicString& namespaceURI, const AtomicString& qualifiedName, ExceptionState& exceptionState)
 {
     AtomicString prefix, localName;
     if (!Document::parseQualifiedName(qualifiedName, prefix, localName, exceptionState))
         return false;
-    ASSERT(!exceptionState.hadException());
+    DCHECK(!exceptionState.hadException());
 
     QualifiedName qName(prefix, localName, namespaceURI);
 
     if (!Document::hasValidNamespaceForAttributes(qName)) {
         exceptionState.throwDOMException(NamespaceError, "'" + namespaceURI + "' is an invalid namespace for attributes.");
         return false;
     }
 
     out = qName;
     return true;
@@ skipping 208 matching lines @@
     return (hasEventListeners(EventTypeNames::focus)
         || hasEventListeners(EventTypeNames::blur)
         || hasEventListeners(EventTypeNames::focusin)
         || hasEventListeners(EventTypeNames::focusout));
 }
 
 bool Element::isFocusable() const
 {
     // Style cannot be cleared out for non-active documents, so in that case the
     // needsLayoutTreeUpdateForNode check is invalid.
-    ASSERT(!document().isActive() || !document().needsLayoutTreeUpdateForNode(*this));
+    DCHECK(!document().isActive() || !document().needsLayoutTreeUpdateForNode(*this));
     return inShadowIncludingDocument() && supportsFocus() && !isInert() && layoutObjectIsFocusable();
 }
 
 bool Element::isKeyboardFocusable() const
 {
     return isFocusable() && tabIndex() >= 0;
 }
 
 bool Element::isMouseFocusable() const
 {
@@ skipping 10 matching lines @@
     dispatchEvent(FocusEvent::create(EventTypeNames::focus, false, false, document().domWindow(), 0, oldFocusedElement, sourceCapabilities));
 }
 
 void Element::dispatchBlurEvent(Element* newFocusedElement, WebFocusType type, InputDeviceCapabilities* sourceCapabilities)
 {
     dispatchEvent(FocusEvent::create(EventTypeNames::blur, false, false, document().domWindow(), 0, newFocusedElement, sourceCapabilities));
 }
 
 void Element::dispatchFocusInEvent(const AtomicString& eventType, Element* oldFocusedElement, WebFocusType, InputDeviceCapabilities* sourceCapabilities)
 {
-    ASSERT(!EventDispatchForbiddenScope::isEventDispatchForbidden());
-    ASSERT(eventType == EventTypeNames::focusin || eventType == EventTypeNames::DOMFocusIn);
+#if DCHECK_IS_ON()
+    DCHECK(!EventDispatchForbiddenScope::isEventDispatchForbidden());
+#endif
+    DCHECK(eventType == EventTypeNames::focusin || eventType == EventTypeNames::DOMFocusIn);
     dispatchScopedEvent(FocusEvent::create(eventType, true, false, document().domWindow(), 0, oldFocusedElement, sourceCapabilities));
 }
 
 void Element::dispatchFocusOutEvent(const AtomicString& eventType, Element* newFocusedElement, InputDeviceCapabilities* sourceCapabilities)
 {
-    ASSERT(!EventDispatchForbiddenScope::isEventDispatchForbidden());
-    ASSERT(eventType == EventTypeNames::focusout || eventType == EventTypeNames::DOMFocusOut);
+#if DCHECK_IS_ON()
+    DCHECK(!EventDispatchForbiddenScope::isEventDispatchForbidden());
+#endif
+    DCHECK(eventType == EventTypeNames::focusout || eventType == EventTypeNames::DOMFocusOut);
     dispatchScopedEvent(FocusEvent::create(eventType, true, false, document().domWindow(), 0, newFocusedElement, sourceCapabilities));
 }
 
 String Element::innerHTML() const
 {
     return createMarkup(this, ChildrenOnly);
 }
 
 String Element::outerHTML() const
 {
@@ skipping 206 matching lines @@
     }
 
     StringBuilder content;
     content.reserveCapacity(totalLength);
     for (Node* child = firstTextNode; child; child = child->nextSibling()) {
         if (!child->isTextNode())
             continue;
         content.append(toText(child)->data());
     }
 
-    ASSERT(content.length() == totalLength);
+    DCHECK_EQ(content.length(), totalLength);
     return content.toString();
 }
 
 const AtomicString& Element::shadowPseudoId() const
 {
     if (ShadowRoot* root = containingShadowRoot()) {
         if (root->type() == ShadowRootType::UserAgent)
             return fastGetAttribute(pseudoAttr);
     }
     return nullAtom;
 }
 
 void Element::setShadowPseudoId(const AtomicString& id)
 {
-    ASSERT(CSSSelector::parsePseudoType(id, false) == CSSSelector::PseudoWebKitCustomElement);
+    DCHECK_EQ(CSSSelector::parsePseudoType(id, false), CSSSelector::PseudoWebKitCustomElement);
     setAttribute(pseudoAttr, id);
 }
 
 bool Element::isInDescendantTreeOf(const Element* shadowHost) const
 {
-    ASSERT(shadowHost);
-    ASSERT(isShadowHost(shadowHost));
+    DCHECK(shadowHost);
+    DCHECK(isShadowHost(shadowHost));
 
     const ShadowRoot* shadowRoot = containingShadowRoot();
     while (shadowRoot) {
         const Element* ancestorShadowHost = shadowRoot->shadowHost();
         if (ancestorShadowHost == shadowHost)
             return true;
         shadowRoot = ancestorShadowHost->containingShadowRoot();
     }
     return false;
 }
@@ skipping 32 matching lines @@
         elementStyle = rareData.ensureComputedStyle();
     }
 
     if (!pseudoElementSpecifier)
         return elementStyle;
 
     if (ComputedStyle* pseudoElementStyle = elementStyle->getCachedPseudoStyle(pseudoElementSpecifier))
         return pseudoElementStyle;
 
     RefPtr<ComputedStyle> result = document().ensureStyleResolver().pseudoStyleForElement(this, PseudoStyleRequest(pseudoElementSpecifier, PseudoStyleRequest::ForComputedStyle), elementStyle);
-    ASSERT(result);
+    DCHECK(result);
     return elementStyle->addCachedPseudoStyle(result.release());
 }
 
 AtomicString Element::computeInheritedLanguage() const
 {
     const Node* n = this;
     AtomicString value;
     // The language property is inherited, so we iterate over the parents to find the first language.
     do {
         if (n->isElementNode()) {
@@ skipping 22 matching lines @@
 }
 
 void Element::cancelFocusAppearanceUpdate()
 {
     if (document().focusedElement() == this)
         document().cancelFocusAppearanceUpdate();
 }
 
 void Element::updatePseudoElement(PseudoId pseudoId, StyleRecalcChange change)
 {
-    ASSERT(!needsStyleRecalc());
+    DCHECK(!needsStyleRecalc());
     PseudoElement* element = pseudoElement(pseudoId);
 
     if (element && (change == UpdatePseudoElements || element->shouldCallRecalcStyle(change))) {
         if (pseudoId == PseudoIdFirstLetter && updateFirstLetter(element))
             return;
 
         // Need to clear the cached style if the PseudoElement wants a recalc so it
         // computes a new style.
         if (element->needsStyleRecalc())
             layoutObject()->mutableStyle()->removeCachedPseudoStyle(pseudoId);
@@ skipping 110 matching lines @@
     // <link> implement URLUtils?
     if (isHTMLAnchorElement(*this) || isHTMLAreaElement(*this) || isHTMLLinkElement(*this))
         return getURLAttribute(hrefAttr);
     if (isSVGAElement(*this))
         return toSVGAElement(*this).legacyHrefURL(document());
     return KURL();
 }
 
 KURL Element::getURLAttribute(const QualifiedName& name) const
 {
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
     if (elementData()) {
         if (const Attribute* attribute = attributes().find(name))
-            ASSERT(isURLAttribute(*attribute));
+            DCHECK(isURLAttribute(*attribute));
     }
 #endif
     return document().completeURL(stripLeadingAndTrailingHTMLSpaces(getAttribute(name)));
 }
 
 KURL Element::getNonEmptyURLAttribute(const QualifiedName& name) const
 {
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
     if (elementData()) {
         if (const Attribute* attribute = attributes().find(name))
-            ASSERT(isURLAttribute(*attribute));
+            DCHECK(isURLAttribute(*attribute));
     }
 #endif
     String value = stripLeadingAndTrailingHTMLSpaces(getAttribute(name));
     if (value.isEmpty())
         return KURL();
     return document().completeURL(value);
 }
 
 int Element::getIntegralAttribute(const QualifiedName& attributeName) const
 {
@@ skipping 27 matching lines @@
 
 void Element::setContainsFullScreenElement(bool flag)
 {
     setElementFlag(ContainsFullScreenElement, flag);
     document().styleEngine().ensureFullscreenUAStyle();
     pseudoStateChanged(CSSSelector::PseudoFullScreenAncestor);
 }
 
 static Element* parentCrossingFrameBoundaries(Element* element)
 {
-    ASSERT(element);
+    DCHECK(element);
     return element->parentElement() ? element->parentElement() : element->document().ownerElement();
 }
 
 void Element::setContainsFullScreenElementOnAncestorsCrossingFrameBoundaries(bool flag)
 {
     for (Element* element = parentCrossingFrameBoundaries(this); element; element = parentCrossingFrameBoundaries(element))
         element->setContainsFullScreenElement(flag);
 }
 
 void Element::setIsInTopLayer(bool inTopLayer)
@@ skipping 35 matching lines @@
         case SpellcheckAttributeFalse:
             return false;
         case SpellcheckAttributeDefault:
             break;
         }
     }
 
     return true;
 }
 
-#if ENABLE(ASSERT)
+#if DCHECK_IS_ON()
 bool Element::fastAttributeLookupAllowed(const QualifiedName& name) const
 {
     if (name == HTMLNames::styleAttr)
         return false;
 
     if (isSVGElement())
         return !toSVGElement(this)->isAnimatableAttribute(name);
 
     return true;
 }
@@ skipping 24 matching lines @@
         return;
 
     if (oldId == newId)
         return;
 
     updateId(treeScope(), oldId, newId);
 }
 
 inline void Element::updateId(TreeScope& scope, const AtomicString& oldId, const AtomicString& newId)
 {
-    ASSERT(isInTreeScope());
-    ASSERT(oldId != newId);
+    DCHECK(isInTreeScope());
+    DCHECK_NE(oldId, newId);
 
     if (!oldId.isEmpty())
         scope.removeElementById(oldId, this);
     if (!newId.isEmpty())
         scope.addElementById(newId, this);
 
     if (shouldRegisterAsExtraNamedItem())
         updateExtraNamedItemRegistration(oldId, newId);
 }
 
@@ skipping 146 matching lines @@
     if (!attrNode) {
         attrNode = Attr::create(*this, name);
         treeScope().adoptIfNeeded(*attrNode);
         ensureAttrNodeList().append(attrNode);
     }
     return attrNode.release();
 }
 
 void Element::detachAttrNodeFromElementWithValue(Attr* attrNode, const AtomicString& value)
 {
-    ASSERT(attrNodeList());
+    DCHECK(attrNodeList());
     attrNode->detachFromElementWithValue(value);
 
     AttrNodeList* list = attrNodeList();
     size_t index = list->find(attrNode);
-    ASSERT(index != kNotFound);
+    DCHECK_NE(index, kNotFound);
     list->remove(index);
     if (list->isEmpty())
         removeAttrNodeList();
 }
 
 void Element::detachAllAttrNodesFromElement()
 {
     AttrNodeList* list = this->attrNodeList();
     if (!list)
         return;
 
     AttributeCollection attributes = elementData()->attributes();
     for (const Attribute& attr : attributes) {
         if (RawPtr<Attr> attrNode = attrIfExists(attr.name()))
             attrNode->detachFromElementWithValue(attr.value());
     }
 
     removeAttrNodeList();
 }
 
 void Element::willRecalcStyle(StyleRecalcChange)
 {
-    ASSERT(hasCustomStyleCallbacks());
+    DCHECK(hasCustomStyleCallbacks());
 }
 
 void Element::didRecalcStyle(StyleRecalcChange)
 {
-    ASSERT(hasCustomStyleCallbacks());
+    DCHECK(hasCustomStyleCallbacks());
 }
 
 
 PassRefPtr<ComputedStyle> Element::customStyleForLayoutObject()
 {
-    ASSERT(hasCustomStyleCallbacks());
+    DCHECK(hasCustomStyleCallbacks());
     return nullptr;
 }
 
 void Element::cloneAttributesFromElement(const Element& other)
 {
     if (hasRareData())
         detachAllAttrNodesFromElement();
 
     other.synchronizeAllAttributes();
     if (!other.m_elementData) {
@@ skipping 40 matching lines @@
 {
     cloneAttributesFromElement(other);
     copyNonAttributePropertiesFromElement(other);
 }
 
 void Element::createUniqueElementData()
 {
     if (!m_elementData) {
         m_elementData = UniqueElementData::create();
     } else {
-        ASSERT(!m_elementData->isUnique());
+        DCHECK(!m_elementData->isUnique());
         m_elementData = toShareableElementData(m_elementData)->makeUniqueCopy();
     }
 }
 
 void Element::synchronizeStyleAttributeInternal() const
 {
-    ASSERT(isStyledElement());
-    ASSERT(elementData());
-    ASSERT(elementData()->m_styleAttributeIsDirty);
+    DCHECK(isStyledElement());
+    DCHECK(elementData());
+    DCHECK(elementData()->m_styleAttributeIsDirty);
     elementData()->m_styleAttributeIsDirty = false;
     const StylePropertySet* inlineStyle = this->inlineStyle();
     const_cast<Element*>(this)->setSynchronizedLazyAttribute(styleAttr,
         inlineStyle ? AtomicString(inlineStyle->asText()) : nullAtom);
 }
 
 CSSStyleDeclaration* Element::style()
 {
     if (!isStyledElement())
         return nullptr;
     return &ensureElementRareData().ensureInlineCSSStyleDeclaration(this);
 }
 
 MutableStylePropertySet& Element::ensureMutableInlineStyle()
 {
-    ASSERT(isStyledElement());
+    DCHECK(isStyledElement());
     Member<StylePropertySet>& inlineStyle = ensureUniqueElementData().m_inlineStyle;
     if (!inlineStyle) {
         CSSParserMode mode = (!isHTMLElement() || document().inQuirksMode()) ? HTMLQuirksMode : HTMLStandardMode;
         inlineStyle = MutableStylePropertySet::create(mode);
     } else if (!inlineStyle->isMutable()) {
         inlineStyle = inlineStyle->mutableCopy();
     }
     return *toMutableStylePropertySet(inlineStyle);
 }
 
 void Element::clearMutableInlineStyleIfEmpty()
 {
     if (ensureMutableInlineStyle().isEmpty()) {
         ensureUniqueElementData().m_inlineStyle.clear();
     }
 }
 
 inline void Element::setInlineStyleFromString(const AtomicString& newStyleString)
 {
-    ASSERT(isStyledElement());
+    DCHECK(isStyledElement());
     Member<StylePropertySet>& inlineStyle = elementData()->m_inlineStyle;
 
     // Avoid redundant work if we're using shared attribute data with already parsed inline style.
     if (inlineStyle && !elementData()->isUnique())
         return;
 
     // We reconstruct the property set instead of mutating if there is no CSSOM wrapper.
     // This makes wrapperless property sets immutable and so cacheable.
     if (inlineStyle && !inlineStyle->isMutable())
         inlineStyle.clear();
 
     if (!inlineStyle) {
         inlineStyle = CSSParser::parseInlineStyleDeclaration(newStyleString, this);
     } else {
-        ASSERT(inlineStyle->isMutable());
+        DCHECK(inlineStyle->isMutable());
         static_cast<MutableStylePropertySet*>(inlineStyle.get())->parseDeclarationList(newStyleString, document().elementSheet().contents());
     }
 }
 
 void Element::styleAttributeChanged(const AtomicString& newStyleString, AttributeModificationReason modificationReason)
 {
-    ASSERT(isStyledElement());
+    DCHECK(isStyledElement());
     WTF::OrdinalNumber startLineNumber = WTF::OrdinalNumber::beforeFirst();
     if (document().scriptableDocumentParser() && !document().isInDocumentWrite())
         startLineNumber = document().scriptableDocumentParser()->lineNumber();
 
     if (newStyleString.isNull()) {
         ensureUniqueElementData().m_inlineStyle.clear();
     } else if (modificationReason == ModifiedByCloning || ContentSecurityPolicy::shouldBypassMainWorld(&document()) || document().contentSecurityPolicy()->allowInlineStyle(document().url(), startLineNumber, newStyleString)) {
         setInlineStyleFromString(newStyleString);
     }
 
     elementData()->m_styleAttributeIsDirty = false;
 
     setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::StyleSheetChange));
     InspectorInstrumentation::didInvalidateStyleAttr(this);
 }
 
 void Element::inlineStyleChanged()
 {
-    ASSERT(isStyledElement());
+    DCHECK(isStyledElement());
     setNeedsStyleRecalc(LocalStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::Inline));
-    ASSERT(elementData());
+    DCHECK(elementData());
     elementData()->m_styleAttributeIsDirty = true;
     InspectorInstrumentation::didInvalidateStyleAttr(this);
 }
 
 bool Element::setInlineStyleProperty(CSSPropertyID propertyID, CSSValueID identifier, bool important)
 {
-    ASSERT(isStyledElement());
+    DCHECK(isStyledElement());
     ensureMutableInlineStyle().setProperty(propertyID, cssValuePool().createIdentifierValue(identifier), important);
     inlineStyleChanged();
     return true;
 }
 
 bool Element::setInlineStyleProperty(CSSPropertyID propertyID, double value, CSSPrimitiveValue::UnitType unit, bool important)
 {
-    ASSERT(isStyledElement());
+    DCHECK(isStyledElement());
     ensureMutableInlineStyle().setProperty(propertyID, cssValuePool().createValue(value, unit), important);
     inlineStyleChanged();
     return true;
 }
 
 bool Element::setInlineStyleProperty(CSSPropertyID propertyID, const String& value, bool important)
 {
-    ASSERT(isStyledElement());
+    DCHECK(isStyledElement());
     bool changes = ensureMutableInlineStyle().setProperty(propertyID, value, important, document().elementSheet().contents());
     if (changes)
         inlineStyleChanged();
     return changes;
 }
 
 bool Element::removeInlineStyleProperty(CSSPropertyID propertyID)
 {
-    ASSERT(isStyledElement());
+    DCHECK(isStyledElement());
     if (!inlineStyle())
         return false;
     bool changes = ensureMutableInlineStyle().removeProperty(propertyID);
     if (changes)
         inlineStyleChanged();
     return changes;
 }
 
 void Element::removeAllInlineStyleProperties()
 {
-    ASSERT(isStyledElement());
+    DCHECK(isStyledElement());
     if (!inlineStyle())
         return;
     ensureMutableInlineStyle().clear();
     inlineStyleChanged();
 }
 
 void Element::updatePresentationAttributeStyle()
 {
     synchronizeAllAttributes();
     // ShareableElementData doesn't store presentation attribute style, so make sure we have a UniqueElementData.
     UniqueElementData& elementData = ensureUniqueElementData();
     elementData.m_presentationAttributeStyleIsDirty = false;
     elementData.m_presentationAttributeStyle = computePresentationAttributeStyle(*this);
 }
 
 void Element::addPropertyToPresentationAttributeStyle(MutableStylePropertySet* style, CSSPropertyID propertyID, CSSValueID identifier)
 {
-    ASSERT(isStyledElement());
+    DCHECK(isStyledElement());
     style->setProperty(propertyID, cssValuePool().createIdentifierValue(identifier));
 }
 
 void Element::addPropertyToPresentationAttributeStyle(MutableStylePropertySet* style, CSSPropertyID propertyID, double value, CSSPrimitiveValue::UnitType unit)
 {
-    ASSERT(isStyledElement());
+    DCHECK(isStyledElement());
     style->setProperty(propertyID, cssValuePool().createValue(value, unit));
 }
 
 void Element::addPropertyToPresentationAttributeStyle(MutableStylePropertySet* style, CSSPropertyID propertyID, const String& value)
 {
-    ASSERT(isStyledElement());
+    DCHECK(isStyledElement());
     style->setProperty(propertyID, value, false);
 }
 
 void Element::addPropertyToPresentationAttributeStyle(MutableStylePropertySet*  style, CSSPropertyID propertyID, RawPtr<CSSValue> value)
 {
-    ASSERT(isStyledElement());
+    DCHECK(isStyledElement());
     style->setProperty(propertyID, value);
 }
 
 bool Element::supportsStyleSharing() const
 {
     if (!isStyledElement() || !parentOrShadowHostElement())
         return false;
     // If the element has inline style it is probably unique.
     if (inlineStyle())
         return false;
@@ skipping 83 matching lines @@
 
 DEFINE_TRACE(Element)
 {
     if (hasRareData())
         visitor->trace(elementRareData());
     visitor->trace(m_elementData);
     ContainerNode::trace(visitor);
 }
 
 } // namespace blink