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

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) 2008, 2009, 2011, 2012 Google Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) Research In Motion Limited 2010-2011. All rights reserved.
@@ skipping 144 matching lines @@
 }
 
 void StyleEngine::addPendingSheet()
 {
     m_pendingStylesheets++;
 }
 
 // This method is called whenever a top-level stylesheet has finished loading.
 void StyleEngine::removePendingSheet(Node* styleSheetCandidateNode)
 {
-    ASSERT(styleSheetCandidateNode);
+    DCHECK(styleSheetCandidateNode);
     TreeScope* treeScope = isStyleElement(*styleSheetCandidateNode) ? &styleSheetCandidateNode->treeScope() : m_document.get();
     if (styleSheetCandidateNode->inShadowIncludingDocument())
         markTreeScopeDirty(*treeScope);
 
     // Make sure we knew this sheet was pending, and that our count isn't out of sync.
-    ASSERT(m_pendingStylesheets > 0);
+    DCHECK_GT(m_pendingStylesheets, 0);
 
     m_pendingStylesheets--;
     if (m_pendingStylesheets)
         return;
 
     document().didRemoveAllPendingStylesheet();
 }
 
 void StyleEngine::setNeedsActiveStyleUpdate(StyleSheet* sheet, StyleResolverUpdateMode updateMode)
 {
     // resolverChanged() is called for inactive non-master documents because
     // import documents are inactive documents. resolverChanged() for imports
     // will call resolverChanged() for the master document and update the active
     // stylesheets including the ones from the import.
     if (!document().isActive() && isMaster())
         return;
 
     if (sheet && document().isActive()) {
         Node* node = sheet->ownerNode();
         if (node && node->inShadowIncludingDocument()) {
             TreeScope& treeScope = isStyleElement(*node) ? node->treeScope() : *m_document;
-            ASSERT(isStyleElement(*node) || node->treeScope() == m_document);
+            DCHECK(isStyleElement(*node) || node->treeScope() == m_document);
             markTreeScopeDirty(treeScope);
         }
     }
 
     resolverChanged(updateMode);
 }
 
 void StyleEngine::addStyleSheetCandidateNode(Node* node)
 {
     if (!node->inShadowIncludingDocument() || document().isDetached())
         return;
 
     TreeScope& treeScope = isStyleElement(*node) ? node->treeScope() : *m_document;
-    ASSERT(isStyleElement(*node) || treeScope == m_document);
-    ASSERT(!isXSLStyleSheet(*node));
+    DCHECK(isStyleElement(*node) || treeScope == m_document);
+    DCHECK(!isXSLStyleSheet(*node));
     TreeScopeStyleSheetCollection* collection = ensureStyleSheetCollectionFor(treeScope);
-    ASSERT(collection);
+    DCHECK(collection);
     collection->addStyleSheetCandidateNode(node);
 
     markTreeScopeDirty(treeScope);
     if (treeScope != m_document)
         m_activeTreeScopes.add(&treeScope);
 }
 
 void StyleEngine::removeStyleSheetCandidateNode(Node* node)
 {
     removeStyleSheetCandidateNode(node, *m_document);
 }
 
 void StyleEngine::removeStyleSheetCandidateNode(Node* node, TreeScope& treeScope)
 {
-    ASSERT(isStyleElement(*node) || treeScope == m_document);
-    ASSERT(!isXSLStyleSheet(*node));
+    DCHECK(isStyleElement(*node) || treeScope == m_document);
+    DCHECK(!isXSLStyleSheet(*node));
 
     TreeScopeStyleSheetCollection* collection = styleSheetCollectionFor(treeScope);
     // After detaching document, collection could be null. In the case,
     // we should not update anything. Instead, just return.
     if (!collection)
         return;
     collection->removeStyleSheetCandidateNode(node);
 
     markTreeScopeDirty(treeScope);
 }
 
 void StyleEngine::modifiedStyleSheetCandidateNode(Node* node)
 {
     if (!node->inShadowIncludingDocument())
         return;
 
     TreeScope& treeScope = isStyleElement(*node) ? node->treeScope() : *m_document;
-    ASSERT(isStyleElement(*node) || treeScope == m_document);
+    DCHECK(isStyleElement(*node) || treeScope == m_document);
     markTreeScopeDirty(treeScope);
     resolverChanged(FullStyleUpdate);
 }
 
 void StyleEngine::watchedSelectorsChanged()
 {
     if (m_resolver) {
         m_resolver->initWatchedSelectorRules();
         m_resolver->resetRuleFeatures();
     }
     document().setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::DeclarativeContent));
 }
 
 bool StyleEngine::shouldUpdateDocumentStyleSheetCollection(StyleResolverUpdateMode updateMode) const
 {
     return m_documentScopeDirty || updateMode == FullStyleUpdate;
 }
 
 bool StyleEngine::shouldUpdateShadowTreeStyleSheetCollection(StyleResolverUpdateMode updateMode) const
 {
     return !m_dirtyTreeScopes.isEmpty() || updateMode == FullStyleUpdate;
 }
 
 void StyleEngine::clearMediaQueryRuleSetOnTreeScopeStyleSheets(UnorderedTreeScopeSet& treeScopes)
 {
     for (TreeScope* treeScope : treeScopes) {
-        ASSERT(treeScope != m_document);
+        DCHECK(treeScope != m_document);
         ShadowTreeStyleSheetCollection* collection = static_cast<ShadowTreeStyleSheetCollection*>(styleSheetCollectionFor(*treeScope));
-        ASSERT(collection);
+        DCHECK(collection);
         collection->clearMediaQueryRuleSetStyleSheets();
     }
 }
 
 void StyleEngine::clearMediaQueryRuleSetStyleSheets()
 {
     resolverChanged(FullStyleUpdate);
     documentStyleSheetCollection()->clearMediaQueryRuleSetStyleSheets();
     clearMediaQueryRuleSetOnTreeScopeStyleSheets(m_activeTreeScopes);
 }
 
 void StyleEngine::updateStyleSheetsInImport(DocumentStyleSheetCollector& parentCollector)
 {
-    ASSERT(!isMaster());
+    DCHECK(!isMaster());
     HeapVector<Member<StyleSheet>> sheetsForList;
     ImportedDocumentStyleSheetCollector subcollector(parentCollector, sheetsForList);
     documentStyleSheetCollection()->collectStyleSheets(*this, subcollector);
     documentStyleSheetCollection()->swapSheetsForSheetList(sheetsForList);
 }
 
 void StyleEngine::updateActiveStyleSheetsInShadow(StyleResolverUpdateMode updateMode, TreeScope* treeScope, UnorderedTreeScopeSet& treeScopesRemoved)
 {
-    ASSERT(treeScope != m_document);
+    DCHECK_NE(treeScope, m_document);
     ShadowTreeStyleSheetCollection* collection = static_cast<ShadowTreeStyleSheetCollection*>(styleSheetCollectionFor(*treeScope));
-    ASSERT(collection);
+    DCHECK(collection);
     collection->updateActiveStyleSheets(*this, updateMode);
     if (!collection->hasStyleSheetCandidateNodes()) {
         treeScopesRemoved.add(treeScope);
         // When removing TreeScope from ActiveTreeScopes,
         // its resolver should be destroyed by invoking resetAuthorStyle.
-        ASSERT(!treeScope->scopedStyleResolver());
+        DCHECK(!treeScope->scopedStyleResolver());
     }
 }
 
 void StyleEngine::updateActiveStyleSheets(StyleResolverUpdateMode updateMode)
 {
-    ASSERT(isMaster());
-    ASSERT(!document().inStyleRecalc());
+    DCHECK(isMaster());
+    DCHECK(!document().inStyleRecalc());
 
     if (!document().isActive())
         return;
 
     TRACE_EVENT0("blink,blink_style", "StyleEngine::updateActiveStyleSheets");
 
     if (shouldUpdateDocumentStyleSheetCollection(updateMode))
         documentStyleSheetCollection()->updateActiveStyleSheets(*this, updateMode);
 
     if (shouldUpdateShadowTreeStyleSheetCollection(updateMode)) {
@@ skipping 50 matching lines @@
         if (TreeScopeStyleSheetCollection* collection = styleSheetCollectionFor(*shadowRoot))
             styleResolver->removePendingAuthorStyleSheets(collection->activeAuthorStyleSheets());
     }
     m_styleSheetCollectionMap.remove(shadowRoot);
     m_activeTreeScopes.remove(shadowRoot);
     m_dirtyTreeScopes.remove(shadowRoot);
 }
 
 void StyleEngine::appendActiveAuthorStyleSheets()
 {
-    ASSERT(isMaster());
+    DCHECK(isMaster());
 
     m_resolver->appendAuthorStyleSheets(documentStyleSheetCollection()->activeAuthorStyleSheets());
     for (TreeScope* treeScope : m_activeTreeScopes) {
         if (TreeScopeStyleSheetCollection* collection = m_styleSheetCollectionMap.get(treeScope))
             m_resolver->appendAuthorStyleSheets(collection->activeAuthorStyleSheets());
     }
     m_resolver->finishAppendAuthorStyleSheets();
 }
 
 void StyleEngine::createResolver()
 {
     TRACE_EVENT1("blink", "StyleEngine::createResolver", "frame", document().frame());
     // It is a programming error to attempt to resolve style on a Document
     // which is not in a frame. Code which hits this should have checked
     // Document::isActive() before calling into code which could get here.
 
-    ASSERT(document().frame());
+    DCHECK(document().frame());
 
     m_resolver = StyleResolver::create(*m_document);
 
     // A scoped style resolver for document will be created during
     // appendActiveAuthorStyleSheets if needed.
     appendActiveAuthorStyleSheets();
 }
 
 void StyleEngine::clearResolver()
 {
-    ASSERT(!document().inStyleRecalc());
-    ASSERT(isMaster() || !m_resolver);
+    DCHECK(!document().inStyleRecalc());
+    DCHECK(isMaster() || !m_resolver);
 
     document().clearScopedStyleResolver();
     // StyleEngine::shadowRootRemovedFromDocument removes not-in-document
     // treescopes from activeTreeScopes. StyleEngine::didRemoveShadowRoot
     // removes treescopes which are being destroyed from activeTreeScopes.
     // So we need to clearScopedStyleResolver for treescopes which have been
     // just removed from document. If document is destroyed before invoking
     // updateActiveStyleSheets, the treescope has a scopedStyleResolver which
     // has destroyed StyleSheetContents.
     for (TreeScope* treeScope : m_activeTreeScopes)
@@ skipping 46 matching lines @@
     if (m_fontSelector)
         m_fontSelector->fontFaceCache()->clearCSSConnected();
     if (m_resolver)
         m_resolver->invalidateMatchedPropertiesCache();
 }
 
 void StyleEngine::updateGenericFontFamilySettings()
 {
     // FIXME: we should not update generic font family settings when
     // document is inactive.
-    ASSERT(document().isActive());
+    DCHECK(document().isActive());
 
     if (!m_fontSelector)
         return;
 
     m_fontSelector->updateGenericFontFamilySettings(*m_document);
     if (m_resolver)
         m_resolver->invalidateMatchedPropertiesCache();
     FontCache::fontCache()->invalidateShapeCache();
 }
 
 void StyleEngine::removeFontFaceRules(const HeapVector<Member<const StyleRuleFontFace>>& fontFaceRules)
 {
     if (!m_fontSelector)
         return;
 
     FontFaceCache* cache = m_fontSelector->fontFaceCache();
     for (unsigned i = 0; i < fontFaceRules.size(); ++i)
         cache->remove(fontFaceRules[i]);
     if (m_resolver)
         m_resolver->invalidateMatchedPropertiesCache();
 }
 
 void StyleEngine::markTreeScopeDirty(TreeScope& scope)
 {
     if (scope == m_document) {
         markDocumentDirty();
         return;
     }
 
-    ASSERT(m_styleSheetCollectionMap.contains(&scope));
+    DCHECK(m_styleSheetCollectionMap.contains(&scope));
     m_dirtyTreeScopes.add(&scope);
 }
 
 void StyleEngine::markDocumentDirty()
 {
     m_documentScopeDirty = true;
     if (document().importLoader())
         document().importsController()->master()->styleEngine().markDocumentDirty();
 }
 
 static bool isCacheableForStyleElement(const StyleSheetContents& contents)
 {
     // FIXME: Support copying import rules.
     if (!contents.importRules().isEmpty())
         return false;
     // Until import rules are supported in cached sheets it's not possible for loading to fail.
-    ASSERT(!contents.didLoadErrorOccur());
+    DCHECK(!contents.didLoadErrorOccur());
     // It is not the original sheet anymore.
     if (contents.isMutable())
         return false;
     if (!contents.hasSyntacticallyValidCSSHeader())
         return false;
     return true;
 }
 
 RawPtr<CSSStyleSheet> StyleEngine::createSheet(Element* e, const String& text, TextPosition startPosition)
 {
     RawPtr<CSSStyleSheet> styleSheet = nullptr;
 
     e->document().styleEngine().addPendingSheet();
 
     AtomicString textContent(text);
 
     HeapHashMap<AtomicString, Member<StyleSheetContents>>::AddResult result = m_textToSheetCache.add(textContent, nullptr);
     if (result.isNewEntry || !result.storedValue->value) {
         styleSheet = StyleEngine::parseSheet(e, text, startPosition);
         if (result.isNewEntry && isCacheableForStyleElement(*styleSheet->contents())) {
             result.storedValue->value = styleSheet->contents();
             m_sheetToTextCache.add(styleSheet->contents(), textContent);
         }
     } else {
         StyleSheetContents* contents = result.storedValue->value;
-        ASSERT(contents);
-        ASSERT(isCacheableForStyleElement(*contents));
-        ASSERT(contents->singleOwnerDocument() == e->document());
+        DCHECK(contents);
+        DCHECK(isCacheableForStyleElement(*contents));
+        DCHECK_EQ(contents->singleOwnerDocument(), e->document());
         styleSheet = CSSStyleSheet::createInline(contents, e, startPosition);
     }
 
-    ASSERT(styleSheet);
+    DCHECK(styleSheet);
     styleSheet->setTitle(e->title());
     return styleSheet;
 }
 
 RawPtr<CSSStyleSheet> StyleEngine::parseSheet(Element* e, const String& text, TextPosition startPosition)
 {
     RawPtr<CSSStyleSheet> styleSheet = nullptr;
     styleSheet = CSSStyleSheet::createInline(e, KURL(), startPosition, e->document().characterSet());
     styleSheet->contents()->parseStringAtPosition(text, startPosition);
     return styleSheet;
@@ skipping 160 matching lines @@
         return;
     }
     if (!m_styleResolverStats)
         m_styleResolverStats = StyleResolverStats::create();
     else
         m_styleResolverStats->reset();
 }
 
 void StyleEngine::setShadowCascadeOrder(ShadowCascadeOrder order)
 {
-    ASSERT(order != ShadowCascadeOrder::ShadowCascadeNone);
+    DCHECK_NE(order, ShadowCascadeOrder::ShadowCascadeNone);
 
     if (order == m_shadowCascadeOrder)
         return;
 
     if (order == ShadowCascadeOrder::ShadowCascadeV0)
         m_mayContainV0Shadow = true;
 
     // For V0 -> V1 upgrade, we need style recalculation for the whole document.
     if (m_shadowCascadeOrder == ShadowCascadeOrder::ShadowCascadeV0 && order == ShadowCascadeOrder::ShadowCascadeV1)
         document().setNeedsStyleRecalc(SubtreeStyleChange, StyleChangeReasonForTracing::create(StyleChangeReason::Shadow));
@@ skipping 53 matching lines @@
     visitor->trace(m_styleInvalidator);
     visitor->trace(m_dirtyTreeScopes);
     visitor->trace(m_activeTreeScopes);
     visitor->trace(m_fontSelector);
     visitor->trace(m_textToSheetCache);
     visitor->trace(m_sheetToTextCache);
     CSSFontSelectorClient::trace(visitor);
 }
 
 } // namespace blink