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

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

 /*
  * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
  *               1999 Waldo Bastian (bastian@kde.org)
  * Copyright (C) 2004, 2006, 2007, 2008, 2009, 2010, 2013 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
  * version 2 of the License, or (at your option) any later version.
@@ skipping 288 matching lines @@
   bool isInsertionPointCrossing() const {
     return m_pseudoType == PseudoHostContext || m_pseudoType == PseudoContent;
   }
   bool isIdClassOrAttributeSelector() const;
 
   RelationType relation() const {
     return static_cast<RelationType>(m_relation);
   }
   void setRelation(RelationType relation) {
     m_relation = relation;
-    ASSERT(static_cast<RelationType>(m_relation) ==
-           relation);  // using a bitfield.
+    DCHECK_EQ(static_cast<RelationType>(m_relation),
+              relation);  // using a bitfield.
   }
 
   MatchType match() const { return static_cast<MatchType>(m_match); }
   void setMatch(MatchType match) {
     m_match = match;
-    ASSERT(static_cast<MatchType>(m_match) == match);  // using a bitfield.
+    DCHECK_EQ(static_cast<MatchType>(m_match), match);  // using a bitfield.
   }
 
   bool isLastInSelectorList() const { return m_isLastInSelectorList; }
   void setLastInSelectorList() { m_isLastInSelectorList = true; }
   bool isLastInTagHistory() const { return m_isLastInTagHistory; }
   void setNotLastInTagHistory() { m_isLastInTagHistory = false; }
 
   // http://dev.w3.org/csswg/selectors4/#compound
   bool isCompound() const;
 
@@ skipping 27 matching lines @@
   unsigned m_pseudoType : 8;  // enum PseudoType
   unsigned m_isLastInSelectorList : 1;
   unsigned m_isLastInTagHistory : 1;
   unsigned m_hasRareData : 1;
   unsigned m_isForPage : 1;
   unsigned m_tagIsImplicit : 1;
   unsigned m_relationIsAffectedByPseudoContent : 1;
 
   void setPseudoType(PseudoType pseudoType) {
     m_pseudoType = pseudoType;
-    ASSERT(static_cast<PseudoType>(m_pseudoType) ==
-           pseudoType);  // using a bitfield.
+    DCHECK_EQ(static_cast<PseudoType>(m_pseudoType),
+              pseudoType);  // using a bitfield.
   }
 
   unsigned specificityForOneSelector() const;
   unsigned specificityForPage() const;
 
   // Hide.
   CSSSelector& operator=(const CSSSelector&);
 
   struct RareData : public RefCounted<RareData> {
     static PassRefPtr<RareData> create(const AtomicString& value) {
@@ skipping 27 matching lines @@
 
   union DataUnion {
     DataUnion() : m_value(nullptr) {}
     StringImpl* m_value;
     QualifiedName::QualifiedNameImpl* m_tagQName;
     RareData* m_rareData;
   } m_data;
 };
 
 inline const QualifiedName& CSSSelector::attribute() const {
-  ASSERT(isAttributeSelector());
-  ASSERT(m_hasRareData);
+  DCHECK(isAttributeSelector());
+  DCHECK(m_hasRareData);
   return m_data.m_rareData->m_attribute;
 }
 
 inline CSSSelector::AttributeMatchType CSSSelector::attributeMatch() const {
-  ASSERT(isAttributeSelector());
-  ASSERT(m_hasRareData);
+  DCHECK(isAttributeSelector());
+  DCHECK(m_hasRareData);
   return m_data.m_rareData->m_bits.m_attributeMatch;
 }
 
 inline bool CSSSelector::isASCIILower(const AtomicString& value) {
   for (size_t i = 0; i < value.length(); ++i) {
     if (isASCIIUpper(value[i]))
       return false;
   }
   return true;
 }
 
 inline void CSSSelector::setValue(const AtomicString& value,
                                   bool matchLowerCase = false) {
-  ASSERT(m_match != Tag);
+  DCHECK_NE(m_match, Tag);
   if (matchLowerCase && !m_hasRareData && !isASCIILower(value)) {
     createRareData();
   }
   // Need to do ref counting manually for the union.
   if (!m_hasRareData) {
     if (m_data.m_value)
       m_data.m_value->deref();
     m_data.m_value = value.impl();
     m_data.m_value->ref();
     return;
@@ skipping 55 matching lines @@
 inline CSSSelector::~CSSSelector() {
   if (m_match == Tag)
     m_data.m_tagQName->deref();
   else if (m_hasRareData)
     m_data.m_rareData->deref();
   else if (m_data.m_value)
     m_data.m_value->deref();
 }
 
 inline const QualifiedName& CSSSelector::tagQName() const {
-  ASSERT(m_match == Tag);
+  DCHECK_EQ(m_match, Tag);
   return *reinterpret_cast<const QualifiedName*>(&m_data.m_tagQName);
 }
 
 inline const AtomicString& CSSSelector::value() const {
-  ASSERT(m_match != Tag);
+  DCHECK_NE(m_match, Tag);
   if (m_hasRareData)
     return m_data.m_rareData->m_matchingValue;
   // AtomicString is really just a StringImpl* so the cast below is safe.
   // FIXME: Perhaps call sites could be changed to accept StringImpl?
   return *reinterpret_cast<const AtomicString*>(&m_data.m_value);
 }
 
 inline const AtomicString& CSSSelector::serializingValue() const {
-  ASSERT(m_match != Tag);
+  DCHECK_NE(m_match, Tag);
   if (m_hasRareData)
     return m_data.m_rareData->m_serializingValue;
   // AtomicString is really just a StringImpl* so the cast below is safe.
   // FIXME: Perhaps call sites could be changed to accept StringImpl?
   return *reinterpret_cast<const AtomicString*>(&m_data.m_value);
 }
 
 inline bool CSSSelector::isUserActionPseudoClass() const {
   return m_pseudoType == PseudoHover || m_pseudoType == PseudoActive ||
          m_pseudoType == PseudoFocus || m_pseudoType == PseudoDrag;
 }
 
 inline bool CSSSelector::isIdClassOrAttributeSelector() const {
   return isAttributeSelector() || match() == CSSSelector::Id ||
          match() == CSSSelector::Class;
 }
 
 }  // namespace blink
 
 #endif  // CSSSelector_h