Replace ASSERT, ASSERT_NOT_REACHED, and RELEASE_ASSERT in core/css/

third_party/WebKit/Source/core/css/RuleFeature.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All
  * rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
  * (http://www.torchmobile.com/)
@@ skipping 232 matching lines @@
     CSSSelector::PseudoType key,
     InvalidationType type) {
   RefPtr<InvalidationSet>& invalidationSet =
       map.insert(key, nullptr).storedValue->value;
   return storedInvalidationSet(invalidationSet, type);
 }
 
 void extractInvalidationSets(InvalidationSet* invalidationSet,
                              DescendantInvalidationSet*& descendants,
                              SiblingInvalidationSet*& siblings) {
-  RELEASE_ASSERT(invalidationSet->isAlive());
+  CHECK(invalidationSet->isAlive());
   if (invalidationSet->type() == InvalidateDescendants) {
     descendants = toDescendantInvalidationSet(invalidationSet);
     siblings = nullptr;
     return;
   }
 
   siblings = toSiblingInvalidationSet(invalidationSet);
   descendants = siblings->descendants();
 }
 
 }  // anonymous namespace
 
 RuleFeature::RuleFeature(StyleRule* rule,
                          unsigned selectorIndex,
                          bool hasDocumentSecurityOrigin)
     : rule(rule),
       selectorIndex(selectorIndex),
       hasDocumentSecurityOrigin(hasDocumentSecurityOrigin) {}
 
 DEFINE_TRACE(RuleFeature) {
   visitor->trace(rule);
 }
 
 RuleFeatureSet::RuleFeatureSet() : m_isAlive(true) {}
 
 RuleFeatureSet::~RuleFeatureSet() {
-  RELEASE_ASSERT(m_isAlive);
+  CHECK(m_isAlive);
 
   m_metadata.clear();
   m_classInvalidationSets.clear();
   m_attributeInvalidationSets.clear();
   m_idInvalidationSets.clear();
   m_pseudoInvalidationSets.clear();
   m_universalSiblingInvalidationSet.clear();
   m_nthInvalidationSet.clear();
 
   m_isAlive = false;
 }
 
 ALWAYS_INLINE InvalidationSet& RuleFeatureSet::ensureClassInvalidationSet(
     const AtomicString& className,
     InvalidationType type) {
-  RELEASE_ASSERT(!className.isEmpty());
+  CHECK(!className.isEmpty());
   return ensureInvalidationSet(m_classInvalidationSets, className, type);
 }
 
 ALWAYS_INLINE InvalidationSet& RuleFeatureSet::ensureAttributeInvalidationSet(
     const AtomicString& attributeName,
     InvalidationType type) {
-  RELEASE_ASSERT(!attributeName.isEmpty());
+  CHECK(!attributeName.isEmpty());
   return ensureInvalidationSet(m_attributeInvalidationSets, attributeName,
                                type);
 }
 
 ALWAYS_INLINE InvalidationSet& RuleFeatureSet::ensureIdInvalidationSet(
     const AtomicString& id,
     InvalidationType type) {
-  RELEASE_ASSERT(!id.isEmpty());
+  CHECK(!id.isEmpty());
   return ensureInvalidationSet(m_idInvalidationSets, id, type);
 }
 
 ALWAYS_INLINE InvalidationSet& RuleFeatureSet::ensurePseudoInvalidationSet(
     CSSSelector::PseudoType pseudoType,
     InvalidationType type) {
-  RELEASE_ASSERT(pseudoType != CSSSelector::PseudoUnknown);
+  CHECK_NE(pseudoType, CSSSelector::PseudoUnknown);
   return ensureInvalidationSet(m_pseudoInvalidationSets, pseudoType, type);
 }
 
 void RuleFeatureSet::updateFeaturesFromCombinator(
     const CSSSelector& lastInCompound,
     const CSSSelector* lastCompoundInAdjacentChain,
     InvalidationSetFeatures& lastCompoundInAdjacentChainFeatures,
     InvalidationSetFeatures*& siblingFeatures,
     InvalidationSetFeatures& descendantFeatures) {
   if (lastInCompound.isAdjacentSelector()) {
@@ skipping 470 matching lines @@
     DCHECK(lastInCompound);
     updateFeaturesFromCombinator(*lastInCompound, compound,
                                  lastCompoundInSiblingChainFeatures,
                                  siblingFeatures, descendantFeatures);
     compound = lastInCompound->tagHistory();
   }
 }
 
 RuleFeatureSet::SelectorPreMatch RuleFeatureSet::collectFeaturesFromRuleData(
     const RuleData& ruleData) {
-  RELEASE_ASSERT(m_isAlive);
+  CHECK(m_isAlive);
   FeatureMetadata metadata;
   if (collectFeaturesFromSelector(ruleData.selector(), metadata) ==
       SelectorNeverMatches)
     return SelectorNeverMatches;
 
   m_metadata.add(metadata);
 
   if (metadata.foundSiblingSelector) {
     m_siblingRules.push_back(RuleFeature(ruleData.rule(),
                                          ruleData.selectorIndex(),
@@ skipping 96 matching lines @@
 void RuleFeatureSet::FeatureMetadata::clear() {
   usesFirstLineRules = false;
   usesWindowInactiveSelector = false;
   foundSiblingSelector = false;
   foundInsertionPointCrossing = false;
   needsFullRecalcForRuleSetInvalidation = false;
   maxDirectAdjacentSelectors = 0;
 }
 
 void RuleFeatureSet::add(const RuleFeatureSet& other) {
-  RELEASE_ASSERT(m_isAlive);
-  RELEASE_ASSERT(other.m_isAlive);
-  RELEASE_ASSERT(&other != this);
+  CHECK(m_isAlive);
+  CHECK(other.m_isAlive);
+  CHECK_NE(&other, this);
   for (const auto& entry : other.m_classInvalidationSets)
     ensureInvalidationSet(m_classInvalidationSets, entry.key,
                           entry.value->type())
         .combine(*entry.value);
   for (const auto& entry : other.m_attributeInvalidationSets)
     ensureInvalidationSet(m_attributeInvalidationSets, entry.key,
                           entry.value->type())
         .combine(*entry.value);
   for (const auto& entry : other.m_idInvalidationSets)
     ensureInvalidationSet(m_idInvalidationSets, entry.key, entry.value->type())
@@ skipping 13 matching lines @@
 
   m_siblingRules.appendVector(other.m_siblingRules);
   m_uncommonAttributeRules.appendVector(other.m_uncommonAttributeRules);
   m_viewportDependentMediaQueryResults.appendVector(
       other.m_viewportDependentMediaQueryResults);
   m_deviceDependentMediaQueryResults.appendVector(
       other.m_deviceDependentMediaQueryResults);
 }
 
 void RuleFeatureSet::clear() {
-  RELEASE_ASSERT(m_isAlive);
+  CHECK(m_isAlive);
   m_siblingRules.clear();
   m_uncommonAttributeRules.clear();
   m_metadata.clear();
   m_classInvalidationSets.clear();
   m_attributeInvalidationSets.clear();
   m_idInvalidationSets.clear();
   m_pseudoInvalidationSets.clear();
   m_universalSiblingInvalidationSet.clear();
   m_nthInvalidationSet.clear();
   m_viewportDependentMediaQueryResults.clear();
@@ skipping 258 matching lines @@
 bool RuleFeatureSet::InvalidationSetFeatures::hasFeatures() const {
   return !classes.isEmpty() || !attributes.isEmpty() || !ids.isEmpty() ||
          !tagNames.isEmpty() || customPseudoElement;
 }
 
 bool RuleFeatureSet::InvalidationSetFeatures::hasIdClassOrAttribute() const {
   return !classes.isEmpty() || !attributes.isEmpty() || !ids.isEmpty();
 }
 
 }  // namespace blink