Make a function to query whether a CSSPropertyID is valid and whether it has a name.

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

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 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
  * version 2 of the License, or (at your option) any later version.
@@ skipping 37 matching lines @@
         if (CSSProperty::isAffectedByAllProperty(property.id())) {
             if (allProperty.isImportant() && !property.isImportant())
                 continue;
             if (static_cast<unsigned>(m_allIndex) >= i)
                 continue;
             if (property.value().equals(allProperty.value())
                 && property.isImportant() == allProperty.isImportant())
                 continue;
             m_needToExpandAll = true;
         }
-        if (property.id() < firstCSSProperty || property.id() > lastCSSProperty)
+        if (!propertyHasName(property.id()))
             continue;
         m_longhandPropertyUsed.set(property.id() - firstCSSProperty);
     }
 }
 
 DEFINE_TRACE(StylePropertySerializer::StylePropertySetForSerializer)
 {
     visitor->trace(m_propertySet);
 }
 
 unsigned StylePropertySerializer::StylePropertySetForSerializer::propertyCount() const
 {
     if (!hasExpandedAllProperty())
         return m_propertySet->propertyCount();
     return lastCSSProperty - firstCSSProperty + 1;
 }
 
 StylePropertySerializer::PropertyValueForSerializer StylePropertySerializer::StylePropertySetForSerializer::propertyAt(unsigned index) const
 {
     if (!hasExpandedAllProperty())
         return StylePropertySerializer::PropertyValueForSerializer(m_propertySet->propertyAt(index));
 
     CSSPropertyID propertyID = static_cast<CSSPropertyID>(index + firstCSSProperty);
-    ASSERT(firstCSSProperty <= propertyID && propertyID <= lastCSSProperty);
+    DCHECK(propertyHasName(propertyID));
     if (m_longhandPropertyUsed.test(index)) {
         int index = m_propertySet->findPropertyIndex(propertyID);
-        ASSERT(index != -1);
+        DCHECK_NE(index, -1);
         return StylePropertySerializer::PropertyValueForSerializer(m_propertySet->propertyAt(index));
     }
 
     StylePropertySet::PropertyReference property = m_propertySet->propertyAt(m_allIndex);
     return StylePropertySerializer::PropertyValueForSerializer(propertyID, &property.value(), property.isImportant());
 }
 
 bool StylePropertySerializer::StylePropertySetForSerializer::shouldProcessPropertyAt(unsigned index) const
 {
     // StylePropertySet has all valid longhands. We should process.
     if (!hasAllProperty())
         return true;
 
     // If all is not expanded, we need to process "all" and properties which
     // are not overwritten by "all".
     if (!m_needToExpandAll) {
         StylePropertySet::PropertyReference property = m_propertySet->propertyAt(index);
         if (property.id() == CSSPropertyAll || !CSSProperty::isAffectedByAllProperty(property.id()))
             return true;
-        if (property.id() < firstCSSProperty || property.id() > lastCSSProperty)
+        if (!propertyHasName(property.id()))
             return false;
         return m_longhandPropertyUsed.test(property.id() - firstCSSProperty);
     }
 
     CSSPropertyID propertyID = static_cast<CSSPropertyID>(index + firstCSSProperty);
-    ASSERT(firstCSSProperty <= propertyID && propertyID <= lastCSSProperty);
+    DCHECK(propertyHasName(propertyID));
 
     // Since "all" is expanded, we don't need to process "all".
     // We should not process expanded shorthands (e.g. font, background,
     // and so on) either.
     if (isShorthandProperty(propertyID) || propertyID == CSSPropertyAll)
         return false;
 
     // The all property is a shorthand that resets all CSS properties except
     // direction and unicode-bidi. It only accepts the CSS-wide keywords.
     // c.f. http://dev.w3.org/csswg/css-cascade/#all-shorthand
@@ skipping 48 matching lines @@
     return value.isImportant();
 }
 
 StylePropertySerializer::StylePropertySerializer(const StylePropertySet& properties)
     : m_propertySet(properties)
 {
 }
 
 String StylePropertySerializer::getCustomPropertyText(const PropertyValueForSerializer& property, bool isNotFirstDecl) const
 {
-    ASSERT(property.id() == CSSPropertyVariable);
+    DCHECK_EQ(property.id(), CSSPropertyVariable);
     StringBuilder result;
     if (isNotFirstDecl)
         result.append(' ');
     const CSSCustomPropertyDeclaration* value = toCSSCustomPropertyDeclaration(property.value());
     result.append(value->name());
     result.append(':');
     if (!value->value())
         result.append(' ');
     result.append(value->customCSSText());
     if (property.isImportant())
@@ skipping 36 matching lines @@
 
     unsigned size = m_propertySet.propertyCount();
     unsigned numDecls = 0;
     for (unsigned n = 0; n < size; ++n) {
         if (!m_propertySet.shouldProcessPropertyAt(n))
             continue;
 
         StylePropertySerializer::PropertyValueForSerializer property = m_propertySet.propertyAt(n);
         CSSPropertyID propertyID = property.id();
         // Only enabled properties should be part of the style.
-        ASSERT(CSSPropertyMetadata::isEnabledProperty(propertyID));
+        DCHECK(CSSPropertyMetadata::isEnabledProperty(propertyID));
         // Shorthands with variable references are not expanded at parse time
         // and hence may still be observed during serialization.
-        ASSERT(!isShorthandProperty(propertyID) || property.value()->isVariableReferenceValue());
+        DCHECK(!isShorthandProperty(propertyID) || property.value()->isVariableReferenceValue());
 
         switch (propertyID) {
         case CSSPropertyVariable:
             result.append(getCustomPropertyText(property, numDecls++));
             continue;
         case CSSPropertyAll:
             result.append(getPropertyText(propertyID, property.value()->cssText(), property.isImportant(), numDecls++));
             continue;
         case CSSPropertyApplyAtRule:
             result.append(getApplyAtRuleText(property.value(), numDecls++));
@@ skipping 45 matching lines @@
                 longhandSerialized.set(shorthand.properties()[i] - firstCSSProperty);
             break;
         }
 
         if (serializedAsShorthand)
             continue;
 
         result.append(getPropertyText(propertyID, property.value()->cssText(), property.isImportant(), numDecls++));
     }
 
-    ASSERT(!numDecls ^ !result.isEmpty());
+    DCHECK(!numDecls ^ !result.isEmpty());
     return result.toString();
 }
 
 // As per css-cascade, shorthands do not expand longhands to the value
 // "initial", except when the shorthand is set to "initial", instead
 // setting "missing" sub-properties to their initial values. This means
 // that a shorthand can never represent a list of subproperties where
 // some are "initial" and some are not, and so serialization should
 // always fail in these cases (as per cssom). However we currently use
 // "initial" instead of the initial values for certain shorthands, so
@@ skipping 201 matching lines @@
     String horizontalValueCSSText = horizontalValue->cssText();
     String verticalValueCSSText = verticalValue->cssText();
     if (horizontalValueCSSText == verticalValueCSSText)
         return horizontalValueCSSText;
     return horizontalValueCSSText + ' ' + verticalValueCSSText;
 }
 
 void StylePropertySerializer::appendFontLonghandValueIfNotNormal(CSSPropertyID propertyID, StringBuilder& result) const
 {
     int foundPropertyIndex = m_propertySet.findPropertyIndex(propertyID);
-    ASSERT(foundPropertyIndex != -1);
+    DCHECK_NE(foundPropertyIndex, -1);
 
     const CSSValue* val = m_propertySet.propertyAt(foundPropertyIndex).value();
     if (val->isPrimitiveValue() && toCSSPrimitiveValue(val)->getValueID() == CSSValueNormal)
         return;
 
     char prefix = '\0';
     switch (propertyID) {
     case CSSPropertyFontStyle:
         break; // No prefix.
     case CSSPropertyFontFamily:
     case CSSPropertyFontStretch:
     case CSSPropertyFontVariantCaps:
     case CSSPropertyFontVariantLigatures:
     case CSSPropertyFontVariantNumeric:
     case CSSPropertyFontWeight:
         prefix = ' ';
         break;
     case CSSPropertyLineHeight:
         prefix = '/';
         break;
     default:
-        ASSERT_NOT_REACHED();
+        NOTREACHED();
     }
 
     if (prefix && !result.isEmpty())
         result.append(prefix);
 
     String value;
     // In the font-variant shorthand a "none" ligatures value needs to be expanded.
     if (propertyID == CSSPropertyFontVariantLigatures
         && val->isPrimitiveValue()
         && toCSSPrimitiveValue(val)->getValueID() == CSSValueNone) {
@@ skipping 156 matching lines @@
                 // Background color belongs in the last layer.
                 value = values[propertyIndex];
             }
             // No point proceeding if there's not a value to look at.
             if (!value)
                 continue;
 
             // Special case for background-repeat.
             if ((propertyIndex < size - 1 && m_propertySet.isPropertyImplicit(property))
                 && (property == CSSPropertyBackgroundRepeatX || property == CSSPropertyWebkitMaskRepeatX)) {
-                ASSERT(shorthand.properties()[propertyIndex + 1] == CSSPropertyBackgroundRepeatY
+                DCHECK(shorthand.properties()[propertyIndex + 1] == CSSPropertyBackgroundRepeatY
                     || shorthand.properties()[propertyIndex + 1] == CSSPropertyWebkitMaskRepeatY);
                 const CSSValue& yValue = values[propertyIndex + 1]->isValueList() ?
                     toCSSValueList(values[propertyIndex + 1])->item(layer) : *values[propertyIndex + 1];
 
 
                 // FIXME: At some point we need to fix this code to avoid returning an invalid shorthand,
                 // since some longhand combinations are not serializable into a single shorthand.
                 if (!value->isPrimitiveValue() || !yValue.isPrimitiveValue())
                     continue;
 
@@ skipping 152 matching lines @@
             builder.append(", ");
 
         const CSSValue& xValue = repeatXList ? repeatXList->item(i % repeatXList->length()) : repeatX;
         const CSSValue& yValue = repeatYList ? repeatYList->item(i % repeatYList->length()) : repeatY;
         appendBackgroundRepeatValue(builder, xValue, yValue);
     }
     return builder.toString();
 }
 
 } // namespace blink