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 39 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 (!isCSSPropertyIDWithName(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(isCSSPropertyIDWithName(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 (!isCSSPropertyIDWithName(property.id()))
       return false;
     return m_longhandPropertyUsed.test(property.id() - firstCSSProperty);
   }
 
   CSSPropertyID propertyID =
       static_cast<CSSPropertyID>(index + firstCSSProperty);
-  ASSERT(firstCSSProperty <= propertyID && propertyID <= lastCSSProperty);
+  DCHECK(isCSSPropertyIDWithName(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 29 matching lines @@
   return value.isImplicit();
 }
 
 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());
@@ skipping 38 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) ||
+    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;
@@ skipping 51 matching lines @@
       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 209 matching lines @@
   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->isIdentifierValue() &&
       toCSSIdentifierValue(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->isIdentifierValue() &&
       toCSSIdentifierValue(val)->getValueID() == CSSValueNone) {
@@ skipping 176 matching lines @@
       }
       // 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] ==
+        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.
@@ skipping 173 matching lines @@
     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