CSSValue Immediates: Add move operators to CSSPrimitiveValue

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 141 matching lines @@
     case CSSValueWebkitText:
     case CSSValueWebkitLink:
     case CSSValueWebkitActivelink:
     case CSSValueCurrentcolor:
         return true;
     default:
         return false;
     }
 }
 
-typedef HashMap<const CSSPrimitiveValue*, String> CSSTextCache;
+typedef HashMap<const CSSPrimitiveValue::CSSLargePrimitiveValue*, String> CSSTextCache;
 static CSSTextCache& cssTextCache()
 {
     AtomicallyInitializedStaticReference(ThreadSpecific<CSSTextCache>, cache, new ThreadSpecific<CSSTextCache>());
     return *cache;
 }
 
 CSSPrimitiveValue::UnitType CSSPrimitiveValue::primitiveType() const
 {
-    if (m_primitiveUnitType == CSS_PROPERTY_ID || m_primitiveUnitType == CSS_VALUE_ID)
+    if (type() == CSS_PROPERTY_ID || type() == CSS_VALUE_ID)
         return CSS_IDENT;
 
-    if (m_primitiveUnitType != CSS_CALC)
-        return static_cast<UnitType>(m_primitiveUnitType);
+    if (type() != CSS_CALC)
+        return type();
 
-    switch (m_value.calc->category()) {
+    switch (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 22 matching lines @@
     if (valueID < 0)
         return nullAtom;
 
     static AtomicString* keywordStrings = new AtomicString[numCSSValueKeywords]; // Leaked intentionally.
     AtomicString& keywordString = keywordStrings[valueID];
     if (keywordString.isNull())
         keywordString = getValueName(valueID);
     return keywordString;
 }
 
-CSSPrimitiveValue::CSSPrimitiveValue(CSSValueID valueID)
+CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(CSSValueID valueID)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     m_value.valueID = valueID;
 }
 
-CSSPrimitiveValue::CSSPrimitiveValue(CSSPropertyID propertyID)
+CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(CSSPropertyID propertyID)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_PROPERTY_ID;
     m_value.propertyID = propertyID;
 }
 
-CSSPrimitiveValue::CSSPrimitiveValue(double num, UnitType type)
+CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(double num, UnitType type)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = type;
     ASSERT(std::isfinite(num));
     m_value.num = num;
 }
 
-CSSPrimitiveValue::CSSPrimitiveValue(const String& str, UnitType type)
+CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(double num, UnitType type, bool isQuirkValue)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = type;
+    m_isQuirkValue = true;
+    ASSERT(std::isfinite(num));
+    m_value.num = num;
+}
+
+CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(const String& str, UnitType type)
+    : CSSValueObject(PrimitiveClass)
+{
+    m_primitiveUnitType = type;
     m_value.string = str.impl();
     if (m_value.string)
         m_value.string->ref();
 }
 
-CSSPrimitiveValue::CSSPrimitiveValue(const LengthSize& lengthSize, const ComputedStyle& style)
+CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(const LengthSize& lengthSize, const ComputedStyle& style)
     : CSSValueObject(PrimitiveClass)
 {
     init(lengthSize, style);
 }
 
-CSSPrimitiveValue::CSSPrimitiveValue(RGBA32 color)
+CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(RGBA32 color)
     : CSSValueObject(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_RGBCOLOR;
     m_value.rgbcolor = color;
 }
 
-CSSPrimitiveValue::CSSPrimitiveValue(const Length& length, float zoom)
+CSSPrimitiveValue::CSSLargePrimitiveValue::CSSLargePrimitiveValue(const Length& length, float zoom)
     : CSSValueObject(PrimitiveClass)
 {
     switch (length.type()) {
     case Auto:
         m_primitiveUnitType = CSS_VALUE_ID;
         m_value.valueID = CSSValueAuto;
         break;
     case Intrinsic:
         m_primitiveUnitType = CSS_VALUE_ID;
         m_value.valueID = CSSValueIntrinsic;
@@ skipping 51 matching lines @@
         break;
     }
     case DeviceWidth:
     case DeviceHeight:
     case MaxSizeNone:
         ASSERT_NOT_REACHED();
         break;
     }
 }
 
-void CSSPrimitiveValue::init(const LengthSize& lengthSize, const ComputedStyle& style)
+void CSSPrimitiveValue::CSSLargePrimitiveValue::init(const LengthSize& lengthSize, const ComputedStyle& style)
 {
     m_primitiveUnitType = CSS_PAIR;
     m_hasCachedCSSText = false;
     m_value.pair = Pair::create(create(lengthSize.width(), style.effectiveZoom()), create(lengthSize.height(), style.effectiveZoom()), Pair::KeepIdenticalValues).leakRef();
 }
 
-void CSSPrimitiveValue::init(PassRefPtrWillBeRawPtr<Counter> c)
+void CSSPrimitiveValue::CSSLargePrimitiveValue::init(PassRefPtrWillBeRawPtr<Counter> c)
 {
     m_primitiveUnitType = CSS_COUNTER;
     m_hasCachedCSSText = false;
     m_value.counter = c.leakRef();
 }
 
-void CSSPrimitiveValue::init(PassRefPtrWillBeRawPtr<Rect> r)
+void CSSPrimitiveValue::CSSLargePrimitiveValue::init(PassRefPtrWillBeRawPtr<Rect> r)
 {
     m_primitiveUnitType = CSS_RECT;
     m_hasCachedCSSText = false;
     m_value.rect = r.leakRef();
 }
 
-void CSSPrimitiveValue::init(PassRefPtrWillBeRawPtr<Quad> quad)
+void CSSPrimitiveValue::CSSLargePrimitiveValue::init(PassRefPtrWillBeRawPtr<Quad> quad)
 {
     m_primitiveUnitType = CSS_QUAD;
     m_hasCachedCSSText = false;
     m_value.quad = quad.leakRef();
 }
 
-void CSSPrimitiveValue::init(PassRefPtrWillBeRawPtr<Pair> p)
+void CSSPrimitiveValue::CSSLargePrimitiveValue::init(PassRefPtrWillBeRawPtr<Pair> p)
 {
     m_primitiveUnitType = CSS_PAIR;
     m_hasCachedCSSText = false;
     m_value.pair = p.leakRef();
 }
 
-void CSSPrimitiveValue::init(PassRefPtrWillBeRawPtr<CSSCalcValue> c)
+void CSSPrimitiveValue::CSSLargePrimitiveValue::init(PassRefPtrWillBeRawPtr<CSSCalcValue> c)
 {
     m_primitiveUnitType = CSS_CALC;
     m_hasCachedCSSText = false;
     m_value.calc = c.leakRef();
 }
 
-void CSSPrimitiveValue::init(PassRefPtrWillBeRawPtr<CSSBasicShape> shape)
+void CSSPrimitiveValue::CSSLargePrimitiveValue::init(PassRefPtrWillBeRawPtr<CSSBasicShape> shape)
 {
     m_primitiveUnitType = CSS_SHAPE;
     m_hasCachedCSSText = false;
     m_value.shape = shape.leakRef();
 }
 
-CSSPrimitiveValue::~CSSPrimitiveValue()
+CSSPrimitiveValue::CSSLargePrimitiveValue::~CSSLargePrimitiveValue()
 {
     cleanup();
 }
 
-void CSSPrimitiveValue::cleanup()
+void CSSPrimitiveValue::CSSLargePrimitiveValue::cleanup()
 {
-    switch (static_cast<UnitType>(m_primitiveUnitType)) {
+    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 71 matching lines @@
     case CSS_VALUE_ID:
         break;
     }
     m_primitiveUnitType = 0;
     if (m_hasCachedCSSText) {
         cssTextCache().remove(this);
         m_hasCachedCSSText = false;
     }
 }
 
-double CSSPrimitiveValue::computeSeconds()
+double CSSPrimitiveValue::computeSeconds() const
 {
     ASSERT(isTime() || (isCalculated() && cssCalcValue()->category() == CalcTime));
-    UnitType currentType = isCalculated() ? cssCalcValue()->expressionNode()->primitiveType() : static_cast<UnitType>(m_primitiveUnitType);
+    UnitType currentType = isCalculated() ? cssCalcValue()->expressionNode()->primitiveType() : type();
     if (currentType == CSS_S)
         return getDoubleValue();
     if (currentType == CSS_MS)
         return getDoubleValue() / 1000;
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 double CSSPrimitiveValue::computeDegrees() const
 {
     ASSERT(isAngle() || (isCalculated() && cssCalcValue()->category() == CalcAngle));
-    UnitType currentType = isCalculated() ? cssCalcValue()->expressionNode()->primitiveType() : static_cast<UnitType>(m_primitiveUnitType);
+    UnitType currentType = isCalculated() ? cssCalcValue()->expressionNode()->primitiveType() : type();
     switch (currentType) {
     case CSS_DEG:
         return getDoubleValue();
     case CSS_RAD:
         return rad2deg(getDoubleValue());
     case CSS_GRAD:
         return grad2deg(getDoubleValue());
     case CSS_TURN:
         return turn2deg(getDoubleValue());
     default:
         ASSERT_NOT_REACHED();
         return 0;
     }
 }
 
-template<> int CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData)
+template<> int CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData) const
 {
     return roundForImpreciseConversion<int>(computeLengthDouble(conversionData));
 }
 
-template<> unsigned CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData)
+template<> unsigned CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData) const
 {
     return roundForImpreciseConversion<unsigned>(computeLengthDouble(conversionData));
 }
 
-template<> Length CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData)
+template<> Length CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData) const
 {
     return Length(clampToCSSLengthRange(computeLengthDouble(conversionData)), Fixed);
 }
 
-template<> short CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData)
+template<> short CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData) const
 {
     return roundForImpreciseConversion<short>(computeLengthDouble(conversionData));
 }
 
-template<> unsigned short CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData)
+template<> unsigned short CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData) const
 {
     return roundForImpreciseConversion<unsigned short>(computeLengthDouble(conversionData));
 }
 
-template<> float CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData)
+template<> float CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData) const
 {
     return static_cast<float>(computeLengthDouble(conversionData));
 }
 
-template<> double CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData)
+template<> double CSSPrimitiveValue::computeLength(const CSSToLengthConversionData& conversionData) const
 {
     return computeLengthDouble(conversionData);
 }
 
-double CSSPrimitiveValue::computeLengthDouble(const CSSToLengthConversionData& conversionData)
+double CSSPrimitiveValue::computeLengthDouble(const CSSToLengthConversionData& conversionData) const
 {
     // 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 (m_primitiveUnitType == CSS_CALC)
-        return m_value.calc->computeLengthPx(conversionData);
+    if (type() == CSS_CALC)
+        return 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 (m_primitiveUnitType == CSS_CALC) {
+    if (type() == CSS_CALC) {
         cssCalcValue()->accumulateLengthArray(lengthArray, lengthTypeArray, multiplier);
         return;
     }
 
     LengthUnitType lengthType;
-    if (unitTypeToLengthUnitType(static_cast<UnitType>(m_primitiveUnitType), lengthType)) {
-        lengthArray.at(lengthType) += m_value.num * conversionToCanonicalUnitsScaleFactor(static_cast<UnitType>(m_primitiveUnitType)) * multiplier;
+    if (unitTypeToLengthUnitType(type(), lengthType)) {
+        lengthArray.at(lengthType) += value().num * conversionToCanonicalUnitsScaleFactor(type()) * 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 45 matching lines @@
     case CSS_KHZ:
         factor = 1000;
         break;
     default:
         break;
     }
 
     return factor;
 }
 
-Length CSSPrimitiveValue::convertToLength(const CSSToLengthConversionData& conversionData)
+Length CSSPrimitiveValue::convertToLength(const CSSToLengthConversionData& conversionData) const
 {
     if (isLength())
         return computeLength<Length>(conversionData);
     if (isPercentage())
         return Length(getDoubleValue(), Percent);
     ASSERT(isCalculated());
     return Length(cssCalcValue()->toCalcValue(conversionData));
 }
 
 double CSSPrimitiveValue::getDoubleValue() const
 {
-    return m_primitiveUnitType != CSS_CALC ? m_value.num : m_value.calc->doubleValue();
+    return type() != CSS_CALC ? value().num : 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 81 matching lines @@
         return CSSPrimitiveValue::CSS_VMAX;
     case LengthUnitTypeCount:
         break;
     }
     ASSERT_NOT_REACHED();
     return CSSPrimitiveValue::CSS_UNKNOWN;
 }
 
 String CSSPrimitiveValue::getStringValue() const
 {
-    switch (m_primitiveUnitType) {
+    switch (type()) {
     case CSS_CUSTOM_IDENT:
     case CSS_STRING:
     case CSS_ATTR:
     case CSS_URI:
-        return m_value.string;
+        return value().string;
     case CSS_VALUE_ID:
-        return valueName(m_value.valueID);
+        return valueName(value().valueID);
     case CSS_PROPERTY_ID:
-        return propertyName(m_value.propertyID);
+        return propertyName(value().propertyID);
     default:
         break;
     }
 
     return String();
 }
 
 static String formatNumber(double number, const char* suffix, unsigned suffixLength)
 {
 #if OS(WIN) && _MSC_VER < 1900
@@ skipping 97 matching lines @@
     case CSS_CALC_PERCENTAGE_WITH_LENGTH:
     case CSS_QEM:
         break;
     };
     ASSERT_NOT_REACHED();
     return "";
 }
 
 String CSSPrimitiveValue::customCSSText() const
 {
-    if (m_hasCachedCSSText) {
-        ASSERT(cssTextCache().contains(this));
-        return cssTextCache().get(this);
+    if (m_rawValue->m_hasCachedCSSText) {
+        ASSERT(cssTextCache().contains(m_rawValue));
+        return cssTextCache().get(m_rawValue);
     }
 
     String text;
-    switch (m_primitiveUnitType) {
+    switch (type()) {
         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(m_value.num, unitTypeToString((UnitType)m_primitiveUnitType));
+            text = formatNumber(value().num, unitTypeToString((UnitType)type()));
             break;
         case CSS_CUSTOM_IDENT:
-            text = quoteCSSStringIfNeeded(m_value.string);
+            text = quoteCSSStringIfNeeded(value().string);
             break;
         case CSS_STRING: {
-            text = serializeString(m_value.string);
+            text = serializeString(value().string);
             break;
         }
         case CSS_URI:
-            text = "url(" + quoteCSSURLIfNeeded(m_value.string) + ")";
+            text = "url(" + quoteCSSURLIfNeeded(value().string) + ")";
             break;
         case CSS_VALUE_ID:
-            text = valueName(m_value.valueID);
+            text = valueName(value().valueID);
             break;
         case CSS_PROPERTY_ID:
-            text = propertyName(m_value.propertyID);
+            text = propertyName(value().propertyID);
             break;
         case CSS_ATTR: {
             StringBuilder result;
-            result.reserveCapacity(6 + m_value.string->length());
+            result.reserveCapacity(6 + value().string->length());
             result.appendLiteral("attr(");
-            result.append(m_value.string);
+            result.append(value().string);
             result.append(')');
 
             text = result.toString();
             break;
         }
         case CSS_COUNTER: {
             StringBuilder result;
-            String separator = m_value.counter->separator();
+            String separator = value().counter->separator();
             if (separator.isEmpty())
                 result.appendLiteral("counter(");
             else
                 result.appendLiteral("counters(");
 
-            result.append(m_value.counter->identifier());
+            result.append(value().counter->identifier());
             if (!separator.isEmpty()) {
                 result.appendLiteral(", ");
                 result.append(serializeString(separator));
             }
-            String listStyle = m_value.counter->listStyle();
-            bool isDefaultListStyle = m_value.counter->listStyleIdent() == CSSValueDecimal;
+            String listStyle = value().counter->listStyle();
+            bool isDefaultListStyle = 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(m_value.rgbcolor).serializedAsCSSComponentValue();
+            text = Color(value().rgbcolor).serializedAsCSSComponentValue();
             break;
         }
         case CSS_PAIR:
             text = getPairValue()->cssText();
             break;
         case CSS_CALC:
-            text = m_value.calc->cssText();
+            text = value().calc->cssText();
             break;
         case CSS_SHAPE:
-            text = m_value.shape->cssText();
+            text = value().shape->cssText();
+            break;
+        default:
             break;
     }
 
-    ASSERT(!cssTextCache().contains(this));
-    cssTextCache().set(this, text);
-    m_hasCachedCSSText = true;
+    ASSERT(!cssTextCache().contains(m_rawValue));
+    cssTextCache().set(m_rawValue, text);
+    m_rawValue->m_hasCachedCSSText = true;
     return text;
 }
 
-bool CSSPrimitiveValue::equals(const CSSPrimitiveValue& other) const
+bool CSSPrimitiveValue::equals(const CSSPrimitiveValue other) const
 {
-    if (m_primitiveUnitType != other.m_primitiveUnitType)
+    if (type() != other.type())
         return false;
 
-    switch (m_primitiveUnitType) {
+    switch (type()) {
     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 m_value.num == other.m_value.num;
+        return value().num == other.value().num;
     case CSS_PROPERTY_ID:
-        return m_value.propertyID == other.m_value.propertyID;
+        return value().propertyID == other.value().propertyID;
     case CSS_VALUE_ID:
-        return m_value.valueID == other.m_value.valueID;
+        return value().valueID == other.value().valueID;
     case CSS_CUSTOM_IDENT:
     case CSS_STRING:
     case CSS_URI:
     case CSS_ATTR:
-        return equal(m_value.string, other.m_value.string);
+        return equal(value().string, other.value().string);
     case CSS_COUNTER:
-        return m_value.counter && other.m_value.counter && m_value.counter->equals(*other.m_value.counter);
+        return value().counter && other.value().counter && value().counter->equals(*other.value().counter);
     case CSS_RECT:
-        return m_value.rect && other.m_value.rect && m_value.rect->equals(*other.m_value.rect);
+        return value().rect && other.value().rect && value().rect->equals(*other.value().rect);
     case CSS_QUAD:
-        return m_value.quad && other.m_value.quad && m_value.quad->equals(*other.m_value.quad);
+        return value().quad && other.value().quad && value().quad->equals(*other.value().quad);
     case CSS_RGBCOLOR:
-        return m_value.rgbcolor == other.m_value.rgbcolor;
+        return value().rgbcolor == other.value().rgbcolor;
     case CSS_PAIR:
-        return m_value.pair && other.m_value.pair && m_value.pair->equals(*other.m_value.pair);
+        return value().pair && other.value().pair && value().pair->equals(*other.value().pair);
     case CSS_CALC:
-        return m_value.calc && other.m_value.calc && m_value.calc->equals(*other.m_value.calc);
+        return value().calc && other.value().calc && value().calc->equals(*other.value().calc);
     case CSS_SHAPE:
-        return m_value.shape && other.m_value.shape && m_value.shape->equals(*other.m_value.shape);
+        return value().shape && other.value().shape && value().shape->equals(*other.value().shape);
+    default:
+        break;
     }
     return false;
 }
 
-DEFINE_TRACE_AFTER_DISPATCH(CSSPrimitiveValue)
+DEFINE_TRACE_AFTER_DISPATCH(CSSPrimitiveValue::CSSLargePrimitiveValue)
 {
 #if ENABLE(OILPAN)
     switch (m_primitiveUnitType) {
     case CSS_COUNTER:
         visitor->trace(m_value.counter);
         break;
     case CSS_RECT:
         visitor->trace(m_value.rect);
         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
     CSSValueObject::traceAfterDispatch(visitor);
 }
 
 } // namespace blink