CSSValue Immediates: Remove redundant isTaggedPtr() checks

Source/core/css/CSSPrimitiveValue.cpp

 /*
  * (C) 1999-2003 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2012 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.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 150 matching lines @@
 
 typedef HashMap<const CSSPrimitiveValue*, String> CSSTextCache;
 static CSSTextCache& cssTextCache()
 {
     AtomicallyInitializedStaticReference(ThreadSpecific<CSSTextCache>, cache, new ThreadSpecific<CSSTextCache>());
     return *cache;
 }
 
 CSSPrimitiveValue::UnitType CSSPrimitiveValue::primitiveType() const
 {
-    if (type() == CSS_PROPERTY_ID || type() == CSS_VALUE_ID)
+    CSSPrimitiveValue::UnitType unitType = type();
+
+    if (unitType == CSS_PROPERTY_ID || unitType == CSS_VALUE_ID)
         return CSS_IDENT;
 
-    if (type() != CSS_CALC)
-        return type();
+    if (unitType != CSS_CALC)
+        return unitType;
 
-    switch (value().calc->category()) {
+    ASSERT(!isTaggedPtr());
+    switch (m_value.calc->category()) {
     case CalcAngle:
         return CSS_DEG;
     case CalcFrequency:
         return CSS_HZ;
     case CalcNumber:
         return CSS_NUMBER;
     case CalcPercent:
         return CSS_PERCENTAGE;
     case CalcLength:
         return CSS_PX;
@@ skipping 211 matching lines @@
 CSSPrimitiveValue::~CSSPrimitiveValue()
 {
     cleanup();
 }
 
 void CSSPrimitiveValue::cleanup()
 {
     if (isTaggedPtr())
         return;
 
-    switch (type()) {
+    switch (m_primitiveUnitType) {
     case CSS_CUSTOM_IDENT:
     case CSS_STRING:
     case CSS_URI:
     case CSS_ATTR:
         if (m_value.string)
             m_value.string->deref();
         break;
     case CSS_COUNTER:
         // We must not call deref() when oilpan is enabled because m_value.counter is traced.
 #if !ENABLE(OILPAN)
@@ skipping 142 matching lines @@
 template<> double CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData)
 {
     return computeLengthDouble(conversionData);
 }
 
 double CSSPrimitiveValue::computeLengthDouble(const CSSToLengthConversionData& conversionData)
 {
     // The logic in this function is duplicated in MediaValues::computeLength
     // because MediaValues::computeLength needs nearly identical logic, but we haven't found a way to make
     // CSSPrimitiveValue::computeLengthDouble more generic (to solve both cases) without hurting performance.
-    if (type() == CSS_CALC)
-        return value().calc->computeLengthPx(conversionData);
+    if (!isTaggedPtr() && m_primitiveUnitType == CSS_CALC)
+        return m_value.calc->computeLengthPx(conversionData);
 
     double factor;
 
     switch (primitiveType()) {
         case CSS_EMS:
             factor = conversionData.emFontSize();
             break;
         case CSS_EXS:
             factor = conversionData.exFontSize();
             break;
@@ skipping 49 matching lines @@
     if (isFontRelativeLength())
         return result;
 
     return result * conversionData.zoom();
 }
 
 void CSSPrimitiveValue::accumulateLengthArray(CSSLengthArray& lengthArray, CSSLengthTypeArray& lengthTypeArray, double multiplier) const
 {
     ASSERT(lengthArray.size() == LengthUnitTypeCount);
 
-    if (type() == CSS_CALC) {
+    if (!isTaggedPtr() && m_primitiveUnitType == CSS_CALC) {
         cssCalcValue()->accumulateLengthArray(lengthArray, lengthTypeArray, multiplier);
         return;
     }
 
     LengthUnitType lengthType;
-    if (unitTypeToLengthUnitType(type(), lengthType)) {
-        lengthArray.at(lengthType) += value().num * conversionToCanonicalUnitsScaleFactor(type()) * multiplier;
+    CSSPrimitiveValue::UnitType unitType = type();
+    if (unitTypeToLengthUnitType(unitType, lengthType)) {
+        lengthArray.at(lengthType) += numValue() * conversionToCanonicalUnitsScaleFactor(unitType) * multiplier;
         lengthTypeArray.set(lengthType);
     }
 }
 
 void CSSPrimitiveValue::accumulateLengthArray(CSSLengthArray& lengthArray, double multiplier) const
 {
     CSSLengthTypeArray lengthTypeArray;
     lengthTypeArray.resize(CSSPrimitiveValue::LengthUnitTypeCount);
     for (size_t i = 0; i < CSSPrimitiveValue::LengthUnitTypeCount; ++i)
         lengthTypeArray.clear(i);
@@ skipping 59 matching lines @@
     if (isPercentage())
         return Length(getDoubleValue(), Percent);
     ASSERT(isCalculated());
     return Length(cssCalcValue()->toCalcValue(conversionData));
 }
 
 double CSSPrimitiveValue::getCalcDoubleValue() const
 {
     ASSERT(!isTaggedPtr());
     ASSERT(m_primitiveUnitType == CSS_CALC);
-    return value().calc->doubleValue();
+    return m_value.calc->doubleValue();
 }
 
 CSSPrimitiveValue::UnitType CSSPrimitiveValue::canonicalUnitTypeForCategory(UnitCategory category)
 {
     // The canonical unit type is chosen according to the way CSSPropertyParser::validUnit() chooses the default unit
     // in each category (based on unitflags).
     switch (category) {
     case UNumber:
         return CSS_NUMBER;
     case ULength:
@@ skipping 86 matching lines @@
     return CSSPrimitiveValue::CSS_UNKNOWN;
 }
 
 String CSSPrimitiveValue::getStringValue() const
 {
     switch (type()) {
     case CSS_CUSTOM_IDENT:
     case CSS_STRING:
     case CSS_ATTR:
     case CSS_URI:
-        return value().string;
+        return m_value.string;
     case CSS_VALUE_ID:
-        return valueName(value().valueID);
+        return valueName(valueIDValue());
     case CSS_PROPERTY_ID:
-        return propertyName(value().propertyID);
+        return propertyName(propertyIDValue());
     default:
         break;
     }
 
     return String();
 }
 
 static String formatNumber(double number, const char* suffix, unsigned suffixLength)
 {
 #if OS(WIN) && _MSC_VER < 1900
@@ skipping 106 matching lines @@
 {
     if (isTaggedPtr() && cssTextCache().contains(this))
         return cssTextCache().get(this);
 
     if (!isTaggedPtr() && m_hasCachedCSSText) {
         ASSERT(cssTextCache().contains(this));
         return cssTextCache().get(this);
     }
 
     String text;
-    switch (type()) {
+    CSSPrimitiveValue::UnitType unitType = type();
+    switch (unitType) {
         case CSS_UNKNOWN:
             // FIXME
             break;
         case CSS_INTEGER:
             text = String::format("%d", getIntValue());
             break;
         case CSS_NUMBER:
         case CSS_PERCENTAGE:
         case CSS_EMS:
         case CSS_EXS:
@@ skipping 14 matching lines @@
         case CSS_MS:
         case CSS_S:
         case CSS_HZ:
         case CSS_KHZ:
         case CSS_TURN:
         case CSS_FR:
         case CSS_VW:
         case CSS_VH:
         case CSS_VMIN:
         case CSS_VMAX:
-            text = formatNumber(value().num, unitTypeToString(type()));
+            text = formatNumber(numValue(), unitTypeToString(unitType));
             break;
         case CSS_CUSTOM_IDENT:
-            text = quoteCSSStringIfNeeded(value().string);
+            text = quoteCSSStringIfNeeded(m_value.string);
             break;
         case CSS_STRING: {
-            text = serializeString(value().string);
+            text = serializeString(m_value.string);
             break;
         }
         case CSS_URI:
-            text = "url(" + quoteCSSURLIfNeeded(value().string) + ")";
+            text = "url(" + quoteCSSURLIfNeeded(m_value.string) + ")";
             break;
         case CSS_VALUE_ID:
-            text = valueName(value().valueID);
+            text = valueName(valueIDValue());
             break;
         case CSS_PROPERTY_ID:
-            text = propertyName(value().propertyID);
+            text = propertyName(propertyIDValue());
             break;
         case CSS_ATTR: {
             StringBuilder result;
-            result.reserveCapacity(6 + value().string->length());
+            result.reserveCapacity(6 + m_value.string->length());
             result.appendLiteral("attr(");
-            result.append(value().string);
+            result.append(m_value.string);
             result.append(')');
 
             text = result.toString();
             break;
         }
         case CSS_COUNTER: {
             StringBuilder result;
-            String separator = value().counter->separator();
+            String separator = m_value.counter->separator();
             if (separator.isEmpty())
                 result.appendLiteral("counter(");
             else
                 result.appendLiteral("counters(");
 
-            result.append(value().counter->identifier());
+            result.append(m_value.counter->identifier());
             if (!separator.isEmpty()) {
                 result.appendLiteral(", ");
                 result.append(serializeString(separator));
             }
-            String listStyle = value().counter->listStyle();
-            bool isDefaultListStyle = value().counter->listStyleIdent() == CSSValueDecimal;
+            String listStyle = m_value.counter->listStyle();
+            bool isDefaultListStyle = m_value.counter->listStyleIdent() == CSSValueDecimal;
             if (!listStyle.isEmpty() && !isDefaultListStyle) {
                 result.appendLiteral(", ");
                 result.append(listStyle);
             }
             result.append(')');
 
             text = result.toString();
             break;
         }
         case CSS_RECT:
             text = getRectValue()->cssText();
             break;
         case CSS_QUAD:
             text = getQuadValue()->cssText();
             break;
         case CSS_RGBCOLOR: {
-            text = Color(value().rgbcolor).serializedAsCSSComponentValue();
+            text = Color(rgbcolorValue()).serializedAsCSSComponentValue();
             break;
         }
         case CSS_PAIR:
             text = getPairValue()->cssText();
             break;
         case CSS_CALC:
-            text = value().calc->cssText();
+            text = m_value.calc->cssText();
             break;
         case CSS_SHAPE:
-            text = value().shape->cssText();
+            text = m_value.shape->cssText();
             break;
         case CSS_IDENT:
         case CSS_CALC_PERCENTAGE_WITH_NUMBER:
         case CSS_CALC_PERCENTAGE_WITH_LENGTH:
         case CSS_QEM:
             break;
     }
 
     ASSERT(!cssTextCache().contains(this));
     cssTextCache().set(this, text);
     if (!isTaggedPtr())
         m_hasCachedCSSText = true;
     return text;
 }
 
 bool CSSPrimitiveValue::equals(const CSSPrimitiveValue& other) const
 {
-    if (type() != other.type())
+    if (isTaggedPtr() && other.isTaggedPtr())
+        return this == &other;
+
+    CSSPrimitiveValue::UnitType thisType = type();
+    CSSPrimitiveValue::UnitType otherType = other.type();
+
+    if (thisType != otherType)
         return false;
 
-    switch (type()) {
+    switch (thisType) {
     case CSS_UNKNOWN:
         return false;
     case CSS_NUMBER:
     case CSS_PERCENTAGE:
     case CSS_EMS:
     case CSS_EXS:
     case CSS_REMS:
     case CSS_PX:
     case CSS_CM:
     case CSS_DPPX:
     case CSS_DPI:
     case CSS_DPCM:
     case CSS_MM:
     case CSS_IN:
     case CSS_PT:
     case CSS_PC:
     case CSS_DEG:
     case CSS_RAD:
     case CSS_GRAD:
     case CSS_MS:
     case CSS_S:
     case CSS_HZ:
     case CSS_KHZ:
     case CSS_TURN:
     case CSS_VW:
     case CSS_VH:
     case CSS_VMIN:
     case CSS_VMAX:
     case CSS_FR:
-        return value().num == other.value().num;
+        return numValue() == other.numValue();
     case CSS_PROPERTY_ID:
-        return value().propertyID == other.value().propertyID;
+        return propertyIDValue() == other.propertyIDValue();
     case CSS_VALUE_ID:
-        return value().valueID == other.value().valueID;
+        return valueIDValue() == other.valueIDValue();
     case CSS_CUSTOM_IDENT:
     case CSS_STRING:
     case CSS_URI:
     case CSS_ATTR:
-        return equal(value().string, other.value().string);
+        return equal(m_value.string, other.m_value.string);
     case CSS_COUNTER:
-        return value().counter && other.value().counter && value().counter->equals(*other.value().counter);
+        return m_value.counter && other.m_value.counter && m_value.counter->equals(*other.m_value.counter);
     case CSS_RECT:
-        return value().rect && other.value().rect && value().rect->equals(*other.value().rect);
+        return m_value.pair && other.m_value.pair && m_value.pair->equals(*other.m_value.pair);
     case CSS_QUAD:
-        return value().quad && other.value().quad && value().quad->equals(*other.value().quad);
+        return m_value.quad && other.m_value.quad && m_value.quad->equals(*other.m_value.quad);
     case CSS_RGBCOLOR:
-        return value().rgbcolor == other.value().rgbcolor;
+        return rgbcolorValue() == other.rgbcolorValue();
     case CSS_PAIR:
-        return value().pair && other.value().pair && value().pair->equals(*other.value().pair);
+        return m_value.pair && other.m_value.pair && m_value.pair->equals(*other.m_value.pair);
     case CSS_CALC:
-        return value().calc && other.value().calc && value().calc->equals(*other.value().calc);
+        return m_value.calc && other.m_value.calc && m_value.calc->equals(*other.m_value.calc);
     case CSS_SHAPE:
-        return value().shape && other.value().shape && value().shape->equals(*other.value().shape);
+        return m_value.shape && other.m_value.shape && m_value.shape->equals(*other.m_value.shape);
     case CSS_IDENT:
     case CSS_INTEGER:
     case CSS_CHS:
     case CSS_CALC_PERCENTAGE_WITH_NUMBER:
     case CSS_CALC_PERCENTAGE_WITH_LENGTH:
     case CSS_QEM:
         return false;
     }
     return false;
 }
 
 DEFINE_TRACE_AFTER_DISPATCH(CSSPrimitiveValue)
 {
 #if ENABLE(OILPAN)
-    switch (type()) {
-    case CSS_COUNTER:
-        visitor->trace(value().counter);
-        break;
-    case CSS_RECT:
-        visitor->trace(value().rect);
-        break;
-    case CSS_QUAD:
-        visitor->trace(value().quad);
-        break;
-    case CSS_PAIR:
-        visitor->trace(value().pair);
-        break;
-    case CSS_CALC:
-        visitor->trace(value().calc);
-        break;
-    case CSS_SHAPE:
-        visitor->trace(value().shape);
-        break;
-    default:
-        break;
+    if (!isTaggedPtr()) {
+        switch (m_type) {
+        case CSS_COUNTER:
+            visitor->trace(m_value.counter);
+            break;
+        case CSS_RECT:
+            visitor->trace(m_value.pair);
+            break;
+        case CSS_QUAD:
+            visitor->trace(m_value.quad);
+            break;
+        case CSS_PAIR:
+            visitor->trace(m_value.pair);
+            break;
+        case CSS_CALC:
+            visitor->trace(m_value.calc);
+            break;
+        case CSS_SHAPE:
+            visitor->trace(m_value.shape);
+            break;
+        default:
+            break;
+        }
     }
 #endif
     CSSValue::traceAfterDispatch(visitor);
 }
 
 } // namespace blink