diff -r 000000000000 -r 4f2f89ce4247 WebCore/css/CSSPrimitiveValue.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/WebCore/css/CSSPrimitiveValue.cpp	Fri Sep 17 09:02:29 2010 +0300
@@ -0,0 +1,967 @@
+/*
+ * (C) 1999-2003 Lars Knoll (knoll@kde.org)
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008 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,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public License
+ * along with this library; see the file COPYING.LIB.  If not, write to
+ * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1301, USA.
+ */
+
+#include "config.h"
+#include "CSSPrimitiveValue.h"
+
+#include "CSSHelper.h"
+#include "CSSParser.h"
+#include "CSSPropertyNames.h"
+#include "CSSStyleSheet.h"
+#include "CSSValueKeywords.h"
+#include "Color.h"
+#include "Counter.h"
+#include "ExceptionCode.h"
+#include "Node.h"
+#include "Pair.h"
+#include "RGBColor.h"
+#include "Rect.h"
+#include "RenderStyle.h"
+#include <wtf/ASCIICType.h>
+#include <wtf/StdLibExtras.h>
+
+#if ENABLE(DASHBOARD_SUPPORT)
+#include "DashboardRegion.h"
+#endif
+
+using namespace WTF;
+
+namespace WebCore {
+
+typedef HashMap<const CSSPrimitiveValue*, String> CSSTextCache;
+static CSSTextCache& cssTextCache()
+{
+    DEFINE_STATIC_LOCAL(CSSTextCache, cache, ());
+    return cache;
+}
+
+// A more stylish solution than sharing would be to turn CSSPrimitiveValue (or CSSValues in general) into non-virtual,
+// non-refcounted simple type with value semantics. In practice these sharing tricks get similar memory benefits 
+// with less need for refactoring.
+
+inline PassRefPtr<CSSPrimitiveValue> CSSPrimitiveValue::createUncachedIdentifier(int identifier)
+{
+    return adoptRef(new CSSPrimitiveValue(identifier));
+}
+
+inline PassRefPtr<CSSPrimitiveValue> CSSPrimitiveValue::createUncachedColor(unsigned rgbValue)
+{
+    return adoptRef(new CSSPrimitiveValue(rgbValue));
+}
+
+inline PassRefPtr<CSSPrimitiveValue> CSSPrimitiveValue::createUncached(double value, UnitTypes type)
+{
+    return adoptRef(new CSSPrimitiveValue(value, type));
+}
+
+PassRefPtr<CSSPrimitiveValue> CSSPrimitiveValue::createIdentifier(int ident)
+{
+    static RefPtr<CSSPrimitiveValue>* identValueCache = new RefPtr<CSSPrimitiveValue>[numCSSValueKeywords];
+    if (ident >= 0 && ident < numCSSValueKeywords) {
+        RefPtr<CSSPrimitiveValue> primitiveValue = identValueCache[ident];
+        if (!primitiveValue) {
+            primitiveValue = createUncachedIdentifier(ident);
+            identValueCache[ident] = primitiveValue;
+        }
+        return primitiveValue.release();
+    } 
+    return createUncachedIdentifier(ident);
+}
+
+PassRefPtr<CSSPrimitiveValue> CSSPrimitiveValue::createColor(unsigned rgbValue)
+{
+    typedef HashMap<unsigned, RefPtr<CSSPrimitiveValue> > ColorValueCache;
+    static ColorValueCache* colorValueCache = new ColorValueCache;
+    // These are the empty and deleted values of the hash table.
+    if (rgbValue == Color::transparent) {
+        static CSSPrimitiveValue* colorTransparent = createUncachedColor(Color::transparent).releaseRef();
+        return colorTransparent;
+    }
+    if (rgbValue == Color::white) {
+        static CSSPrimitiveValue* colorWhite = createUncachedColor(Color::white).releaseRef();
+        return colorWhite;
+    }
+    RefPtr<CSSPrimitiveValue> primitiveValue = colorValueCache->get(rgbValue);
+    if (primitiveValue)
+        return primitiveValue.release();
+    primitiveValue = createUncachedColor(rgbValue);
+    // Just wipe out the cache and start rebuilding when it gets too big.
+    const int maxColorCacheSize = 512;
+    if (colorValueCache->size() >= maxColorCacheSize)
+        colorValueCache->clear();
+    colorValueCache->add(rgbValue, primitiveValue);
+    
+    return primitiveValue.release();
+}
+
+PassRefPtr<CSSPrimitiveValue> CSSPrimitiveValue::create(double value, UnitTypes type)
+{
+    // Small integers are very common. Try to share them.
+    const int cachedIntegerCount = 128;
+    // Other common primitive types have UnitTypes smaller than this.
+    const int maxCachedUnitType = CSS_PX;
+    typedef RefPtr<CSSPrimitiveValue>(* IntegerValueCache)[maxCachedUnitType + 1];
+    static IntegerValueCache integerValueCache = new RefPtr<CSSPrimitiveValue>[cachedIntegerCount][maxCachedUnitType + 1];
+    if (type <= maxCachedUnitType && value >= 0 && value < cachedIntegerCount) {
+        int intValue = static_cast<int>(value);
+        if (value == intValue) {
+            RefPtr<CSSPrimitiveValue> primitiveValue = integerValueCache[intValue][type];
+            if (!primitiveValue) {
+                primitiveValue = createUncached(value, type);
+                integerValueCache[intValue][type] = primitiveValue;
+            }
+            return primitiveValue.release();
+        }
+    }
+
+    return createUncached(value, type);
+}
+
+PassRefPtr<CSSPrimitiveValue> CSSPrimitiveValue::create(const String& value, UnitTypes type)
+{
+    return adoptRef(new CSSPrimitiveValue(value, type));
+}
+
+static const AtomicString& valueOrPropertyName(int valueOrPropertyID)
+{
+    ASSERT_ARG(valueOrPropertyID, valueOrPropertyID >= 0);
+    ASSERT_ARG(valueOrPropertyID, valueOrPropertyID < numCSSValueKeywords || (valueOrPropertyID >= firstCSSProperty && valueOrPropertyID < firstCSSProperty + numCSSProperties));
+
+    if (valueOrPropertyID < 0)
+        return nullAtom;
+
+    if (valueOrPropertyID < numCSSValueKeywords) {
+        static AtomicString* cssValueKeywordStrings[numCSSValueKeywords];
+        if (!cssValueKeywordStrings[valueOrPropertyID])
+            cssValueKeywordStrings[valueOrPropertyID] = new AtomicString(getValueName(valueOrPropertyID));
+        return *cssValueKeywordStrings[valueOrPropertyID];
+    }
+
+    if (valueOrPropertyID >= firstCSSProperty && valueOrPropertyID < firstCSSProperty + numCSSProperties) {
+        static AtomicString* cssPropertyStrings[numCSSProperties];
+        int propertyIndex = valueOrPropertyID - firstCSSProperty;
+        if (!cssPropertyStrings[propertyIndex])
+            cssPropertyStrings[propertyIndex] = new AtomicString(getPropertyName(static_cast<CSSPropertyID>(valueOrPropertyID)));
+        return *cssPropertyStrings[propertyIndex];
+    }
+
+    return nullAtom;
+}
+
+CSSPrimitiveValue::CSSPrimitiveValue()
+    : m_type(0)
+    , m_hasCachedCSSText(false)
+{
+}
+
+CSSPrimitiveValue::CSSPrimitiveValue(int ident)
+    : m_type(CSS_IDENT)
+    , m_hasCachedCSSText(false)
+{
+    m_value.ident = ident;
+}
+
+CSSPrimitiveValue::CSSPrimitiveValue(double num, UnitTypes type)
+    : m_type(type)
+    , m_hasCachedCSSText(false)
+{
+    m_value.num = num;
+}
+
+CSSPrimitiveValue::CSSPrimitiveValue(const String& str, UnitTypes type)
+    : m_type(type)
+    , m_hasCachedCSSText(false)
+{
+    if ((m_value.string = str.impl()))
+        m_value.string->ref();
+}
+
+CSSPrimitiveValue::CSSPrimitiveValue(RGBA32 color)
+    : m_type(CSS_RGBCOLOR)
+    , m_hasCachedCSSText(false)
+{
+    m_value.rgbcolor = color;
+}
+
+CSSPrimitiveValue::CSSPrimitiveValue(const Length& length)
+    : m_hasCachedCSSText(false)
+{
+    switch (length.type()) {
+        case Auto:
+            m_type = CSS_IDENT;
+            m_value.ident = CSSValueAuto;
+            break;
+        case WebCore::Fixed:
+            m_type = CSS_PX;
+            m_value.num = length.value();
+            break;
+        case Intrinsic:
+            m_type = CSS_IDENT;
+            m_value.ident = CSSValueIntrinsic;
+            break;
+        case MinIntrinsic:
+            m_type = CSS_IDENT;
+            m_value.ident = CSSValueMinIntrinsic;
+            break;
+        case Percent:
+            m_type = CSS_PERCENTAGE;
+            m_value.num = length.percent();
+            break;
+        case Relative:
+        case Static:
+            ASSERT_NOT_REACHED();
+            break;
+    }
+}
+
+void CSSPrimitiveValue::init(PassRefPtr<Counter> c)
+{
+    m_type = CSS_COUNTER;
+    m_hasCachedCSSText = false;
+    m_value.counter = c.releaseRef();
+}
+
+void CSSPrimitiveValue::init(PassRefPtr<Rect> r)
+{
+    m_type = CSS_RECT;
+    m_hasCachedCSSText = false;
+    m_value.rect = r.releaseRef();
+}
+
+#if ENABLE(DASHBOARD_SUPPORT)
+void CSSPrimitiveValue::init(PassRefPtr<DashboardRegion> r)
+{
+    m_type = CSS_DASHBOARD_REGION;
+    m_hasCachedCSSText = false;
+    m_value.region = r.releaseRef();
+}
+#endif
+
+void CSSPrimitiveValue::init(PassRefPtr<Pair> p)
+{
+    m_type = CSS_PAIR;
+    m_hasCachedCSSText = false;
+    m_value.pair = p.releaseRef();
+}
+
+CSSPrimitiveValue::~CSSPrimitiveValue()
+{
+    cleanup();
+}
+
+void CSSPrimitiveValue::cleanup()
+{
+    switch (m_type) {
+        case CSS_STRING:
+        case CSS_URI:
+        case CSS_ATTR:
+        case CSS_PARSER_VARIABLE_FUNCTION_SYNTAX:
+        case CSS_PARSER_HEXCOLOR:
+            if (m_value.string)
+                m_value.string->deref();
+            break;
+        case CSS_COUNTER:
+            m_value.counter->deref();
+            break;
+        case CSS_RECT:
+            m_value.rect->deref();
+            break;
+        case CSS_PAIR:
+            m_value.pair->deref();
+            break;
+#if ENABLE(DASHBOARD_SUPPORT)
+        case CSS_DASHBOARD_REGION:
+            if (m_value.region)
+                m_value.region->deref();
+            break;
+#endif
+        default:
+            break;
+    }
+
+    m_type = 0;
+    if (m_hasCachedCSSText) {
+        cssTextCache().remove(this);
+        m_hasCachedCSSText = false;
+    }
+}
+
+int CSSPrimitiveValue::computeLengthInt(RenderStyle* style, RenderStyle* rootStyle)
+{
+    double result = computeLengthDouble(style, rootStyle);
+
+    // This conversion is imprecise, often resulting in values of, e.g., 44.99998.  We
+    // need to go ahead and round if we're really close to the next integer value.
+    result += result < 0 ? -0.01 : +0.01;
+
+    if (result > INT_MAX || result < INT_MIN)
+        return 0;
+    return static_cast<int>(result);
+}
+
+int CSSPrimitiveValue::computeLengthInt(RenderStyle* style, RenderStyle* rootStyle, double multiplier)
+{
+    double result = computeLengthDouble(style, rootStyle, multiplier);
+
+    // This conversion is imprecise, often resulting in values of, e.g., 44.99998.  We
+    // need to go ahead and round if we're really close to the next integer value.
+    result += result < 0 ? -0.01 : +0.01;
+
+    if (result > INT_MAX || result < INT_MIN)
+        return 0;
+    return static_cast<int>(result);
+}
+
+const int intMaxForLength = 0x7ffffff; // max value for a 28-bit int
+const int intMinForLength = (-0x7ffffff - 1); // min value for a 28-bit int
+
+// Lengths expect an int that is only 28-bits, so we have to check for a different overflow.
+int CSSPrimitiveValue::computeLengthIntForLength(RenderStyle* style, RenderStyle* rootStyle)
+{
+    double result = computeLengthDouble(style, rootStyle);
+
+    // This conversion is imprecise, often resulting in values of, e.g., 44.99998.  We
+    // need to go ahead and round if we're really close to the next integer value.
+    result += result < 0 ? -0.01 : +0.01;
+
+    if (result > intMaxForLength || result < intMinForLength)
+        return 0;
+    return static_cast<int>(result);
+}
+
+// Lengths expect an int that is only 28-bits, so we have to check for a different overflow.
+int CSSPrimitiveValue::computeLengthIntForLength(RenderStyle* style, RenderStyle* rootStyle, double multiplier)
+{
+    double result = computeLengthDouble(style, rootStyle, multiplier);
+
+    // This conversion is imprecise, often resulting in values of, e.g., 44.99998.  We
+    // need to go ahead and round if we're really close to the next integer value.
+    result += result < 0 ? -0.01 : +0.01;
+
+    if (result > intMaxForLength || result < intMinForLength)
+        return 0;
+    return static_cast<int>(result);
+}
+
+short CSSPrimitiveValue::computeLengthShort(RenderStyle* style, RenderStyle* rootStyle)
+{
+    double result = computeLengthDouble(style, rootStyle);
+
+    // This conversion is imprecise, often resulting in values of, e.g., 44.99998.  We
+    // need to go ahead and round if we're really close to the next integer value.
+    result += result < 0 ? -0.01 : +0.01;
+
+    if (result > SHRT_MAX || result < SHRT_MIN)
+        return 0;
+    return static_cast<short>(result);
+}
+
+short CSSPrimitiveValue::computeLengthShort(RenderStyle* style, RenderStyle* rootStyle, double multiplier)
+{
+    double result = computeLengthDouble(style, rootStyle, multiplier);
+
+    // This conversion is imprecise, often resulting in values of, e.g., 44.99998.  We
+    // need to go ahead and round if we're really close to the next integer value.
+    result += result < 0 ? -0.01 : +0.01;
+
+    if (result > SHRT_MAX || result < SHRT_MIN)
+        return 0;
+    return static_cast<short>(result);
+}
+
+float CSSPrimitiveValue::computeLengthFloat(RenderStyle* style, RenderStyle* rootStyle, bool computingFontSize)
+{
+    return static_cast<float>(computeLengthDouble(style, rootStyle, 1.0, computingFontSize));
+}
+
+float CSSPrimitiveValue::computeLengthFloat(RenderStyle* style, RenderStyle* rootStyle, double multiplier, bool computingFontSize)
+{
+    return static_cast<float>(computeLengthDouble(style, rootStyle, multiplier, computingFontSize));
+}
+
+double CSSPrimitiveValue::computeLengthDouble(RenderStyle* style, RenderStyle* rootStyle, double multiplier, bool computingFontSize)
+{
+    unsigned short type = primitiveType();
+
+    // We do not apply the zoom factor when we are computing the value of the font-size property.  The zooming
+    // for font sizes is much more complicated, since we have to worry about enforcing the minimum font size preference
+    // as well as enforcing the implicit "smart minimum."  In addition the CSS property text-size-adjust is used to
+    // prevent text from zooming at all.  Therefore we will not apply the zoom here if we are computing font-size.
+    bool applyZoomMultiplier = !computingFontSize;
+
+    double factor = 1.0;
+    switch (type) {
+        case CSS_EMS:
+            applyZoomMultiplier = false;
+            factor = computingFontSize ? style->fontDescription().specifiedSize() : style->fontDescription().computedSize();
+            break;
+        case CSS_EXS:
+            // FIXME: We have a bug right now where the zoom will be applied twice to EX units.
+            // We really need to compute EX using fontMetrics for the original specifiedSize and not use
+            // our actual constructed rendering font.
+            applyZoomMultiplier = false;
+            factor = style->font().xHeight();
+            break;
+        case CSS_REMS:
+            applyZoomMultiplier = false;
+            factor = computingFontSize ? rootStyle->fontDescription().specifiedSize() : rootStyle->fontDescription().computedSize();
+            break;
+        case CSS_PX:
+            break;
+        case CSS_CM:
+            factor = cssPixelsPerInch / 2.54; // (2.54 cm/in)
+            break;
+        case CSS_MM:
+            factor = cssPixelsPerInch / 25.4;
+            break;
+        case CSS_IN:
+            factor = cssPixelsPerInch;
+            break;
+        case CSS_PT:
+            factor = cssPixelsPerInch / 72.0;
+            break;
+        case CSS_PC:
+            // 1 pc == 12 pt
+            factor = cssPixelsPerInch * 12.0 / 72.0;
+            break;
+        default:
+            return -1.0;
+    }
+
+    double result = getDoubleValue() * factor;
+    if (!applyZoomMultiplier || multiplier == 1.0)
+        return result;
+     
+    // Any original result that was >= 1 should not be allowed to fall below 1.  This keeps border lines from
+    // vanishing.
+    double zoomedResult = result * multiplier;
+    if (result >= 1.0)
+        zoomedResult = max(1.0, zoomedResult);
+    return zoomedResult;
+}
+
+void CSSPrimitiveValue::setFloatValue(unsigned short unitType, double floatValue, ExceptionCode& ec)
+{
+    ec = 0;
+
+    if (m_type < CSS_NUMBER || m_type > CSS_DIMENSION || unitType < CSS_NUMBER || unitType > CSS_DIMENSION) {
+        ec = INVALID_ACCESS_ERR;
+        return;
+    }
+
+    cleanup();
+
+    m_value.num = floatValue;
+    m_type = unitType;
+}
+
+static double scaleFactorForConversion(unsigned short unitType)
+{
+    double factor = 1.0;
+    switch (unitType) {
+        case CSSPrimitiveValue::CSS_PX:
+            break;
+        case CSSPrimitiveValue::CSS_CM:
+            factor = cssPixelsPerInch / 2.54; // (2.54 cm/in)
+            break;
+        case CSSPrimitiveValue::CSS_MM:
+            factor = cssPixelsPerInch / 25.4;
+            break;
+        case CSSPrimitiveValue::CSS_IN:
+            factor = cssPixelsPerInch;
+            break;
+        case CSSPrimitiveValue::CSS_PT:
+            factor = cssPixelsPerInch / 72.0;
+            break;
+        case CSSPrimitiveValue::CSS_PC:
+            factor = cssPixelsPerInch * 12.0 / 72.0; // 1 pc == 12 pt
+            break;
+        default:
+            break;
+    }
+
+    return factor;
+}
+
+double CSSPrimitiveValue::getDoubleValue(unsigned short unitType, ExceptionCode& ec)
+{
+    ec = 0;
+    if (m_type < CSS_NUMBER || m_type > CSS_DIMENSION || unitType < CSS_NUMBER || unitType > CSS_DIMENSION) {
+        ec = INVALID_ACCESS_ERR;
+        return 0.0;
+    }
+
+    if (unitType == m_type || unitType < CSS_PX || unitType > CSS_PC)
+        return m_value.num;
+
+    double convertedValue = m_value.num;
+
+    // First convert the value from m_type into CSSPixels
+    double factor = scaleFactorForConversion(m_type);
+    convertedValue *= factor;
+
+    // Now convert from CSSPixels to the specified unitType
+    factor = scaleFactorForConversion(unitType);
+    convertedValue /= factor;
+
+    return convertedValue;
+}
+
+double CSSPrimitiveValue::getDoubleValue(unsigned short unitType)
+{
+    if (m_type < CSS_NUMBER || m_type > CSS_DIMENSION || unitType < CSS_NUMBER || unitType > CSS_DIMENSION)
+        return 0;
+
+    if (unitType == m_type || unitType < CSS_PX || unitType > CSS_PC)
+        return m_value.num;
+
+    double convertedValue = m_value.num;
+
+    // First convert the value from m_type into CSSPixels
+    double factor = scaleFactorForConversion(m_type);
+    convertedValue *= factor;
+
+    // Now convert from CSSPixels to the specified unitType
+    factor = scaleFactorForConversion(unitType);
+    convertedValue /= factor;
+
+    return convertedValue;
+}
+
+
+void CSSPrimitiveValue::setStringValue(unsigned short stringType, const String& stringValue, ExceptionCode& ec)
+{
+    ec = 0;
+
+    if (m_type < CSS_STRING || m_type > CSS_ATTR || stringType < CSS_STRING || stringType > CSS_ATTR) {
+        ec = INVALID_ACCESS_ERR;
+        return;
+    }
+
+    cleanup();
+
+    if (stringType != CSS_IDENT) {
+        m_value.string = stringValue.impl();
+        m_value.string->ref();
+        m_type = stringType;
+    }
+    // FIXME: parse ident
+}
+
+String CSSPrimitiveValue::getStringValue(ExceptionCode& ec) const
+{
+    ec = 0;
+    switch (m_type) {
+        case CSS_STRING:
+        case CSS_ATTR:
+        case CSS_URI:
+        case CSS_PARSER_VARIABLE_FUNCTION_SYNTAX:
+            return m_value.string;
+        case CSS_IDENT:
+            return valueOrPropertyName(m_value.ident);
+        default:
+            ec = INVALID_ACCESS_ERR;
+            break;
+    }
+
+    return String();
+}
+
+String CSSPrimitiveValue::getStringValue() const
+{
+    switch (m_type) {
+        case CSS_STRING:
+        case CSS_ATTR:
+        case CSS_URI:
+        case CSS_PARSER_VARIABLE_FUNCTION_SYNTAX:
+             return m_value.string;
+        case CSS_IDENT:
+            return valueOrPropertyName(m_value.ident);
+        default:
+            break;
+    }
+
+    return String();
+}
+
+Counter* CSSPrimitiveValue::getCounterValue(ExceptionCode& ec) const
+{
+    ec = 0;
+    if (m_type != CSS_COUNTER) {
+        ec = INVALID_ACCESS_ERR;
+        return 0;
+    }
+
+    return m_value.counter;
+}
+
+Rect* CSSPrimitiveValue::getRectValue(ExceptionCode& ec) const
+{
+    ec = 0;
+    if (m_type != CSS_RECT) {
+        ec = INVALID_ACCESS_ERR;
+        return 0;
+    }
+
+    return m_value.rect;
+}
+
+PassRefPtr<RGBColor> CSSPrimitiveValue::getRGBColorValue(ExceptionCode& ec) const
+{
+    ec = 0;
+    if (m_type != CSS_RGBCOLOR) {
+        ec = INVALID_ACCESS_ERR;
+        return 0;
+    }
+
+    // FIMXE: This should not return a new object for each invocation.
+    return RGBColor::create(m_value.rgbcolor);
+}
+
+Pair* CSSPrimitiveValue::getPairValue(ExceptionCode& ec) const
+{
+    ec = 0;
+    if (m_type != CSS_PAIR) {
+        ec = INVALID_ACCESS_ERR;
+        return 0;
+    }
+
+    return m_value.pair;
+}
+
+unsigned short CSSPrimitiveValue::cssValueType() const
+{
+    return CSS_PRIMITIVE_VALUE;
+}
+
+bool CSSPrimitiveValue::parseString(const String& /*string*/, bool /*strict*/)
+{
+    // FIXME
+    return false;
+}
+
+int CSSPrimitiveValue::getIdent()
+{
+    if (m_type != CSS_IDENT)
+        return 0;
+    return m_value.ident;
+}
+
+String CSSPrimitiveValue::cssText() const
+{
+    // FIXME: return the original value instead of a generated one (e.g. color
+    // name if it was specified) - check what spec says about this
+
+    if (m_hasCachedCSSText) {
+        ASSERT(cssTextCache().contains(this));
+        return cssTextCache().get(this);
+    }
+
+    String text;
+    switch (m_type) {
+        case CSS_UNKNOWN:
+            // FIXME
+            break;
+        case CSS_NUMBER:
+        case CSS_PARSER_INTEGER:
+            text = String::number(m_value.num);
+            break;
+        case CSS_PERCENTAGE:
+            text = String::format("%.6lg%%", m_value.num);
+            break;
+        case CSS_EMS:
+            text = String::format("%.6lgem", m_value.num);
+            break;
+        case CSS_EXS:
+            text = String::format("%.6lgex", m_value.num);
+            break;
+        case CSS_REMS:
+            text = String::format("%.6lgrem", m_value.num);
+            break;
+        case CSS_PX:
+            text = String::format("%.6lgpx", m_value.num);
+            break;
+        case CSS_CM:
+            text = String::format("%.6lgcm", m_value.num);
+            break;
+        case CSS_MM:
+            text = String::format("%.6lgmm", m_value.num);
+            break;
+        case CSS_IN:
+            text = String::format("%.6lgin", m_value.num);
+            break;
+        case CSS_PT:
+            text = String::format("%.6lgpt", m_value.num);
+            break;
+        case CSS_PC:
+            text = String::format("%.6lgpc", m_value.num);
+            break;
+        case CSS_DEG:
+            text = String::format("%.6lgdeg", m_value.num);
+            break;
+        case CSS_RAD:
+            text = String::format("%.6lgrad", m_value.num);
+            break;
+        case CSS_GRAD:
+            text = String::format("%.6lggrad", m_value.num);
+            break;
+        case CSS_MS:
+            text = String::format("%.6lgms", m_value.num);
+            break;
+        case CSS_S:
+            text = String::format("%.6lgs", m_value.num);
+            break;
+        case CSS_HZ:
+            text = String::format("%.6lghz", m_value.num);
+            break;
+        case CSS_KHZ:
+            text = String::format("%.6lgkhz", m_value.num);
+            break;
+        case CSS_TURN:
+            text = String::format("%.6lgturn", m_value.num);
+            break;
+        case CSS_DIMENSION:
+            // FIXME
+            break;
+        case CSS_STRING:
+            text = quoteCSSStringIfNeeded(m_value.string);
+            break;
+        case CSS_URI:
+            text = "url(" + quoteCSSURLIfNeeded(m_value.string) + ")";
+            break;
+        case CSS_IDENT:
+            text = valueOrPropertyName(m_value.ident);
+            break;
+        case CSS_ATTR: {
+            DEFINE_STATIC_LOCAL(const String, attrParen, ("attr("));
+
+            Vector<UChar> result;
+            result.reserveInitialCapacity(6 + m_value.string->length());
+
+            append(result, attrParen);
+            append(result, m_value.string);
+            result.uncheckedAppend(')');
+
+            text = String::adopt(result);
+            break;
+        }
+        case CSS_COUNTER:
+            text = "counter(";
+            text += String::number(m_value.num);
+            text += ")";
+            // FIXME: Add list-style and separator
+            break;
+        case CSS_RECT: {
+            DEFINE_STATIC_LOCAL(const String, rectParen, ("rect("));
+
+            Rect* rectVal = getRectValue();
+            Vector<UChar> result;
+            result.reserveInitialCapacity(32);
+            append(result, rectParen);
+
+            append(result, rectVal->top()->cssText());
+            result.append(' ');
+
+            append(result, rectVal->right()->cssText());
+            result.append(' ');
+
+            append(result, rectVal->bottom()->cssText());
+            result.append(' ');
+
+            append(result, rectVal->left()->cssText());
+            result.append(')');
+
+            text = String::adopt(result);
+            break;
+        }
+        case CSS_RGBCOLOR:
+        case CSS_PARSER_HEXCOLOR: {
+            DEFINE_STATIC_LOCAL(const String, commaSpace, (", "));
+            DEFINE_STATIC_LOCAL(const String, rgbParen, ("rgb("));
+            DEFINE_STATIC_LOCAL(const String, rgbaParen, ("rgba("));
+
+            RGBA32 rgbColor = m_value.rgbcolor;
+            if (m_type == CSS_PARSER_HEXCOLOR)
+                Color::parseHexColor(m_value.string, rgbColor);
+            Color color(rgbColor);
+
+            Vector<UChar> result;
+            result.reserveInitialCapacity(32);
+            if (color.hasAlpha())
+                append(result, rgbaParen);
+            else
+                append(result, rgbParen);
+
+            appendNumber(result, static_cast<unsigned char>(color.red()));
+            append(result, commaSpace);
+
+            appendNumber(result, static_cast<unsigned char>(color.green()));
+            append(result, commaSpace);
+
+            appendNumber(result, static_cast<unsigned char>(color.blue()));
+            if (color.hasAlpha()) {
+                append(result, commaSpace);
+                append(result, String::number(color.alpha() / 256.0f));
+            }
+
+            result.append(')');
+            text = String::adopt(result);
+            break;
+        }
+        case CSS_PAIR:
+            text = m_value.pair->first()->cssText();
+            text += " ";
+            text += m_value.pair->second()->cssText();
+            break;
+#if ENABLE(DASHBOARD_SUPPORT)
+        case CSS_DASHBOARD_REGION:
+            for (DashboardRegion* region = getDashboardRegionValue(); region; region = region->m_next.get()) {
+                if (!text.isEmpty())
+                    text.append(' ');
+                text += "dashboard-region(";
+                text += region->m_label;
+                if (region->m_isCircle)
+                    text += " circle";
+                else if (region->m_isRectangle)
+                    text += " rectangle";
+                else
+                    break;
+                if (region->top()->m_type == CSS_IDENT && region->top()->getIdent() == CSSValueInvalid) {
+                    ASSERT(region->right()->m_type == CSS_IDENT);
+                    ASSERT(region->bottom()->m_type == CSS_IDENT);
+                    ASSERT(region->left()->m_type == CSS_IDENT);
+                    ASSERT(region->right()->getIdent() == CSSValueInvalid);
+                    ASSERT(region->bottom()->getIdent() == CSSValueInvalid);
+                    ASSERT(region->left()->getIdent() == CSSValueInvalid);
+                } else {
+                    text.append(' ');
+                    text += region->top()->cssText() + " ";
+                    text += region->right()->cssText() + " ";
+                    text += region->bottom()->cssText() + " ";
+                    text += region->left()->cssText();
+                }
+                text += ")";
+            }
+            break;
+#endif
+        case CSS_PARSER_VARIABLE_FUNCTION_SYNTAX:
+            text = "-webkit-var(";
+            text += m_value.string;
+            text += ")";
+            break;
+        case CSS_PARSER_OPERATOR: {
+            char c = static_cast<char>(m_value.ident);
+            text = String(&c, 1U);
+            break;
+        }
+        case CSS_PARSER_IDENTIFIER:
+            text = quoteCSSStringIfNeeded(m_value.string);
+            break;
+    }
+
+    ASSERT(!cssTextCache().contains(this));
+    cssTextCache().set(this, text);
+    m_hasCachedCSSText = true;
+    return text;
+}
+
+CSSParserValue CSSPrimitiveValue::parserValue() const
+{
+    // We only have to handle a subset of types.
+    CSSParserValue value;
+    value.id = 0;
+    value.isInt = false;
+    value.unit = CSSPrimitiveValue::CSS_IDENT;
+    switch (m_type) {
+        case CSS_NUMBER:
+        case CSS_PERCENTAGE:
+        case CSS_EMS:
+        case CSS_EXS:
+        case CSS_REMS:
+        case CSS_PX:
+        case CSS_CM:
+        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_DIMENSION:
+        case CSS_TURN:
+            value.fValue = m_value.num;
+            value.unit = m_type;
+            break;
+        case CSS_STRING:
+        case CSS_URI:
+        case CSS_PARSER_VARIABLE_FUNCTION_SYNTAX:
+        case CSS_PARSER_HEXCOLOR:
+            value.string.characters = const_cast<UChar*>(m_value.string->characters());
+            value.string.length = m_value.string->length();
+            value.unit = m_type;
+            break;
+        case CSS_IDENT: {
+            value.id = m_value.ident;
+            const AtomicString& name = valueOrPropertyName(m_value.ident);
+            value.string.characters = const_cast<UChar*>(name.characters());
+            value.string.length = name.length();
+            break;
+        }
+        case CSS_PARSER_OPERATOR:
+            value.iValue = m_value.ident;
+            value.unit = CSSParserValue::Operator;
+            break;
+        case CSS_PARSER_INTEGER:
+            value.fValue = m_value.num;
+            value.unit = CSSPrimitiveValue::CSS_NUMBER;
+            value.isInt = true;
+            break;
+        case CSS_PARSER_IDENTIFIER:
+            value.string.characters = const_cast<UChar*>(m_value.string->characters());
+            value.string.length = m_value.string->length();
+            value.unit = CSSPrimitiveValue::CSS_IDENT;
+            break;
+        case CSS_UNKNOWN:
+        case CSS_ATTR:
+        case CSS_COUNTER:
+        case CSS_RECT:
+        case CSS_RGBCOLOR:
+        case CSS_PAIR:
+#if ENABLE(DASHBOARD_SUPPORT)
+        case CSS_DASHBOARD_REGION:
+#endif
+            ASSERT_NOT_REACHED();
+            break;
+    }
+    
+    return value;
+}
+
+void CSSPrimitiveValue::addSubresourceStyleURLs(ListHashSet<KURL>& urls, const CSSStyleSheet* styleSheet)
+{
+    if (m_type == CSS_URI)
+        addSubresourceURL(urls, styleSheet->completeURL(m_value.string));
+}
+
+} // namespace WebCore