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

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

 /*
  * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
  *               1999 Waldo Bastian (bastian@kde.org)
  *               2001 Andreas Schlapbach (schlpbch@iam.unibe.ch)
  *               2001-2003 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2002, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights
  * reserved.
  * Copyright (C) 2008 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
@@ skipping 36 matching lines @@
 
 struct SameSizeAsCSSSelector {
   unsigned bitfields;
   void* pointers[1];
 };
 
 static_assert(sizeof(CSSSelector) == sizeof(SameSizeAsCSSSelector),
               "CSSSelector should stay small");
 
 void CSSSelector::createRareData() {
-  ASSERT(m_match != Tag);
+  DCHECK_NE(m_match, Tag);
   if (m_hasRareData)
     return;
   AtomicString value(m_data.m_value);
   if (m_data.m_value)
     m_data.m_value->deref();
   m_data.m_rareData = RareData::create(value).leakRef();
   m_hasRareData = true;
 }
 
 unsigned CSSSelector::specificity() const {
@@ skipping 33 matching lines @@
     case Id:
       return 0x010000;
     case PseudoClass:
       switch (getPseudoType()) {
         case PseudoHost:
         case PseudoHostContext:
           // We dynamically compute the specificity of :host and :host-context
           // during matching.
           return 0;
         case PseudoNot:
-          ASSERT(selectorList());
+          DCHECK(selectorList());
           return selectorList()->first()->specificityForOneSelector();
         // FIXME: PseudoAny should base the specificity on the sub-selectors.
         // See http://lists.w3.org/Archives/Public/www-style/2010Sep/0530.html
         case PseudoAny:
         default:
           break;
       }
       return 0x000100;
     case Class:
     case PseudoElement:
@@ skipping 254 matching lines @@
     {"nth-child", CSSSelector::PseudoNthChild},
     {"nth-last-child", CSSSelector::PseudoNthLastChild},
     {"nth-last-of-type", CSSSelector::PseudoNthLastOfType},
     {"nth-of-type", CSSSelector::PseudoNthOfType},
     {"slotted", CSSSelector::PseudoSlotted},
 };
 
 class NameToPseudoCompare {
  public:
   NameToPseudoCompare(const AtomicString& key) : m_key(key) {
-    ASSERT(m_key.is8Bit());
+    DCHECK(m_key.is8Bit());
   }
 
   bool operator()(const NameToPseudoStruct& entry, const NameToPseudoStruct&) {
-    ASSERT(entry.string);
+    DCHECK(entry.string);
     const char* key = reinterpret_cast<const char*>(m_key.characters8());
     // If strncmp returns 0, then either the keys are equal, or |m_key| sorts
     // before |entry|.
     return strncmp(entry.string, key, m_key.length()) < 0;
   }
 
  private:
   const AtomicString& m_key;
 };
 
@@ skipping 74 matching lines @@
 
 PseudoId CSSSelector::parsePseudoId(const String& name) {
   unsigned nameWithoutColonsStart =
       name[0] == ':' ? (name[1] == ':' ? 2 : 1) : 0;
   return pseudoId(parsePseudoType(
       AtomicString(name.substring(nameWithoutColonsStart)), false));
 }
 
 void CSSSelector::updatePseudoType(const AtomicString& value,
                                    bool hasArguments) {
-  ASSERT(m_match == PseudoClass || m_match == PseudoElement ||
+  DCHECK(m_match == PseudoClass || m_match == PseudoElement ||
          m_match == PagePseudoClass);
 
   setValue(value);
   setPseudoType(parsePseudoType(value, hasArguments));
 
   switch (m_pseudoType) {
     case PseudoAfter:
     case PseudoBefore:
     case PseudoFirstLetter:
     case PseudoFirstLine:
@@ skipping 181 matching lines @@
 
           str.append(')');
           break;
         }
         case PseudoLang:
           str.append('(');
           str.append(cs->argument());
           str.append(')');
           break;
         case PseudoNot:
-          ASSERT(cs->selectorList());
+          DCHECK(cs->selectorList());
           break;
         case PseudoHost:
         case PseudoHostContext:
         case PseudoAny:
           break;
         default:
           break;
       }
     } else if (cs->m_match == PseudoElement) {
       str.append("::");
@@ skipping 62 matching lines @@
       case ShadowDeep:
         return tagHistory->selectorText(" /deep/ " + str.toString() +
                                         rightSide);
       case ShadowPiercingDescendant:
         return tagHistory->selectorText(" >>> " + str.toString() + rightSide);
       case DirectAdjacent:
         return tagHistory->selectorText(" + " + str.toString() + rightSide);
       case IndirectAdjacent:
         return tagHistory->selectorText(" ~ " + str.toString() + rightSide);
       case SubSelector:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
       case ShadowPseudo:
       case ShadowSlot:
         return tagHistory->selectorText(str.toString() + rightSide);
     }
   }
   return str.toString() + rightSide;
 }
 
 void CSSSelector::setAttribute(const QualifiedName& value,
                                AttributeMatchType matchType) {
@@ skipping 89 matching lines @@
 
   // Determine if this selector will match a link in visited, unvisited or any
   // state, or never.
   // :visited never matches other elements than the innermost link element.
   for (const CSSSelector* current = this; current;
        current = current->tagHistory()) {
     switch (current->getPseudoType()) {
       case PseudoNot: {
         // :not(:visited) is equivalent to :link. Parser enforces that :not
         // can't nest.
-        ASSERT(current->selectorList());
+        DCHECK(current->selectorList());
         for (const CSSSelector* subSelector = current->selectorList()->first();
              subSelector; subSelector = subSelector->tagHistory()) {
           PseudoType subType = subSelector->getPseudoType();
           if (subType == PseudoVisited)
             linkMatchType &= ~MatchVisited;
           else if (subType == PseudoLink)
             linkMatchType &= ~MatchLink;
         }
       } break;
       case PseudoLink:
@@ skipping 17 matching lines @@
   return linkMatchType;
 }
 
 void CSSSelector::setNth(int a, int b) {
   createRareData();
   m_data.m_rareData->m_bits.m_nth.m_a = a;
   m_data.m_rareData->m_bits.m_nth.m_b = b;
 }
 
 bool CSSSelector::matchNth(int count) const {
-  ASSERT(m_hasRareData);
+  DCHECK(m_hasRareData);
   return m_data.m_rareData->matchNth(count);
 }
 
 bool CSSSelector::matchesPseudoElement() const {
   for (const CSSSelector* current = this; current;
        current = current->tagHistory()) {
     if (current->match() == PseudoElement)
       return true;
     if (current->relation() != SubSelector)
       return false;
@@ skipping 73 matching lines @@
     if (count < nthBValue())
       return false;
     return (count - nthBValue()) % nthAValue() == 0;
   }
   if (count > nthBValue())
     return false;
   return (nthBValue() - count) % (-nthAValue()) == 0;
 }
 
 }  // namespace blink