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

third_party/WebKit/Source/core/css/invalidation/InvalidationSet.cpp

 /*
  * Copyright (C) 2014 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 91 matching lines @@
             element, InvalidationSetMatchedAttribute, *this, attribute);
         return true;
       }
     }
   }
 
   return false;
 }
 
 void InvalidationSet::combine(const InvalidationSet& other) {
-  RELEASE_ASSERT(m_isAlive);
-  RELEASE_ASSERT(other.m_isAlive);
-  RELEASE_ASSERT(&other != this);
-  RELEASE_ASSERT(type() == other.type());
+  CHECK(m_isAlive);
+  CHECK(other.m_isAlive);
+  CHECK_NE(&other, this);
+  CHECK_EQ(type(), other.type());
   if (type() == InvalidateSiblings) {
     SiblingInvalidationSet& siblings = toSiblingInvalidationSet(*this);
     const SiblingInvalidationSet& otherSiblings =
         toSiblingInvalidationSet(other);
 
     siblings.updateMaxDirectAdjacentSelectors(
         otherSiblings.maxDirectAdjacentSelectors());
     if (otherSiblings.siblingDescendants())
       siblings.ensureSiblingDescendants().combine(
           *otherSiblings.siblingDescendants());
@@ skipping 74 matching lines @@
 
 HashSet<AtomicString>& InvalidationSet::ensureAttributeSet() {
   if (!m_attributes)
     m_attributes = WTF::wrapUnique(new HashSet<AtomicString>);
   return *m_attributes;
 }
 
 void InvalidationSet::addClass(const AtomicString& className) {
   if (wholeSubtreeInvalid())
     return;
-  RELEASE_ASSERT(!className.isEmpty());
+  CHECK(!className.isEmpty());
   ensureClassSet().insert(className);
 }
 
 void InvalidationSet::addId(const AtomicString& id) {
   if (wholeSubtreeInvalid())
     return;
-  RELEASE_ASSERT(!id.isEmpty());
+  CHECK(!id.isEmpty());
   ensureIdSet().insert(id);
 }
 
 void InvalidationSet::addTagName(const AtomicString& tagName) {
   if (wholeSubtreeInvalid())
     return;
-  RELEASE_ASSERT(!tagName.isEmpty());
+  CHECK(!tagName.isEmpty());
   ensureTagNameSet().insert(tagName);
 }
 
 void InvalidationSet::addAttribute(const AtomicString& attribute) {
   if (wholeSubtreeInvalid())
     return;
-  RELEASE_ASSERT(!attribute.isEmpty());
+  CHECK(!attribute.isEmpty());
   ensureAttributeSet().insert(attribute);
 }
 
 void InvalidationSet::setWholeSubtreeInvalid() {
   if (m_allDescendantsMightBeInvalid)
     return;
 
   m_allDescendantsMightBeInvalid = true;
   m_customPseudoInvalid = false;
   m_treeBoundaryCrossing = false;
@@ skipping 74 matching lines @@
   return *m_siblingDescendantInvalidationSet;
 }
 
 DescendantInvalidationSet& SiblingInvalidationSet::ensureDescendants() {
   if (!m_descendantInvalidationSet)
     m_descendantInvalidationSet = DescendantInvalidationSet::create();
   return *m_descendantInvalidationSet;
 }
 
 }  // namespace blink