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

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

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 Apple Inc.
  * All rights reserved.
  * Copyright (C) 2011 Research In Motion Limited. All rights reserved.
  * Copyright (C) 2013 Intel Corporation. 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
@@ skipping 35 matching lines @@
     unsigned count) {
   return sizeof(ImmutableStylePropertySet) - sizeof(void*) +
          sizeof(Member<CSSValue>) * count +
          sizeof(StylePropertyMetadata) * count;
 }
 
 ImmutableStylePropertySet* ImmutableStylePropertySet::create(
     const CSSProperty* properties,
     unsigned count,
     CSSParserMode cssParserMode) {
-  ASSERT(count <= MaxArraySize);
+  DCHECK_LE(count, static_cast<unsigned>(MaxArraySize));
   void* slot = ThreadHeap::allocate<StylePropertySet>(
       sizeForImmutableStylePropertySetWithPropertyCount(count));
   return new (slot) ImmutableStylePropertySet(properties, count, cssParserMode);
 }
 
 ImmutableStylePropertySet* StylePropertySet::immutableCopyIfNeeded() const {
   if (!isMutable())
     return toImmutableStylePropertySet(const_cast<StylePropertySet*>(this));
   const MutableStylePropertySet* mutableThis = toMutableStylePropertySet(this);
   return ImmutableStylePropertySet::create(mutableThis->m_propertyVector.data(),
@@ skipping 36 matching lines @@
 }
 
 static uint16_t getConvertedCSSPropertyID(const AtomicString&) {
   return static_cast<uint16_t>(CSSPropertyVariable);
 }
 
 static bool isPropertyMatch(const StylePropertyMetadata& metadata,
                             const CSSValue&,
                             uint16_t id,
                             CSSPropertyID propertyID) {
-  ASSERT(id == propertyID);
+  DCHECK_EQ(id, propertyID);
   bool result = metadata.m_propertyID == id;
   // Only enabled properties should be part of the style.
-  ASSERT(!result || CSSPropertyMetadata::isEnabledProperty(propertyID));
+  DCHECK(!result || CSSPropertyMetadata::isEnabledProperty(propertyID));
   return result;
 }
 
 static bool isPropertyMatch(const StylePropertyMetadata& metadata,
                             const CSSValue& value,
                             uint16_t id,
                             const AtomicString& customPropertyName) {
-  ASSERT(id == CSSPropertyVariable);
+  DCHECK_EQ(id, CSSPropertyVariable);
   return metadata.m_propertyID == id &&
          toCSSCustomPropertyDeclaration(value).name() == customPropertyName;
 }
 
 template <typename T>
 int ImmutableStylePropertySet::findPropertyIndex(T property) const {
   uint16_t id = getConvertedCSSPropertyID(property);
   for (int n = m_arraySize - 1; n >= 0; --n) {
     if (isPropertyMatch(metadataArray()[n], *valueArray()[n], id, property))
       return n;
@@ skipping 344 matching lines @@
 
 CSSProperty* MutableStylePropertySet::findCSSPropertyWithID(
     CSSPropertyID propertyID,
     const AtomicString& customPropertyName) {
   int foundPropertyIndex = -1;
   if (propertyID == CSSPropertyVariable && !customPropertyName.isNull()) {
     // TODO(shanestephens): fix call sites so we always have a
     // customPropertyName here.
     foundPropertyIndex = findPropertyIndex(customPropertyName);
   } else {
-    ASSERT(customPropertyName.isNull());
+    DCHECK(customPropertyName.isNull());
     foundPropertyIndex = findPropertyIndex(propertyID);
   }
   if (foundPropertyIndex == -1)
     return nullptr;
   return &m_propertyVector.at(foundPropertyIndex);
 }
 
 bool StylePropertySet::propertyMatches(CSSPropertyID propertyID,
                                        const CSSValue& propertyValue) const {
   int foundPropertyIndex = findPropertyIndex(propertyID);
@@ skipping 43 matching lines @@
     if (value)
       list.push_back(CSSProperty(properties[i], *value, false));
   }
   return MutableStylePropertySet::create(list.data(), list.size());
 }
 
 CSSStyleDeclaration* MutableStylePropertySet::ensureCSSStyleDeclaration() {
   // FIXME: get rid of this weirdness of a CSSStyleDeclaration inside of a
   // style property set.
   if (m_cssomWrapper) {
-    ASSERT(
+    DCHECK(
         !static_cast<CSSStyleDeclaration*>(m_cssomWrapper.get())->parentRule());
-    ASSERT(!m_cssomWrapper->parentElement());
+    DCHECK(!m_cssomWrapper->parentElement());
     return m_cssomWrapper.get();
   }
   m_cssomWrapper = new PropertySetCSSStyleDeclaration(*this);
   return m_cssomWrapper.get();
 }
 
 template <typename T>
 int MutableStylePropertySet::findPropertyIndex(T property) const {
   const CSSProperty* begin = m_propertyVector.data();
   const CSSProperty* end = begin + m_propertyVector.size();
@@ skipping 46 matching lines @@
 
 MutableStylePropertySet* MutableStylePropertySet::create(
     const CSSProperty* properties,
     unsigned count) {
   return new MutableStylePropertySet(properties, count);
 }
 
 DEFINE_TRACE(CSSLazyPropertyParser) {}
 
 }  // namespace blink